Changeset 115


Ignore:
Timestamp:
Mar 16, 2008, 10:51:54 PM (10 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.
Location:
abuse/trunk/src
Files:
14 edited

Legend:

Unmodified
Added
Removed
  • abuse/trunk/src/automap.cpp

    r111 r115  
    5959  if (draw_xstart==old_dx && draw_ystart==old_dy) 
    6060  {
     61   automap_window->screen->lock();
    6162   automap_window->screen->add_dirty(centerx,centery,centerx,centery);
    6263    if ((tick++)&4)
     
    6465    else
    6566      automap_window->screen->putpixel(centerx,centery,27);
     67   automap_window->screen->unlock();
    6668    return ;   
    6769  }
     
    138140
    139141
    140   // draw the person as a dot, no need to add a dirty because we marked the whole screen already
     142  // draw the person as a dot, no need to add a dirty because we marked the
     143  // whole screen already
     144  automap_window->screen->lock();
    141145  if ((tick++)&4)
    142146    automap_window->screen->putpixel(centerx,centery,255);
    143147  else
    144148    automap_window->screen->putpixel(centerx,centery,27);
     149  automap_window->screen->unlock();
    145150
    146151  // set the clip back to full window size because soemthing else could mess with the area
  • abuse/trunk/src/dev.cpp

    r113 r115  
    391391    new_height-=y+new_height-cy2;
    392392
    393 
     393  screen->lock();
     394  im->lock();
    394395  for (iy=iy_start;new_height>0;new_height--,y++,iy+=ystep)
    395396  {
     
    399400      *sl2=sl1[ix>>16];
    400401  }
     402  im->unlock();
     403  screen->unlock();
    401404}
    402405
     
    431434
    432435  uint8_t d;
     436  screen->lock();
    433437  for (iy=iy_start;new_height>0;new_height--,y++,iy+=ystep)
    434438  {
     
    442446    }
    443447  }
     448  screen->unlock();
    444449}
    445450
  • abuse/trunk/src/game.cpp

    r113 r115  
    897897      else
    898898        screen->clear(wm->black());
     899      screen->lock();
    899900      for(y = y1, draw_y = yo; y <= y2; y++, draw_y += yinc)
    900901      {
     
    921922    }
    922923      }
     924      screen->unlock();
    923925
    924926      if(dev & EDIT_MODE)
  • abuse/trunk/src/imlib/filter.cpp

    r114 r115  
    9898int color_compare(void *c1, void *c2)
    9999{
    100   long v1,v2; 
     100  long v1,v2;
    101101  unsigned char r1,g1,b1,r2,g2,b2;
    102102  compare_pal->get(  *((unsigned char *)c1),r1,g1,b1);
     
    106106  if (v1<v2) return -1;
    107107  else if (v1>v2) return 1;
    108   else return 0;     
     108  else return 0;
    109109}
    110110
     
    114114  unsigned char map[256],*last_start,*start;
    115115  int i,last_color=0,color;
    116   compare_pal=pal; 
     116  compare_pal=pal;
    117117  for (i=0;i,256;i++)
    118118    map[i]=i;
    119119
    120   qsort(map,1,1,color_compare); 
     120  qsort(map,1,1,color_compare);
    121121  colors=1<<color_bits;
    122122  last_start=color_table=(unsigned char *)malloc(colors*colors*colors);
    123123
    124  
    125  
     124
     125
    126126  last_color=map[0];
    127127  last_dist=0;
    128  
    129  
     128
     129
    130130  for (i=1;i<colors;i++)
    131   {   
     131  {
    132132    color=map[i<<(8-color_bits)];
    133     dist=       
     133    dist=
    134134
    135135    memset(c,
    136136  }
    137  
    138  
     137
     138
    139139}*/
    140140
    141141
    142142color_filter::color_filter(palette *pal, int color_bits, void (*stat_fun)(int))
    143 { 
     143{
    144144  color_bits=5;      // hard code 5 for now
    145145  int r,g,b,rv,gv,bv,
     
    147147      lshift=8-color_bits;
    148148  unsigned char *pp;
    149  
     149
    150150  long dist_sqr,best;
    151151  int colors=1<<color_bits;
     
    154154  {
    155155    if (stat_fun) stat_fun(r);
    156     rv=r<<lshift;   
     156    rv=r<<lshift;
    157157    for (g=0;g<colors;g++)
    158158    {
    159       gv=g<<lshift;     
     159      gv=g<<lshift;
    160160      for (b=0;b<colors;b++)
    161161      {
    162         bv=b<<lshift;     
     162        bv=b<<lshift;
    163163        best=0x7fffffff;
    164164        for (i=0,pp=(unsigned char *)pal->addr();i<max;i++)
    165         { 
     165        {
    166166          register long rd=*(pp++)-rv,
    167167                        gd=*(pp++)-gv,
    168168                        bd=*(pp++)-bv;
    169          
     169       
    170170          dist_sqr=(long)rd*rd+(long)bd*bd+(long)gd*gd;
    171171          if (dist_sqr<best)
     
    177177      }
    178178    }
    179   } 
     179  }
    180180}
    181181
     
    203203
    204204
    205 void filter::put_image(image *screen, image *im, short x, short y, char transparent)
    206 {
    207   short cx1,cy1,cx2,cy2,x1=0,y1=0,x2=im->width()-1,y2=im->height()-1;
    208   screen->get_clip(cx1,cy1,cx2,cy2);
    209  
    210   // see if the image gets clipped off the screen
    211   if (x>cx2 || y>cy2 || x+(x2-x1)<cx1 || y+(y2-y1)<cy1) return ;
    212  
    213   if (x<cx1)
    214   { x1+=(cx1-x); x=cx1; }
    215   if (y<cy1)
    216   { y1+=(cy1-y); y=cy1; }
    217 
    218   if (x+x2-x1+1>cx2)
    219   { x2=cx2-x+x1; }
    220 
    221   if (y+y2-y1+1>cy2)
    222   { y2=cy2-y+y1; }
    223   if (x1>x2 || y1>y2) return ;   
    224 
    225  
    226 
    227 
    228   int xl=x2-x1+1;
    229   int yl=y2-y1+1;
    230 
    231   screen->add_dirty(x,y,x+xl-1,y+yl-1);
    232 
    233   uint8_t *pg1=screen->scan_line(y),*source,*dest;
    234   uint8_t *pg2=im->scan_line(y1);
    235   int i;
    236   for (int j=0;j<yl;j++)       
    237   {
    238     for (i=0,source=&pg2[x1],dest=&pg1[x];i<xl;i++,source++,dest++)     
    239       if (!transparent || *source!=current_background)
    240         *dest=fdat[*source];
    241     pg1=screen->next_line(y+j,pg1); 
    242     pg2=im->next_line(y1+j,pg2);
    243   }
    244 
    245 }
    246 
    247 
    248 
    249 
    250 
     205void filter::put_image(image *screen, image *im, short x, short y,
     206                       char transparent)
     207{
     208    short cx1, cy1, cx2, cy2, x1 = 0, y1 = 0,
     209          x2 = im->width() - 1, y2 = im->height() - 1;
     210    screen->get_clip(cx1,cy1,cx2,cy2);
     211
     212    // see if the image gets clipped off the screen
     213    if(x > cx2 || y > cy2 || x + (x2 - x1) < cx1 || y + (y2 - y1) < cy1)
     214        return;
     215
     216    if(x < cx1)
     217    {
     218        x1 += (cx1 - x);
     219        x = cx1;
     220    }
     221    if(y < cy1)
     222    {
     223        y1 += (cy1 - y);
     224         y = cy1;
     225    }
     226
     227    if(x + x2 - x1 + 1 > cx2)
     228        x2 = cx2 - x + x1;
     229
     230    if(y + y2 - y1 + 1 > cy2)
     231        y2 = cy2 - y + y1;
     232
     233    if(x1 > x2 || y1 > y2)
     234        return;
     235
     236    int xl = x2 - x1 + 1;
     237    int yl = y2 - y1 + 1;
     238
     239    screen->add_dirty(x, y, x + xl - 1, y + yl - 1);
     240
     241    screen->lock();
     242    im->lock();
     243
     244    uint8_t *pg1 = screen->scan_line(y), *source, *dest;
     245    uint8_t *pg2 = im->scan_line(y1);
     246    int i;
     247    for(int j = 0; j < yl; j++)
     248    {
     249        for(i = 0, source = &pg2[x1], dest = &pg1[x];
     250            i < xl;
     251            i++, source++, dest++)     
     252        {
     253            if(!transparent || *source != current_background)
     254                *dest=fdat[*source];
     255        }
     256        pg1 = screen->next_line(y + j, pg1);
     257        pg2 = im->next_line(y1 + j, pg2);
     258    }
     259
     260    im->unlock();
     261    screen->unlock();
     262}
     263
  • abuse/trunk/src/imlib/glread.cpp

    r56 r115  
    4141  while (first<=last)
    4242  {
     43    sub->lock();
    4344    for (y=0;(int)y<(int)height;y++)
    4445    {
     
    4647      sub->unpack_scanline(y);
    4748    }
     49    sub->unlock();
    4850    sub->put_image(im,(first%32)*width,(first/32)*height);
    4951    first++;
     
    5557image *read_pic(char *fn, palette *&pal)
    5658{
    57   image *im;
     59  image *im = NULL;
    5860  char x[4],bpp;
    5961  uint8_t *sl=NULL,esc,c,n,marker,vmode;
     
    6163  int xx,yy;
    6264  FILE *fp;
    63   im=NULL;
    6465  fp=fopen(fn,"rb");
    6566
     
    7475  { fclose(fp); set_error(imFILE_CORRUPTED); return NULL; }
    7576
    76   im=new image(w,h);
     77  im = new image(w, h);
    7778
    7879  fread(&vmode,1,1,fp);
     
    9293
    9394  yy=h; xx=w;
     95
     96  im->lock();
    9497
    9598  while (blocks-- && w>=1 && yy>=0)
     
    137140    }
    138141  }
     142
     143  im->unlock();
     144
    139145  fclose(fp);
    140146  return im;
  • abuse/trunk/src/imlib/image.cpp

    r114 r115  
    3636    "Error occurred while writing, (disk full?)"
    3737};
    38                        
     38           
    3939                         
    4040int16_t imerror=0;
     
    4949  { printf("Program stopped, error : ");
    5050    if (imerror<=imMAX_ERROR)
    51       printf("%s\n",imerr_messages[imerror]);
     51      printf("%s\n", imerr_messages[imerror]);
    5252    else
    5353      printf("Unsonsponsered error code, you got trouble\n");
     
    5757    nosound();
    5858#else
    59     printf("%c%c\n",7,8);
     59    printf("%c%c\n", 7, 8);
    6060#endif
    6161    exit(1);
     
    7878
    7979image_descriptor::image_descriptor(int16_t length, int16_t height,
    80                                    int keep_dirties, int static_memory)
     80                   int keep_dirties, int static_memory)
    8181
    8282{ clipx1=0; clipy1=0;
     
    9292  w=new_width;
    9393  h=new_height;
    94   make_page(new_width,new_height,page);
     94  make_page(new_width, new_height, page);
    9595}
    9696
    9797image::~image()
    9898{
    99   image_list.unlink((linked_node *)this);
    100   delete_page();
    101   if (special)
    102     delete special;
    103 
     99    if(_locked)
     100    {
     101        fprintf(stderr, "Error: image is locked upon deletion\n");
     102        unlock();
     103    }
     104
     105    image_list.unlink((linked_node *)this);
     106    delete_page();
     107    if(special)
     108        delete special;
    104109}
    105110
     
    107112void make_block(size_t size)
    108113{
    109   void *dat=jmalloc(size,"make_block : tmp");
    110   CONDITION(dat,"Memory error : could not make block\n");
     114  void *dat=jmalloc(size, "make_block : tmp");
     115  CONDITION(dat, "Memory error : could not make block\n");
    111116  if (dat) jfree((char *)dat);
    112117}
     
    125130  if (special)
    126131  { if (x>=special->x1_clip() && x<=special->x2_clip() &&
    127         y>=special->y1_clip() && y<=special->y2_clip())
     132    y>=special->y1_clip() && y<=special->y2_clip())
    128133      (*(scan_line(y)+x))=color;
    129134  } else (*(scan_line(y)+x))=color;
     
    138143  {
    139144    if (create_descriptor==2)
    140       special=new image_descriptor(width,height,1,(page_buffer!=NULL));
    141     else special=new image_descriptor(width,height,0,(page_buffer!=NULL));
     145      special=new image_descriptor(width, height, 1, (page_buffer!=NULL));
     146    else special=new image_descriptor(width, height, 0, (page_buffer!=NULL));
    142147  } else special=NULL;
    143   make_page(width,height,page_buffer);
     148  make_page(width, height, page_buffer);
    144149  image_list.add_end((linked_node *) this);
     150    _locked = false;
    145151}
    146152
     
    148154{
    149155  int16_t i;
    150   fp->seek(e->offset,0);
     156  fp->seek(e->offset, 0);
    151157  w=fp->read_uint16();
    152158  h=fp->read_uint16();
    153159  special=NULL;
    154   make_page(w,h,NULL);
    155   for (i=0;i<h;i++)
    156     fp->read(scan_line(i),w);
     160  make_page(w, h, NULL);
     161  for (i=0; i<h; i++)
     162    fp->read(scan_line(i), w);
    157163  image_list.add_end((linked_node *) this);
     164    _locked = false;
    158165}
    159166
     
    164171  h=fp->read_uint16();
    165172  special=NULL;
    166   make_page(w,h,NULL);
    167   for (i=0;i<h;i++)
    168     fp->read(scan_line(i),w);
     173  make_page(w, h, NULL);
     174  for (i=0; i<h; i++)
     175    fp->read(scan_line(i), w);
    169176  image_list.add_end((linked_node *) this);
     177    _locked = false;
     178}
     179
     180void image::lock()
     181{
     182    /* This is currently a no-op, because it's unneeded with SDL */
     183
     184    if(_locked)
     185        fprintf(stderr, "Trying to lock a locked picture!\n");
     186    _locked = true;
     187}
     188
     189void image::unlock()
     190{
     191    /* This is currently a no-op, because it's unneeded with SDL */
     192
     193    if(!_locked)
     194        fprintf(stderr, "Trying to unlock an unlocked picture!\n");
     195    _locked = false;
    170196}
    171197
    172198void image_uninit()
    173199{
     200    /* FIXME: is this used at all? */
    174201/*  image *im;
    175202  while (image_list.first())
     
    188215{
    189216  uint8_t bt[2];
    190   uint16_t wrd,*up;
     217  uint16_t wrd, *up;
    191218  bt[0]=1;
    192219  bt[1]=0;
     
    195222  if (wrd!=0x01)
    196223  { printf("compiled with wrong endianness, edit system.h and try again\n");
    197     printf("1 (intel) = %d\n",(int)wrd);
     224    printf("1 (intel) = %d\n", (int)wrd);
    198225    exit(1);
    199226  }
     
    204231int32_t image::total_pixels(uint8_t background)
    205232{
    206   int16_t i,j;
    207   int32_t co;
    208   uint8_t *c;
    209   for (co=0,i=height()-1;i>=0;i--)
    210   { c=scan_line(i);
    211     for (j=width()-1;j>=0;j--,c++)
    212       if (*c!=background) co++;
    213   }
    214   return co;
     233    int16_t i, j;
     234    int32_t co;
     235    uint8_t *c;
     236
     237    lock();
     238    for(co = 0, i = height() - 1; i >= 0; i--)
     239    {
     240        c = scan_line(i);
     241        for(j = width() - 1; j >= 0; j--, c++)
     242            if(*c != background) co++;
     243    }
     244    unlock();
     245    return co;
    215246}
    216247
    217248void image::clear(int16_t color)
    218249{
    219   int16_t i;
    220   if (color==-1) color=current_background;
    221   if (special)
    222   { if (special->x1_clip()<=special->x2_clip())
    223       for (i=special->y2_clip();i>=special->y1_clip();i--)
    224         memset(scan_line(i)+special->x1_clip(),color,
    225                special->x2_clip()-special->x1_clip()+1);
    226   }
    227   else
    228     for (i=height()-1;i>=0;i--)
    229       memset(scan_line(i),color,width());
    230   add_dirty(0,0,width()-1,height()-1);
    231 }
    232 
     250    int16_t i;
     251
     252    lock();
     253    if(color == -1)
     254        color = current_background;
     255    if(special)
     256    {
     257        if(special->x1_clip() <= special->x2_clip())
     258            for(i = special->y2_clip(); i >= special->y1_clip(); i--)
     259                memset(scan_line(i) + special->x1_clip(), color,
     260                       special->x2_clip() - special->x1_clip() + 1);
     261    }
     262    else
     263        for(i = height() - 1; i >= 0; i--)
     264            memset(scan_line(i), color, width());
     265    add_dirty(0, 0, width() - 1, height() - 1);
     266    unlock();
     267}
    233268
    234269image *image::copy()
    235270{
    236   image *im;
    237   uint8_t *c,*dat;
    238   int i;
    239   dat=(uint8_t *)jmalloc(width(),"image copy");
    240   im=new image(width(),height());
    241   for (i=height()-1;i>=0;i--)
    242   { c=scan_line(i);
    243     memcpy(dat,c,width());
    244     c=im->scan_line(i);
    245     memcpy(c,dat,width());
    246   }
    247   jfree((char *)dat);
    248   return im;
    249 }
    250 
    251 
    252 
    253 void image::line(int16_t x1, int16_t y1,int16_t x2, int16_t y2, uint8_t color)
    254 {
    255   int16_t i,xc,yc,er,n,m,xi,yi,xcxi,ycyi,xcyi;
    256   unsigned dcy,dcx;
     271    image *im;
     272    uint8_t *c, *dat;
     273    int i;
     274
     275    lock();
     276    dat = (uint8_t *)jmalloc(width(), "image copy");
     277    im = new image(width(), height());
     278    im->lock();
     279    for(i = height() - 1; i >= 0; i--)
     280    {
     281        c = scan_line(i);
     282        memcpy(dat, c, width());
     283        c = im->scan_line(i);
     284        memcpy(c, dat, width());
     285    }
     286    im->unlock();
     287    unlock();
     288    jfree((char *)dat);
     289    return im;
     290}
     291
     292void image::line(int16_t x1, int16_t y1, int16_t x2, int16_t y2, uint8_t color)
     293{
     294  int16_t i, xc, yc, er, n, m, xi, yi, xcxi, ycyi, xcyi;
     295  unsigned dcy, dcx;
    257296  // check to make sure that both endpoint are on the screen
    258297
    259   int16_t cx1,cy1,cx2,cy2;
     298  int16_t cx1, cy1, cx2, cy2;
    260299
    261300  // check to see if the line is completly clipped off
    262   get_clip(cx1,cy1,cx2,cy2); 
     301  get_clip(cx1, cy1, cx2, cy2); 
    263302  if ((x1<cx1 && x2<cx1) || (x1>cx2 && x2>cx2) ||
    264303      (y1<cy1 && y2<cy1) || (y1>cy2 && y2>cy2))
     
    275314  { 
    276315    int my=(y2-y1);       
    277     int mx=(x2-x1),b;
     316    int mx=(x2-x1), b;
    278317    if (!mx) return ;
    279318    if (my)
     
    290329  { 
    291330    int my=(y2-y1);       
    292     int mx=(x2-x1),b;
     331    int mx=(x2-x1), b;
    293332    if (!mx) return ;
    294333    if (my)
     
    311350  { 
    312351    int mx=(x2-x1);       
    313     int my=(y2-y1),b;
     352    int my=(y2-y1), b;
    314353    if (!my)
    315354      return ;
     
    327366  { 
    328367    int mx=(x2-x1);       
    329     int my=(y2-y1),b;
     368    int my=(y2-y1), b;
    330369    if (!my) return ;
    331370    if (mx)
     
    353392  yi=y2; yc=y1;
    354393
    355   add_dirty(xc,yc,xi,yi);
     394  add_dirty(xc, yc, xi, yi);
    356395  dcx=x1; dcy=y1;
    357396  xc=(x2-x1); yc=(y2-y1);
     
    362401  er=0;
    363402
     403  lock();
    364404  if (n>m)
    365405  {
    366406    xcxi=abs(2*xc*xi);
    367     for (i=0;i<=n;i++)
     407    for (i=0; i<=n; i++)
    368408    {
    369409      *(scan_line(dcy)+dcx)=color;
    370410      if (er>0)
    371411      { dcy+=yi;
    372         er-=xcxi;
     412    er-=xcxi;
    373413      }
    374414      er+=ycyi;
     
    379419  {
    380420    xcyi=abs(2*xc*yi);
    381     for (i=0;i<=m;i++)
     421    for (i=0; i<=m; i++)
    382422    {
    383423      *(scan_line(dcy)+dcx)=color;
    384424      if (er>0)
    385425      { dcx+=xi;
    386         er-=ycyi;
     426    er-=ycyi;
    387427      }
    388428      er+=xcyi;
     
    390430    }
    391431  }
     432  unlock();
    392433}
    393434
     
    395436void image::put_image(image *screen, int16_t x, int16_t y, char transparent)
    396437{
    397   int16_t i,j,xl,yl;
    398   uint8_t *pg1,*pg2,*source,*dest;
    399   if (screen->special)  // the screen is clipped then we onl want to put
    400                     // part of the image
    401     put_part(screen,x,y,0,0,width()-1,height()-1,transparent);
    402   else
    403   {
    404     if (x<screen->width() && y<screen->height())
    405     {
    406       xl=width();
    407       if (x+xl>screen->width())     // clip to the border of the screen
    408         xl=screen->width()-x;
    409       yl=height();
    410       if (y+yl>screen->height())
    411         yl=screen->height()-y;
    412 
    413       int startx=0,starty=0;
    414       if (x<0) { startx=-x; x=0; }
    415       if (y<0) { starty=-y; y=0; }
    416 
    417       if (xl<0 || yl<0) return ;
    418 
    419       screen->add_dirty(x,y,x+xl-1,y+yl-1);
    420       for (j=starty;j<yl;j++,y++)
    421       {
    422         pg1=screen->scan_line(y);
    423         pg2=scan_line(j);
    424         if (transparent)
    425         {
    426           for (i=startx,source=pg2+startx,dest=pg1+x;i<xl;i++,source++,dest++)
    427             if (*source!=current_background) *dest=*source;
    428         } else memcpy(&pg1[x],pg2,xl);   // strait copy
    429       }
    430     }
    431   }
     438    int16_t i, j, xl, yl;
     439    uint8_t *pg1, *pg2, *source, *dest;
     440
     441    // the screen is clipped then we only want to put part of the image
     442    if(screen->special)
     443    {
     444        put_part(screen, x, y, 0, 0, width()-1, height()-1, transparent);
     445        return;
     446    }
     447
     448    if(x < screen->width() && y < screen->height())
     449    {
     450        xl = width();
     451        if(x + xl > screen->width()) // clip to the border of the screen
     452            xl = screen->width() - x;
     453        yl = height();
     454        if(y + yl > screen->height())
     455            yl = screen->height() - y;
     456
     457        int startx = 0, starty = 0;
     458        if(x < 0)
     459        {
     460            startx = -x;
     461            x = 0;
     462        }
     463        if(y < 0)
     464        {
     465            starty = -y;
     466            y = 0;
     467        }
     468
     469        if(xl < 0 || yl < 0)
     470            return;
     471
     472        screen->add_dirty(x, y, x + xl - 1, y + yl - 1);
     473        screen->lock();
     474        lock();
     475        for(j = starty; j < yl; j++, y++)
     476        {
     477            pg1 = screen->scan_line(y);
     478            pg2 = scan_line(j);
     479            if(transparent)
     480            {
     481                for(i = startx, source = pg2+startx, dest = pg1 + x;
     482                    i < xl;
     483                    i++, source++, dest++)
     484                {
     485                    if(*source != current_background)
     486                        *dest = *source;
     487                }
     488            }
     489            else
     490                memcpy(&pg1[x], pg2, xl); // straight copy
     491        }
     492        unlock();
     493        screen->unlock();
     494    }
    432495}
    433496
    434497void image::fill_image(image *screen, int16_t x1, int16_t y1, int16_t x2, int16_t y2, int16_t align)
    435498{
    436   int16_t i,j,w,xx,start,xl,starty;
    437   uint8_t *pg1,*pg2;
     499  int16_t i, j, w, xx, start, xl, starty;
     500  uint8_t *pg1, *pg2;
    438501  CHECK(x1<=x2 && y1<=y2);  // we should have gotten this
    439502
     
    452515  if (x2<0 || y2<0 || x1>=screen->width() || y1>=screen->height())
    453516    return ;
    454   screen->add_dirty(x1,y1,x2,y2);
     517  screen->add_dirty(x1, y1, x2, y2);
    455518  w=width();
    456519  if (align)
     
    463526    starty=0;
    464527  }
    465   for (j=y1;j<=y2;j++)
     528  screen->lock();
     529  lock();
     530  for (j=y1; j<=y2; j++)
    466531  {
    467532    pg1=screen->scan_line(j);
     
    472537    while (i<=x2)
    473538    {
    474       xl=min(w-xx,x2-i+1);
    475 
    476       memcpy(&pg1[i],&pg2[xx],xl);
     539      xl=min(w-xx, x2-i+1);
     540
     541      memcpy(&pg1[i], &pg2[xx], xl);
    477542      xx=0;
    478543      i+=xl;
    479544    }
    480545  }
     546  unlock();
     547  screen->unlock();
    481548}
    482549
    483550
    484551void image::put_part(image *screen, int16_t x, int16_t y,
    485                 int16_t x1, int16_t y1, int16_t x2, int16_t y2, char transparent)
    486 {
    487   int16_t xl,yl,j,i;
    488   int16_t cx1,cy1,cx2,cy2;
    489   uint8_t *pg1,*pg2,*source,*dest;
     552        int16_t x1, int16_t y1, int16_t x2, int16_t y2, char transparent)
     553{
     554  int16_t xlen, ylen, j, i;
     555  int16_t cx1, cy1, cx2, cy2;
     556  uint8_t *pg1, *pg2, *source, *dest;
    490557  CHECK(x1<=x2 && y1<=y2);
    491558
    492   screen->get_clip(cx1,cy1,cx2,cy2);
     559  screen->get_clip(cx1, cy1, cx2, cy2);
    493560
    494561
     
    521588
    522589
    523   xl=x2-x1+1;
    524   yl=y2-y1+1;
    525 
    526   screen->add_dirty(x,y,x+xl-1,y+yl-1);
    527 
     590  xlen=x2-x1+1;
     591  ylen=y2-y1+1;
     592
     593  screen->add_dirty(x, y, x+xlen-1, y+ylen-1);
     594
     595  screen->lock();
     596  lock();
    528597  pg1=screen->scan_line(y);
    529598  pg2=scan_line(y1);
     
    531600  if (transparent)
    532601  {
    533     for (j=0;j<yl;j++)       
    534     {
    535       for (i=0,source=&pg2[x1],dest=&pg1[x];i<xl;i++,source++,dest++)   
     602    for (j=0; j<ylen; j++)       
     603    {
     604      for (i=0, source=&pg2[x1], dest=&pg1[x]; i<xlen; i++, source++, dest++)   
    536605        if (*source!=current_background) *dest=*source;
    537       pg1=screen->next_line(y+j,pg1); 
    538       pg2=next_line(y1+j,pg2);
     606      pg1=screen->next_line(y+j, pg1); 
     607      pg2=next_line(y1+j, pg2);
    539608    }     
    540609  }
    541610  else
    542   for (j=0;j<yl;j++)
    543   {     
    544     memcpy(&pg1[x],&pg2[x1],xl);   // strait copy
    545     pg1=screen->next_line(y+j,pg1); 
    546     pg2=next_line(y1+j,pg2);
     611  for (j=0; j<ylen; j++)
     612  {   
     613    memcpy(&pg1[x], &pg2[x1], xlen);   // strait copy
     614    pg1=screen->next_line(y+j, pg1); 
     615    pg2=next_line(y1+j, pg2);
    547616  }   
     617  unlock();
     618  screen->unlock();
    548619}
    549620
    550621void image::put_part_xrev(image *screen, int16_t x, int16_t y,
    551                 int16_t x1, int16_t y1, int16_t x2, int16_t y2, char transparent)
    552 {
    553   int16_t xl,yl,j,i;
    554   int16_t cx1,cy1,cx2,cy2;
    555   uint8_t *pg1,*pg2,*source,*dest;
     622        int16_t x1, int16_t y1, int16_t x2, int16_t y2, char transparent)
     623{
     624  int16_t xl, yl, j, i;
     625  int16_t cx1, cy1, cx2, cy2;
     626  uint8_t *pg1, *pg2, *source, *dest;
    556627  CHECK(x1<=x2 && y1<=y2);
    557628
     
    566637  if (screen->special)
    567638  {
    568     screen->special->get_clip(cx1,cy1,cx2,cy2);
     639    screen->special->get_clip(cx1, cy1, cx2, cy2);
    569640    if (x>cx2 || y>cy2 || x+(x2-x1)<0 || y+(y2-y1)<0) return ;
    570641    if (x<cx1)
     
    593664    if (y+yl>screen->height())
    594665      yl=screen->height()-y;
    595     screen->add_dirty(x,y,x+xl-1,y+yl-1);
    596     for (j=0;j<yl;j++)
     666    screen->add_dirty(x, y, x+xl-1, y+yl-1);
     667    screen->lock();
     668    lock();
     669    for (j=0; j<yl; j++)
    597670    {
    598671      pg1=screen->scan_line(y+j);
     
    600673      if (transparent)
    601674      {
    602         for (i=0,source=&pg2[x1],dest=&pg1[x+xl-1];i<xl;i++,source++,dest--)
     675    for (i=0, source=&pg2[x1], dest=&pg1[x+xl-1]; i<xl; i++, source++, dest--)
    603676          if (*source!=current_background) *dest=*source;
    604677      }
    605678      else
    606         for (i=0,source=&pg2[x1],dest=&pg1[x+xl-1];i<xl;i++,source++,dest++)
     679    for (i=0, source=&pg2[x1], dest=&pg1[x+xl-1]; i<xl; i++, source++, dest++)
    607680          *dest=*source;
    608681    }
     682    unlock();
     683    screen->unlock();
    609684  }
    610685}
     
    612687
    613688void image::put_part_masked(image *screen, image *mask, int16_t x, int16_t y,
    614                 int16_t maskx, int16_t masky,
    615                 int16_t x1, int16_t y1, int16_t x2, int16_t y2)
    616 {
    617   int16_t xl,yl,j,i,ml,mh;
    618   int16_t cx1,cy1,cx2,cy2;
    619   uint8_t *pg1,*pg2,*pg3;
     689        int16_t maskx, int16_t masky,
     690        int16_t x1, int16_t y1, int16_t x2, int16_t y2)
     691{
     692  int16_t xl, yl, j, i, ml, mh;
     693  int16_t cx1, cy1, cx2, cy2;
     694  uint8_t *pg1, *pg2, *pg3;
    620695  CHECK(x1<=x2 && y1<=y2);
    621696
    622697  if (screen->special)
    623698  {
    624     screen->special->get_clip(cx1,cy1,cx2,cy2);
     699    screen->special->get_clip(cx1, cy1, cx2, cy2);
    625700    if (x>cx2 || y>cy2 || x+(x2-x1)<0 || y+(y2-y1)<0) return ;
    626701    if (x<cx1)
     
    652727    if (y+yl>screen->height())
    653728      yl=screen->height()-y-1;
    654     screen->add_dirty(x,y,x+xl-1,y+yl-1);
    655     for (j=0;j<yl;j++)
     729    screen->add_dirty(x, y, x+xl-1, y+yl-1);
     730    screen->lock();
     731    mask->lock();
     732    lock();
     733    for (j=0; j<yl; j++)
    656734    {
    657735      pg1=screen->scan_line(y+j);
     
    659737      pg3=mask->scan_line(masky++);
    660738      if (masky>=mh)           // wrap the mask around if out of bounds
    661         masky=0;
    662       for (i=0;i<xl;i++)
     739    masky=0;
     740      for (i=0; i<xl; i++)
    663741      {
    664         if (pg3[maskx+i])          // check to make sure not 0 before putting
    665           pg1[x+i]=pg2[x1+i];
    666         if (maskx>=ml)            // wrap x around if it goes to far
    667           maskx=0;
     742    if (pg3[maskx+i])          // check to make sure not 0 before putting
     743      pg1[x+i]=pg2[x1+i];
     744    if (maskx>=ml)            // wrap x around if it goes to far
     745      maskx=0;
    668746      }
    669747    }
     748    unlock();
     749    mask->unlock();
     750    screen->unlock();
    670751  }
    671752}
     
    674755
    675756uint8_t image::brightest_color(palette *pal)
    676 { uint8_t *p,r,g,b,bri;
    677   int16_t i,j;
     757{ uint8_t *p, r, g, b, bri;
     758  int16_t i, j;
    678759  int32_t brv;
    679760  brv=0; bri=0;
    680   for (j=0;j<h;j++)
     761  lock();
     762  for (j=0; j<h; j++)
    681763  {
    682764    p=scan_line(j);
    683     for (i=0;i<w;i++)
    684     { pal->get(p[i],r,g,b);
     765    for (i=0; i<w; i++)
     766    { pal->get(p[i], r, g, b);
    685767      if ((int32_t)r*(int32_t)g*(int32_t)b>brv)
    686768      { brv=(int32_t)r*(int32_t)g*(int32_t)b;
    687         bri=p[i];
     769    bri=p[i];
    688770      }
    689771    }
    690772  }
     773  unlock();
    691774  return bri;
    692775}
    693776
    694777uint8_t image::darkest_color(palette *pal, int16_t noblack)
    695 { uint8_t *p,r,g,b,bri;
    696   int16_t i,j;
    697   int32_t brv,x;
     778{ uint8_t *p, r, g, b, bri;
     779  int16_t i, j;
     780  int32_t brv, x;
    698781  brv=(int32_t)258*(int32_t)258*(int32_t)258; bri=0;
    699   for (j=0;j<h;j++)
     782  lock();
     783  for (j=0; j<h; j++)
    700784  {
    701785    p=scan_line(j);
    702     for (i=0;i<w;i++)
    703     { pal->get(p[i],r,g,b);
     786    for (i=0; i<w; i++)
     787    { pal->get(p[i], r, g, b);
    704788      x=(int32_t)r*(int32_t)g*(int32_t)b;
    705789      if (x<brv && (x || !noblack))
    706790      { brv=x;
    707         bri=p[i];
     791    bri=p[i];
    708792      }
    709793    }
    710794  }
     795  unlock();
    711796  return bri;
    712797}
    713798
    714 void image::rectangle(int16_t x1, int16_t y1,int16_t x2, int16_t y2, uint8_t color)
    715 {
    716   line(x1,y1,x2,y1,color);
    717   line(x2,y1,x2,y2,color);
    718   line(x1,y2,x2,y2,color);
    719   line(x1,y1,x1,y2,color);
     799void image::rectangle(int16_t x1, int16_t y1, int16_t x2, int16_t y2, uint8_t color)
     800{
     801  line(x1, y1, x2, y1, color);
     802  line(x2, y1, x2, y2, color);
     803  line(x1, y2, x2, y2, color);
     804  line(x1, y1, x1, y2, color);
    720805}
    721806
     
    735820{
    736821  if (special)
    737     special->get_clip(x1,y1,x2,y2);
     822    special->get_clip(x1, y1, x2, y2);
    738823  else
    739824  { x1=0; y1=0; x2=width()-1; y2=height()-1; }
     
    753838      y2=special->y2_clip();
    754839  }
    755   set_clip(x1,y1,x2,y2);
     840  set_clip(x1, y1, x2, y2);
    756841}
    757842
     
    762847void image_descriptor::reduce_dirties()
    763848{
    764   dirty_rect *p,*q;
    765   int16_t x1,y1,x2,y2,nn;
     849  dirty_rect *p, *q;
     850  int16_t x1, y1, x2, y2, nn;
    766851  x1=6000; y1=6000;
    767852  x2=0; y2=0;
     
    780865    nn--;
    781866  }
    782   dirties.add_front((linked_node *) new dirty_rect(x1,y1,x2,y2));
     867  dirties.add_front((linked_node *) new dirty_rect(x1, y1, x2, y2));
    783868}
    784869
    785870void image_descriptor::delete_dirty(int x1, int y1, int x2, int y2)
    786871{
    787   int16_t i,ax1,ay1,ax2,ay2;
    788   dirty_rect *p,*next;
     872  int16_t i, ax1, ay1, ax2, ay2;
     873  dirty_rect *p, *next;
    789874  if (keep_dirt)
    790875  {
     
    801886    else
    802887    {
    803       for (p=(dirty_rect *)dirties.first();i;i--,p=(dirty_rect *)next)
     888      for (p=(dirty_rect *)dirties.first(); i; i--, p=(dirty_rect *)next)
    804889      {
    805890        next=(dirty_rect *)p->next();
    806891        // are the two touching?
    807         if (!(x2<p->dx1 || y2<p->dy1 || x1>p->dx2 || y1>p->dy2))
     892    if (!(x2<p->dx1 || y2<p->dy1 || x1>p->dx2 || y1>p->dy2))
    808893        {
    809894          // does it take a x slice off? (across)
     
    821906            else
    822907            {
    823               dirties.add_front((linked_node *) new dirty_rect(p->dx1,p->dy1,p->dx2,y1-1));
     908              dirties.add_front((linked_node *) new dirty_rect(p->dx1, p->dy1, p->dx2, y1-1));
    824909              p->dy1=y2+1;
    825910            }
     
    834919            else
    835920            {
    836               dirties.add_front((linked_node *) new dirty_rect(p->dx1,p->dy1,x1-1,p->dy2));
     921              dirties.add_front((linked_node *) new dirty_rect(p->dx1, p->dy1, x1-1, p->dy2));
    837922              p->dx1=x2+1;
    838923            }
     
    847932            else if (y1<=p->dy1) { ay1=p->dy1; ay2=y2; }
    848933            else                { ay1=y1; ay2=y2; }
    849             dirties.add_front((linked_node *) new dirty_rect(ax1,ay1,ax2,ay2));
     934            dirties.add_front((linked_node *) new dirty_rect(ax1, ay1, ax2, ay2));
    850935         
    851936            if (x2>=p->dx2 || x1<=p->dx1)  { ax1=p->dx1; ax2=p->dx2; }
     
    859944            else           { if (ax1==p->dx1) { ay1=p->dy1; ay2=y1-1; }
    860945                             else { ay1=y1; ay2=y2; } }
    861             dirties.add_front((linked_node *) new dirty_rect(ax1,ay1,ax2,ay2));
     946            dirties.add_front((linked_node *) new dirty_rect(ax1, ay1, ax2, ay2));
    862947
    863948            if (x1>p->dx1 && x2<p->dx2)
     
    865950              if (y1>p->dy1 && y2<p->dy2)
    866951              {
    867                 dirties.add_front((linked_node *) new dirty_rect(p->dx1,p->dy1,p->dx2,y1-1));
    868                 dirties.add_front((linked_node *) new dirty_rect(p->dx1,y2+1,p->dx2,p->dy2));
     952                dirties.add_front((linked_node *) new dirty_rect(p->dx1, p->dy1, p->dx2, y1-1));
     953                dirties.add_front((linked_node *) new dirty_rect(p->dx1, y2+1, p->dx2, p->dy2));
    869954              } else if (y1<=p->dy1)
    870                 dirties.add_front((linked_node *) new dirty_rect(p->dx1,y2+1,p->dx2,p->dy2));
     955                dirties.add_front((linked_node *) new dirty_rect(p->dx1, y2+1, p->dx2, p->dy2));
    871956              else
    872                 dirties.add_front((linked_node *) new dirty_rect(p->dx1,p->dy1,p->dx2,y1-1));
     957                dirties.add_front((linked_node *) new dirty_rect(p->dx1, p->dy1, p->dx2, y1-1));
    873958            } else if (y1>p->dy1 && y2<p->dy2)
    874               dirties.add_front((linked_node *) new dirty_rect(p->dx1,y2+1,p->dx2,p->dy2));
     959              dirties.add_front((linked_node *) new dirty_rect(p->dx1, y2+1, p->dx2, p->dy2));
    875960            dirties.unlink((linked_node *) p);
    876961            delete p;
     
    897982    i=dirties.number_nodes();
    898983    if (!i)
    899       dirties.add_front((linked_node *) new dirty_rect(x1,y1,x2,y2));
     984      dirties.add_front((linked_node *) new dirty_rect(x1, y1, x2, y2));
    900985    else if (i>=MAX_DIRTY)
    901986    {
    902       dirties.add_front((linked_node *) new dirty_rect(x1,y1,x2,y2));
     987      dirties.add_front((linked_node *) new dirty_rect(x1, y1, x2, y2));
    903988      reduce_dirties();  // reduce to one dirty rectangle, we have to many
    904989    }
    905990    else
    906991    { 
    907       for (p=(dirty_rect *)dirties.first();i>0;i--)
     992      for (p=(dirty_rect *)dirties.first(); i>0; i--)
    908993      {
    909994
    910995        // check to see if this new rectangle completly encloses the check rectangle
    911         if (x1<=p->dx1 && y1<=p->dy1 && x2>=p->dx2 && y2>=p->dy2)
    912         {
    913           dirty_rect *tmp=(dirty_rect*) p->next();
    914           dirties.unlink((linked_node *)p);
    915           delete p;
    916           if (!dirties.first())
    917             i=0;
    918           else p=tmp;    
    919         }       
    920         else if (!(x2<p->dx1 || y2<p->dy1 || x1>p->dx2 || y1>p->dy2))
    921         {        
    922 
    923 
    924        
     996    if (x1<=p->dx1 && y1<=p->dy1 && x2>=p->dx2 && y2>=p->dy2)
     997    {
     998      dirty_rect *tmp=(dirty_rect*) p->next();
     999      dirties.unlink((linked_node *)p);
     1000      delete p;
     1001      if (!dirties.first())
     1002          i=0;
     1003      else p=tmp;     
     1004    }   
     1005    else if (!(x2<p->dx1 || y2<p->dy1 || x1>p->dx2 || y1>p->dy2))
     1006    {     
     1007
     1008
     1009   
    9251010/*          if (x1<=p->dx1) { a+=p->dx1-x1; ax1=x1; } else ax1=p->dx1;
    9261011          if (y1<=p->dy1) { a+=p->dy1-y1; ay1=y1; } else ay1=p->dy1;
    9271012          if (x2>=p->dx2) { a+=x2-p->dx2; ax2=x2; } else ax2=p->dx2;
    9281013          if (y2>=p->dy2) { a+=y2-p->dy2; ay2=y2; } else ay2=p->dy2;
    929          
    930           if (a<50)
    931           { p->dx1=ax1;                                // then expand the dirty
    932             p->dy1=ay1;
    933             p->dx2=ax2;
    934             p->dy2=ay2;
    935             return ;
    936           }
    937           else */
    938             {
    939               if (x1<p->dx1)
    940                 add_dirty(x1,max(y1,p->dy1),p->dx1-1,min(y2,p->dy2));
    941               if (x2>p->dx2)
    942                 add_dirty(p->dx2+1,max(y1,p->dy1),x2,min(y2,p->dy2));
    943               if (y1<p->dy1)
    944                 add_dirty(x1,y1,x2,p->dy1-1);
    945               if (y2>p->dy2)
    946                 add_dirty(x1,p->dy2+1,x2,y2);
    947               return ;
    948             }
    949             p=(dirty_rect *)p->next();
    950           } else p=(dirty_rect *)p->next();     
    951        
     1014     
     1015      if (a<50)
     1016      { p->dx1=ax1;                         // then expand the dirty
     1017        p->dy1=ay1;
     1018        p->dx2=ax2;
     1019        p->dy2=ay2;
     1020        return ;
     1021      }
     1022      else */
     1023        {
     1024          if (x1<p->dx1)
     1025            add_dirty(x1, max(y1, p->dy1), p->dx1-1, min(y2, p->dy2));
     1026          if (x2>p->dx2)
     1027            add_dirty(p->dx2+1, max(y1, p->dy1), x2, min(y2, p->dy2));
     1028          if (y1<p->dy1)
     1029            add_dirty(x1, y1, x2, p->dy1-1);
     1030          if (y2>p->dy2)
     1031            add_dirty(x1, p->dy2+1, x2, y2);
     1032          return ;
     1033        }
     1034        p=(dirty_rect *)p->next();
     1035      } else p=(dirty_rect *)p->next();     
     1036   
    9521037      }
    9531038      CHECK(x1<=x2 && y1<=y2);
    954       dirties.add_end((linked_node *)new dirty_rect(x1,y1,x2,y2));
     1039      dirties.add_end((linked_node *)new dirty_rect(x1, y1, x2, y2));
    9551040    }
    9561041  }
     
    9751060  if (x2<0 || y2<0 || x1>=width() || y1>=height() || x2<x1 || y2<y1)
    9761061    return ;
    977   for (y=y1;y<=y2;y++)
    978     memset(scan_line(y)+x1,color,(x2-x1+1));
    979   add_dirty(x1,y1,x2,y2);
     1062  lock();
     1063  for (y=y1; y<=y2; y++)
     1064    memset(scan_line(y)+x1, color, (x2-x1+1));
     1065  unlock();
     1066  add_dirty(x1, y1, x2, y2);
    9801067}
    9811068
    9821069void image::xor_bar  (int16_t x1, int16_t y1, int16_t x2, int16_t y2, uint8_t color)
    9831070{
    984   int16_t y,x;
     1071  int16_t y, x;
    9851072  if (x1>x2 || y1>y2) return ;
    9861073  if (special)
     
    9991086    return ;
    10001087
     1088  lock();
    10011089  uint8_t *sl=scan_line(y1)+x1;
    1002   for (y=y1;y<=y2;y++)
     1090  for (y=y1; y<=y2; y++)
    10031091  {
    10041092    uint8_t *s=sl;
    1005     for (x=x1;x<=x2;x++,s++)
     1093    for (x=x1; x<=x2; x++, s++)
    10061094      *s=(*s)^color;
    10071095    sl+=w;
    10081096  }
    1009 
    1010   add_dirty(x1,y1,x2,y2);
     1097  unlock();
     1098
     1099  add_dirty(x1, y1, x2, y2);
    10111100}
    10121101
     
    10151104{
    10161105  int16_t x;
    1017   uint8_t *sl,*ex,mask,bt,sh;
    1018   ex=(uint8_t *)jmalloc(width(),"image::unpacked scanline");
     1106  uint8_t *sl, *ex, mask, bt, sh;
     1107  ex=(uint8_t *)jmalloc(width(), "image::unpacked scanline");
     1108
     1109  lock();
    10191110  sl=scan_line(line);
    1020   memcpy(ex,sl,width());
     1111  memcpy(ex, sl, width());
     1112  unlock();
    10211113
    10221114  if (bitsperpixel==1)      { mask=128;           bt=8; }
    10231115  else if (bitsperpixel==2) { mask=128+64;        bt=4; }
    1024   else                      {  mask=128+64+32+16; bt=2; }
    1025 
    1026   for (x=0;x<width();x++)
     1116  else                 {  mask=128+64+32+16; bt=2; }
     1117
     1118  for (x=0; x<width(); x++)
    10271119  { sh=((x%bt)<<(bitsperpixel-1));
    10281120    sl[x]=(ex[x/bt]&(mask>>sh))>>(bt-sh-1);
     
    10341126void image::dither(palette *pal)
    10351127{
    1036   int16_t x,y,i,j;
    1037   uint8_t dt_matrix[]={0,  136,24, 170,
    1038                    68, 204,102,238,
    1039                    51, 187, 17,153,
    1040                    119,255, 85,221};
     1128  int16_t x, y, i, j;
     1129  uint8_t dt_matrix[]={0,  136, 24, 170,
     1130           68, 204, 102, 238,
     1131           51, 187, 17, 153,
     1132           119, 255, 85, 221};
    10411133
    10421134  uint8_t *sl;
    1043   for (y=height()-1;y>=0;y--)
     1135  lock();
     1136  for (y=height()-1; y>=0; y--)
    10441137  {
    10451138    sl=scan_line(y);
    1046     for (i=0,j=y%4,x=width()-1;x>=0;x--)
     1139    for (i=0, j=y%4, x=width()-1; x>=0; x--)
    10471140    {
    10481141      if (pal->red(sl[x])>dt_matrix[j*4+i])
    1049         sl[x]=255;
     1142    sl[x]=255;
    10501143      else sl[x]=0;
    10511144      if (i==3) i=0; else i++;
    10521145    }
    10531146  }
     1147  unlock();
    10541148}
    10551149
     
    10671161void image::resize(int16_t new_width, int16_t new_height)
    10681162{
    1069   int old_width=width(),old_height=height();
    1070   uint8_t *im=(uint8_t *)jmalloc(width()*height(),"image::resized");
    1071   memcpy(im,scan_line(0),width()*height());
     1163  int old_width=width(), old_height=height();
     1164  uint8_t *im=(uint8_t *)jmalloc(width()*height(), "image::resized");
     1165  lock();
     1166  memcpy(im, scan_line(0), width()*height());
    10721167
    10731168  delete_page();
    1074   make_page(new_width,new_height,NULL);
     1169  make_page(new_width, new_height, NULL);
    10751170  w=new_width;      // set the new hieght and width
    10761171  h=new_height;
    10771172
    1078   uint8_t *sl1,*sl2;
    1079   int16_t y,y2,x2;
    1080   double yc,xc,yd,xd;
     1173  uint8_t *sl1, *sl2;
     1174  int16_t y, y2, x2;
     1175  double yc, xc, yd, xd;
    10811176
    10821177
     
    10841179  yc=(double)old_height/(double)new_height;
    10851180  xc=(double)old_width/(double)new_width;
    1086   for (y2=0,yd=0;y2<new_height;yd+=yc,y2++)
     1181  for (y2=0, yd=0; y2<new_height; yd+=yc, y2++)
    10871182  {
    10881183    y=(int)yd;
    10891184    sl1=im+y*old_width;
    10901185    sl2=scan_line(y2);
    1091     for (xd=0,x2=0;x2<new_width;xd+=xc,x2++)
     1186    for (xd=0, x2=0; x2<new_width; xd+=xc, x2++)
    10921187    { sl2[x2]=sl1[(int)xd]; }
    10931188  }
    10941189  jfree(im);
    1095   if (special) special->resize(new_width,new_height);
     1190  if (special) special->resize(new_width, new_height);
     1191  unlock();
    10961192}
    10971193
    10981194void image::scroll(int16_t x1, int16_t y1, int16_t x2, int16_t y2, int16_t xd, int16_t yd)
    10991195{
    1100   int16_t cx1,cy1,cx2,cy2;
     1196  int16_t cx1, cy1, cx2, cy2;
    11011197  CHECK(x1>=0 && y1>=0 && x1<x2 && y1<y2 && x2<width() && y2<height());
    11021198  if (special)
    11031199  {
    1104     special->get_clip(cx1,cy1,cx2,cy2);
    1105     x1=max(x1,cx1); y1=max(cy1,y1); x2=min(x2,cx2); y2=min(y2,cy2);
    1106   }
    1107   int16_t xsrc,ysrc,xdst,ydst,xtot=x2-x1-abs(xd)+1,ytot,xt;
    1108   uint8_t *src,*dst;
     1200    special->get_clip(cx1, cy1, cx2, cy2);
     1201    x1=max(x1, cx1); y1=max(cy1, y1); x2=min(x2, cx2); y2=min(y2, cy2);
     1202  }
     1203  int16_t xsrc, ysrc, xdst, ydst, xtot=x2-x1-abs(xd)+1, ytot, xt;
     1204  uint8_t *src, *dst;
    11091205  if (xd<0) { xsrc=x1-xd; xdst=x1; } else { xsrc=x2-xd; xdst=x2; }
    11101206  if (yd<0) { ysrc=y1-yd; ydst=y1; } else { ysrc=y2-yd; ydst=y2; }
    1111   for (ytot=y2-y1-abs(yd)+1;ytot;ytot--)
     1207  for (ytot=y2-y1-abs(yd)+1; ytot; ytot--)
    11121208  { src=scan_line(ysrc)+xsrc;
    11131209    dst=scan_line(ydst)+xdst;
    11141210    if (xd<0)
    1115       for (xt=xtot;xt;xt--)
     1211      for (xt=xtot; xt; xt--)
    11161212        *(dst++)=*(src++);
    1117       else for (xt=xtot;xt;xt--)
     1213      else for (xt=xtot; xt; xt--)
    11181214        *(dst--)=*(src--);
    11191215    if (yd<0) { ysrc++; ydst++; } else { ysrc--; ydst--; }
    11201216  }
    1121   add_dirty(x1,y1,x2,y2);
     1217  add_dirty(x1, y1, x2, y2);
    11221218}
    11231219
     
    11251221image *image::create_smooth(int16_t smoothness)
    11261222{
    1127   int16_t i,j,k,l,t,d;
     1223  int16_t i, j, k, l, t, d;
    11281224  image *im;
    11291225  CHECK(smoothness>=0);
     
    11311227  d=smoothness*2+1;
    11321228  d=d*d;
    1133   im=new image(width(),height());
    1134   for (i=0;i<width();i++)
    1135     for (j=0;j<height();j++)
    1136     {
    1137       for (t=0,k=-smoothness;k<=smoothness;k++)
    1138         for (l=-smoothness;l<=smoothness;l++)
    1139           if (i+k>smoothness && i+k<width()-smoothness && j+l<height()-smoothness && j+l>smoothness)
    1140             t+=pixel(i+k,j+l);
    1141           else t+=pixel(i,j);
    1142       im->putpixel(i,j,t/d);
     1229  im=new image(width(), height());
     1230  for (i=0; i<width(); i++)
     1231    for (j=0; j<height(); j++)
     1232    {
     1233      for (t=0, k=-smoothness; k<=smoothness; k++)
     1234    for (l=-smoothness; l<=smoothness; l++)
     1235      if (i+k>smoothness && i+k<width()-smoothness && j+l<height()-smoothness && j+l>smoothness)
     1236        t+=pixel(i+k, j+l);
     1237      else t+=pixel(i, j);
     1238      im->putpixel(i, j, t/d);
    11431239    }
    11441240  return im;
     
    11461242
    11471243void image::widget_bar(int16_t x1, int16_t y1, int16_t x2, int16_t y2,
    1148         uint8_t light, uint8_t med, uint8_t dark)
    1149 {
    1150   line(x1,y1,x2,y1,light);
    1151   line(x1,y1,x1,y2,light);
    1152   line(x2,y1+1,x2,y2,dark);
    1153   line(x1+1,y2,x2-1,y2,dark);
    1154   bar(x1+1,y1+1,x2-1,y2-1,med);
     1244       uint8_t light, uint8_t med, uint8_t dark)
     1245{
     1246  line(x1, y1, x2, y1, light);
     1247  line(x1, y1, x1, y2, light);
     1248  line(x2, y1+1, x2, y2, dark);
     1249  line(x1+1, y2, x2-1, y2, dark);
     1250  bar(x1+1, y1+1, x2-1, y2-1, med);
    11551251}
    11561252
     
    11581254{
    11591255public :
    1160   int16_t x,y;
     1256  int16_t x, y;
    11611257  fill_rec *last;
    11621258  fill_rec(int16_t X, int16_t Y, fill_rec *Last)
     
    11661262void image::flood_fill(int16_t x, int16_t y, uint8_t color)
    11671263{
    1168   uint8_t *sl,*above,*below;
    1169   fill_rec *recs=NULL,*r;
     1264  uint8_t *sl, *above, *below;
     1265  fill_rec *recs=NULL, *r;
    11701266  uint8_t fcolor;
     1267  lock();
    11711268  sl=scan_line(y);
    11721269  fcolor=sl[x];
     
    11891286        above=scan_line(y-1);
    11901287        if (above[x]==fcolor)
    1191         { r=new fill_rec(x,y-1,recs);
     1288        { r=new fill_rec(x, y-1, recs);
    11921289          recs=r; 
    11931290        }
     
    11971294        above=scan_line(y+1);
    11981295        if (above[x]==fcolor)
    1199         { r=new fill_rec(x,y+1,recs);
     1296        { r=new fill_rec(x, y+1, recs);
    12001297          recs=r;
    12011298        }
     
    12101307        { above=scan_line(y-1);
    12111308          if (x>0 && above[x-1]!=fcolor && above[x]==fcolor)
    1212           { r=new fill_rec(x,y-1,recs);
     1309          { r=new fill_rec(x, y-1, recs);
    12131310            recs=r; 
    12141311          }
     
    12171314        { below=scan_line(y+1);
    12181315          if (x>0 && below[x-1]!=fcolor && below[x]==fcolor)
    1219           { r=new fill_rec(x,y+1,recs);
     1316          { r=new fill_rec(x, y+1, recs);
    12201317            recs=r; 
    12211318          }
     
    12281325        above=scan_line(y-1);
    12291326        if (above[x]==fcolor)
    1230         { r=new fill_rec(x,y-1,recs);
     1327        { r=new fill_rec(x, y-1, recs);
    12311328          recs=r;
    12321329        }
     
    12361333        above=scan_line(y+1);
    12371334        if (above[x]==fcolor)
    1238         { r=new fill_rec(x,y+1,recs);
     1335        { r=new fill_rec(x, y+1, recs);
    12391336          recs=r;
    12401337        }
     
    12421339    }
    12431340  } while (recs);
     1341  unlock();
    12441342}
    12451343
     
    12501348{
    12511349  char st[100];
    1252   int16_t ledx[]={1,2,1,2,3,3,3,3,1,2,0,0,0,0};
    1253   int16_t ledy[]={3,3,0,0,1,2,4,6,7,7,4,6,1,2};
    1254 
    1255   int16_t dig[]={2+4+8+16+32+64,4+8,2+4+1+32+16,2+4+1+8+16,64+1+4+8,
    1256              2+64+1+8+16,64+32+1+8+16,2+4+8,1+2+4+8+16+32+64,64+2+4+1+8,1};
    1257   int16_t xx,yy,zz;
    1258   sprintf(st,"%8ld",(long int)num);
    1259   for (xx=0;xx<8;xx++)
     1350  int16_t ledx[]={1, 2, 1, 2, 3, 3, 3, 3, 1, 2, 0, 0, 0, 0};
     1351  int16_t ledy[]={3, 3, 0, 0, 1, 2, 4, 6, 7, 7, 4, 6, 1, 2};
     1352
     1353  int16_t dig[]={2+4+8+16+32+64, 4+8, 2+4+1+32+16, 2+4+1+8+16, 64+1+4+8,
     1354             2+64+1+8+16, 64+32+1+8+16, 2+4+8, 1+2+4+8+16+32+64, 64+2+4+1+8, 1};
     1355  int16_t xx, yy, zz;
     1356  sprintf(st, "%8ld", (long int)num);
     1357  for (xx=0; xx<8; xx++)
    12601358  {
    12611359    if (st[xx]!=' ')
    12621360    {
    12631361      if (st[xx]=='-')
    1264         zz=10;
     1362    zz=10;
    12651363      else
    1266         zz=st[xx]-'0';
    1267       for (yy=0;yy<7;yy++)
    1268         if ((1<<yy)&dig[zz])
    1269           line(x+ledx[yy*2]*scale,y+ledy[yy*2]*scale,x+ledx[yy*2+1]*scale,
    1270             y+ledy[yy*2+1]*scale,color);
     1364    zz=st[xx]-'0';
     1365      for (yy=0; yy<7; yy++)
     1366    if ((1<<yy)&dig[zz])
     1367      line(x+ledx[yy*2]*scale, y+ledy[yy*2]*scale, x+ledx[yy*2+1]*scale,
     1368        y+ledy[yy*2+1]*scale, color);
    12711369    }
    12721370    x+=6*scale;
     
    12741372}
    12751373
    1276 uint8_t dither_matrix[]={0,  136,24, 170,
    1277                      68, 204,102,238,
    1278                      51, 187, 17,153,
    1279                      119,255, 85,221};
     1374uint8_t dither_matrix[]={0,  136, 24, 170,
     1375             68, 204, 102, 238,
     1376             51, 187, 17, 153,
     1377             119, 255, 85, 221};
    12801378
    12811379image *image::copy_part_dithered (int16_t x1, int16_t y1, int16_t x2, int16_t y2)
    12821380{
    1283   int16_t x,y,cx1,cy1,cx2,cy2,ry,rx,bo,dity,ditx;
     1381  int16_t x, y, cx1, cy1, cx2, cy2, ry, rx, bo, dity, ditx;
    12841382  image *ret;
    1285   uint8_t *sl1,*sl2;
    1286   get_clip(cx1,cy1,cx2,cy2);
     1383  uint8_t *sl1, *sl2;
     1384  get_clip(cx1, cy1, cx2, cy2);
    12871385  if (y1<cy1) y1=cy1;
    12881386  if (x1<cx1) x1=cx1;
     
    12911389  CHECK(x2>=x1 && y2>=y1);
    12921390  if (x2<x1 || y2<y1) return NULL;
    1293   ret=new image((x2-x1+8)/8,(y2-y1+1));
     1391  ret=new image((x2-x1+8)/8, (y2-y1+1));
    12941392  if (!last_loaded())
    12951393    ret->clear();
    12961394  else
    1297     for (y=y1,ry=0,dity=(y1%4)*4;y<=y2;y++,ry++)
     1395  {
     1396    ret->lock();
     1397    lock();
     1398    for (y=y1, ry=0, dity=(y1%4)*4; y<=y2; y++, ry++)
    12981399    {
    12991400      sl1=ret->scan_line(ry);     // sl1 is the scan linefo the return image
    13001401      sl2=scan_line(y);          // sl2 is the orginal image scan line
    1301       memset(sl1,0,(x2-x1+8)/8);
    1302       for (bo=7,rx=0,x=x1,ditx=x1%4;x<=x2;x++)
     1402      memset(sl1, 0, (x2-x1+8)/8);
     1403      for (bo=7, rx=0, x=x1, ditx=x1%4; x<=x2; x++)
    13031404      {
    13041405        if (last_loaded()->red(sl2[x])>dither_matrix[ditx+dity])
    1305           sl1[rx]|=1<<bo;
     1406          sl1[rx]|=1<<bo;
    13061407        if (bo!=0)
    1307         bo--;
     1408      bo--;
    13081409        else
    13091410        {
    1310           rx++;
    1311           bo=7;
     1411        rx++;
     1412      bo=7;
    13121413        }
    13131414        ditx+=1; if (ditx>3) ditx=0;
     
    13151416      dity+=4; if (dity>12) dity=0;
    13161417    }
     1418    unlock();
     1419    ret->unlock();
     1420  }
    13171421  return ret;
    13181422}
     
    13201424void image::flip_x()
    13211425{
    1322   uint8_t *rev=(uint8_t *)jmalloc(width(),"image tmp::flipped_x"),*sl;
    1323   CONDITION(rev,"memory allocation");
    1324   int y,x,i;
    1325   for (y=0;y<height();y++)
     1426  uint8_t *rev=(uint8_t *)jmalloc(width(), "image tmp::flipped_x"), *sl;
     1427  CONDITION(rev, "memory allocation");
     1428  int y, x, i;
     1429
     1430  /* FIXME: Abuse Win32 uses RestoreSurface() here instead of locking */
     1431  lock();
     1432  for (y=0; y<height(); y++)
    13261433  { sl=scan_line(y);
    1327     for (i=0,x=width()-1;x>=0;x--,i++)
     1434    for (i=0, x=width()-1; x>=0; x--, i++)
    13281435      rev[i]=sl[x];
    1329     memcpy(sl,rev,width());
    1330   }
     1436    memcpy(sl, rev, width());
     1437  }
     1438  unlock();
    13311439  jfree(rev);
    13321440}
     
    13341442void image::flip_y()
    13351443{
    1336   uint8_t *rev=(uint8_t *)jmalloc(width(),"image::flipped_y"),*sl;
    1337   CONDITION(rev,"memory allocation");
     1444  uint8_t *rev=(uint8_t *)jmalloc(width(), "image::flipped_y"), *sl;
     1445  CONDITION(rev, "memory allocation");
    13381446  int y;
    1339   for (y=0;y<height()/2;y++)
     1447
     1448  /* FIXME: Abuse Win32 uses RestoreSurface() here instead of locking */
     1449  lock();
     1450  for (y=0; y<height()/2; y++)
    13401451  { sl=scan_line(y);
    1341     memcpy(rev,sl,width());
    1342     memcpy(sl,scan_line(height()-y-1),width());
    1343     memcpy(scan_line(height()-y-1),rev,width());
    1344   }
     1452    memcpy(rev, sl, width());
     1453    memcpy(sl, scan_line(height()-y-1), width());
     1454    memcpy(scan_line(height()-y-1), rev, width());
     1455  }
     1456  unlock();
     1457  jfree(rev);
    13451458}
    13461459
     
    13481461{
    13491462  uint8_t *sl;
    1350   int y,x;
    1351   for (y=0;y<height();y++)
     1463  int y, x;
     1464  lock();
     1465  for (y=0; y<height(); y++)
    13521466  {
    13531467    sl=scan_line(y);
    1354     for (x=width();x;x--,sl++)
     1468    for (x=width(); x; x--, sl++)
    13551469      if (*sl)
    13561470        *sl=color;
    13571471  }
    1358 }
     1472  unlock();
     1473}
  • abuse/trunk/src/imlib/image.hpp

    r112 r115  
    88 */
    99
    10 #ifndef _IMGAE_HPP_
    11 #define _IMGAE_HPP_
     10#ifndef _IMAGE_HPP_
     11#define _IMAGE_HPP_
     12
    1213#include <stdlib.h>
    1314#include "linked.hpp"
     
    1920
    2021extern char const *imerr_messages[];  // correspond to imERRORS
    21 #define imREAD_ERROR           1
     22#define imREAD_ERROR            1
    2223#define imINCORRECT_FILETYPE   2
    2324#define imFILE_CORRUPTED       3
     
    2627#define imNOT_SUPPORTED        6
    2728#define imWRITE_ERROR          7
    28 #define imMAX_ERROR            7
     29#define imMAX_ERROR            7
    2930
    3031int16_t current_error();
     
    3940typedef struct image_color_t
    4041{
    41         uint16_t r;
    42         uint16_t g;
    43         uint16_t b;
     42    uint16_t r;
     43    uint16_t g;
     44    uint16_t b;
    4445} image_color;
    4546
     
    5253  int16_t dx1,dy1,dx2,dy2;
    5354  dirty_rect(int16_t x1, int16_t y1, int16_t x2, int16_t y2)
    54   { dx1=x1; dy1=y1; dx2=x2; dy2=y2; 
    55     if (x2<x1 || y2<y1)
     55  { dx1=x1; dy1=y1; dx2=x2; dy2=y2;
     56    if(x2<x1 || y2<y1)
    5657      printf("add inccorect dirty\n");
    5758  }
    5859  virtual int16_t compare(void *n1, int16_t field)
    59   { return ((dirty_rect *)n1)->dy1>dy1; }
     60  { return((dirty_rect *)n1)->dy1>dy1; }
    6061} ;
    6162
    6263class image_descriptor
    6364{
    64   int16_t l,h;
    65   int16_t clipx1, clipy1, clipx2, clipy2;
    66 public : 
    67   uint8_t keep_dirt,
    68           static_mem;      // if this flag is set then don't free memory on exit
    69  
    70   linked_list dirties;
    71   void *extended_descriptor;              // type depends on current system
    72 
    73   image_descriptor(int16_t length, int16_t height,
    74                   int keep_dirties=1, int static_memory=0);
    75   int16_t bound_x1(int16_t x1)  { return x1<clipx1 ? clipx1 : x1; }
    76   int16_t bound_y1(int16_t y1)  { return y1<clipy1 ? clipy1 : y1; }
    77   int16_t bound_x2(int16_t x2)  { return x2>clipx2 ? clipx2 : x2; }
    78   int16_t bound_y2(int16_t y2)  { return y2>clipy2 ? clipy2 : y2; }
    79   int16_t x1_clip() { return clipx1; }
    80   int16_t y1_clip() { return clipy1; }
    81   int16_t x2_clip() { return clipx2; }
    82   int16_t y2_clip() { return clipy2; }
    83   void dirty_area(int16_t x1, int16_t y1, int16_t x2, int16_t y2) { ;}
    84   void clean_area(int16_t x1, int16_t y1, int16_t x2, int16_t y2) { ; }
    85   void clear_dirties();
    86   int16_t get_dirty_area(int16_t &x1, int16_t &y1, int16_t &x2, int16_t &y2) { return 0; }
    87   void get_clip(int16_t &x1, int16_t &y1, int16_t &x2, int16_t &y2)
    88     { x1=clipx1; y1=clipy1; x2=clipx2; y2=clipy2; }
    89   void set_clip(int16_t x1, int16_t y1, int16_t x2, int16_t y2)
    90     { if (x2<x1) x2=x1;
    91       if (y2<y1) y2=y1;
    92       if (x1<0) clipx1=0; else clipx1=x1;
    93       if (y1<0) clipy1=0; else clipy1=y1;
    94       if (x2>=l) clipx2=l-1; else clipx2=x2;
    95       if (y2>=h) clipy2=h-1; else clipy2=y2;
    96     }
    97   void reduce_dirties();
    98   void add_dirty(int x1, int y1, int x2, int y2);
    99   void delete_dirty(int x1, int y1, int x2, int y2);
    100   void resize(int16_t length, int16_t height)
    101    { l=length; h=height; clipx1=0; clipy1=0; clipx2=l-1; clipy2=h-1; }
    102 } ;
     65private:
     66    int16_t l, h;
     67    int16_t clipx1, clipy1, clipx2, clipy2;
     68
     69public:
     70    uint8_t keep_dirt,
     71            static_mem; // if set, don't free memory on exit
     72
     73    linked_list dirties;
     74    void *extended_descriptor;
     75
     76    image_descriptor(int16_t length, int16_t height,
     77                     int keep_dirties = 1, int static_memory = 0);
     78    int16_t bound_x1(int16_t x1)  { return x1 < clipx1 ? clipx1 : x1; }
     79    int16_t bound_y1(int16_t y1)  { return y1 < clipy1 ? clipy1 : y1; }
     80    int16_t bound_x2(int16_t x2)  { return x2 > clipx2 ? clipx2 : x2; }
     81    int16_t bound_y2(int16_t y2)  { return y2 > clipy2 ? clipy2 : y2; }
     82    int16_t x1_clip() { return clipx1; }
     83    int16_t y1_clip() { return clipy1; }
     84    int16_t x2_clip() { return clipx2; }
     85    int16_t y2_clip() { return clipy2; }
     86    void dirty_area(int16_t x1, int16_t y1, int16_t x2, int16_t y2) { ; }
     87    void clean_area(int16_t x1, int16_t y1, int16_t x2, int16_t y2) { ; }
     88    void clear_dirties();
     89    int16_t get_dirty_area(int16_t &x1, int16_t &y1, int16_t &x2, int16_t &y2)
     90    {
     91        return 0;
     92    }
     93    void get_clip(int16_t &x1, int16_t &y1, int16_t &x2, int16_t &y2)
     94    {
     95        x1 = clipx1; y1 = clipy1; x2 = clipx2; y2 = clipy2;
     96    }
     97    void set_clip(int16_t x1, int16_t y1, int16_t x2, int16_t y2)
     98    {
     99        if(x2 < x1) x2 = x1;
     100        if(y2 < y1) y2 = y1;
     101        if(x1 < 0) clipx1 = 0; else clipx1 = x1;
     102        if(y1 < 0) clipy1 = 0; else clipy1 = y1;
     103        if(x2 >= l) clipx2 = l - 1; else clipx2 = x2;
     104        if(y2 >= h) clipy2 = h - 1; else clipy2 = y2;
     105    }
     106    void reduce_dirties();
     107    void add_dirty(int x1, int y1, int x2, int y2);
     108    void delete_dirty(int x1, int y1, int x2, int y2);
     109    void resize(int16_t length, int16_t height)
     110    {
     111        l = length; h = height;
     112        clipx1 = 0; clipy1 = 0; clipx2 = l - 1; clipy2 = h - 1;
     113    }
     114};
    103115
    104116class image : public linked_node
    105 {
    106   uint8_t *data;
    107   int16_t w,h;
    108   void make_page(int16_t width, int16_t height, uint8_t *page_buffer);
    109   void delete_page();
    110 public :
    111   image_descriptor *special;
    112   image(spec_entry *e, bFILE *fp);
    113   image(bFILE *fp);
    114   image(int16_t width, int16_t height,                 // required
    115         uint8_t *page_buffer=NULL,
    116         int16_t create_descriptor=0);        // 0=no, 1=yes, 2=yes & keep dirties
    117   uint8_t  pixel              (int16_t x, int16_t y);
    118   void     putpixel           (int16_t x, int16_t y, char color);
    119   uint8_t *scan_line          (int16_t y) { return data+y*w; }
    120   uint8_t *next_line          (int16_t lasty, uint8_t *last_scan)
    121                                     { return last_scan+w; }         
    122   int32_t  total_pixels       (uint8_t background=0);
    123   image    *copy               ();    // makes a copy of an image
    124   void     clear              (int16_t color=-1);  // -1 is background color
    125   void     to_24bit           (palette &pal);
    126   int16_t  width              () { return (int16_t)w; }
    127   int16_t  height             () { return (int16_t)h; }
    128   void     scroll             (int16_t x1, int16_t y1, int16_t x2, int16_t y2, int16_t xd, int16_t yd);
    129   void     fill_image         (image *screen, int16_t x1, int16_t y1, int16_t x2, int16_t y2,
    130                               int16_t align=1);
    131   void     put_image          (image *screen, int16_t x, int16_t y, char transparent=0);
    132   void     put_part           (image *screen, int16_t x, int16_t y, int16_t x1, int16_t y1,
    133                                      int16_t x2, int16_t y2, char transparent=0);
    134   void     put_part_xrev      (image *screen, int16_t x, int16_t y, int16_t x1, int16_t y1,
    135                                      int16_t x2, int16_t y2, char transparent=0);
    136   void     put_part_masked    (image *screen, image *mask, int16_t x, int16_t y,
    137                                      int16_t maskx, int16_t masky, int16_t x1, int16_t y1, int16_t x2, int16_t y2);
    138   image    *copy_part_dithered (int16_t x1, int16_t y1, int16_t x2, int16_t y2);
    139   void     bar                (int16_t x1, int16_t y1, int16_t x2, int16_t y2, uint8_t color);
    140   void     xor_bar            (int16_t x1, int16_t y1, int16_t x2, int16_t y2, uint8_t color);
    141   void     widget_bar          (int16_t x1, int16_t y1, int16_t x2, int16_t y2,
    142                                      uint8_t light, uint8_t med, uint8_t dark);
    143   void     line               (int16_t x1, int16_t y1, int16_t x2, int16_t y2, uint8_t color);
    144   void     rectangle          (int16_t x1, int16_t y1, int16_t x2, int16_t y2, uint8_t color);
    145   void     burn_led           (int16_t x, int16_t y, int32_t num, int16_t color, int16_t scale=1);
    146   void     set_clip           (int16_t x1, int16_t y1, int16_t x2, int16_t y2);
    147   void     get_clip           (int16_t &x1,int16_t &y1,int16_t &x2,int16_t &y2);
    148   void     in_clip            (int16_t x1, int16_t y1, int16_t x2, int16_t y2);
    149 
    150   void     dirt_off           () { if (special && special->keep_dirt) special->keep_dirt=0; }
    151   void     dirt_on            () { if (special) special->keep_dirt=1; }
    152 
    153   void     add_dirty          (int x1, int y1, int x2, int y2)
    154                                     { if (special) special->add_dirty(x1,y1,x2,y2); }
    155   void     delete_dirty       (int x1, int y1, int x2, int y2)
    156                                     { if (special) special->delete_dirty(x1,y1,x2,y2); }
    157   void     clear_dirties      () { if (special) special->clear_dirties(); }
    158   void     dither             (palette *pal); // use a b&w palette!
    159   void     resize             (int16_t new_width, int16_t new_height);
    160   void     change_size        (int16_t new_width, int16_t new_height, uint8_t *page=NULL);
    161   void     flood_fill         (int16_t x, int16_t y, uint8_t color);
    162   image    *create_smooth     (int16_t smoothness=1); // 0 no smoothness
    163   void     unpack_scanline    (int16_t line, char bitsperpixel=1);
    164   uint8_t  brightest_color    (palette *pal);
    165   void     flip_x             ();
    166   void     flip_y             ();
    167   void     make_color         (uint8_t color);
    168   uint8_t  darkest_color      (palette *pal, int16_t noblack=0);
    169 
    170   ~image();
    171 } ;
    172 
     117{
     118private:
     119    uint8_t *data;
     120    int16_t w, h;
     121    void make_page(int16_t width, int16_t height, uint8_t *page_buffer);
     122    void delete_page();
     123    bool _locked;
     124
     125public:
     126    image_descriptor *special;
     127
     128    image(spec_entry *e, bFILE *fp);
     129    image(bFILE *fp);
     130    image(int16_t width, int16_t height,
     131          uint8_t *page_buffer = NULL, int16_t create_descriptor = 0);
     132    ~image();
     133
     134    void lock();
     135    void unlock();
     136
     137    uint8_t pixel(int16_t x, int16_t y);
     138    void putpixel(int16_t x, int16_t y, char color);
     139    uint8_t *scan_line(int16_t y)
     140    {
     141        return data + y * w;
     142    }
     143    uint8_t *next_line(int16_t lasty, uint8_t *last_scan)
     144    {
     145        return last_scan + w;
     146    }
     147    int32_t total_pixels(uint8_t background=0);
     148    image *copy(); // makes a copy of an image
     149    void clear(int16_t color = -1); // -1 is background color
     150    void to_24bit(palette &pal);
     151    int16_t width()
     152    {
     153        return (int16_t)w;
     154    }
     155    int16_t height()
     156    {
     157        return (int16_t)h;
     158    }
     159    void scroll(int16_t x1, int16_t y1, int16_t x2, int16_t y2,
     160                int16_t xd, int16_t yd);
     161    void fill_image(image *screen, int16_t x1, int16_t y1,
     162                    int16_t x2, int16_t y2, int16_t align = 1);
     163    void put_image(image *screen, int16_t x, int16_t y, char transparent = 0);
     164    void put_part(image *screen, int16_t x, int16_t y, int16_t x1, int16_t y1,
     165                  int16_t x2, int16_t y2, char transparent = 0);
     166    void put_part_xrev(image *screen, int16_t x, int16_t y,
     167                       int16_t x1, int16_t y1, int16_t x2, int16_t y2,
     168                       char transparent = 0);
     169    void put_part_masked(image *screen, image *mask, int16_t x, int16_t y,
     170                         int16_t maskx, int16_t masky, int16_t x1, int16_t y1,
     171                         int16_t x2, int16_t y2);
     172    image *copy_part_dithered(int16_t x1, int16_t y1, int16_t x2, int16_t y2);
     173    void bar(int16_t x1, int16_t y1, int16_t x2, int16_t y2, uint8_t color);
     174    void xor_bar(int16_t x1, int16_t y1, int16_t x2, int16_t y2, uint8_t color);
     175    void widget_bar(int16_t x1, int16_t y1, int16_t x2, int16_t y2,
     176                    uint8_t light, uint8_t med, uint8_t dark);
     177    void line(int16_t x1, int16_t y1, int16_t x2, int16_t y2, uint8_t color);
     178    void rectangle(int16_t x1, int16_t y1, int16_t x2, int16_t y2,
     179                   uint8_t color);
     180    void burn_led(int16_t x, int16_t y, int32_t num, int16_t color,
     181                  int16_t scale = 1);
     182    void set_clip(int16_t x1, int16_t y1, int16_t x2, int16_t y2);
     183    void get_clip(int16_t &x1,int16_t &y1,int16_t &x2,int16_t &y2);
     184    void in_clip(int16_t x1, int16_t y1, int16_t x2, int16_t y2);
     185
     186    void dirt_off()
     187    {
     188        if(special && special->keep_dirt) special->keep_dirt = 0;
     189    }
     190    void dirt_on()
     191    {
     192        if(special) special->keep_dirt = 1;
     193    }
     194
     195    void add_dirty(int x1, int y1, int x2, int y2)
     196    {
     197        if(special) special->add_dirty(x1, y1, x2, y2);
     198    }
     199    void delete_dirty(int x1, int y1, int x2, int y2)
     200    {
     201        if(special) special->delete_dirty(x1, y1, x2, y2);
     202    }
     203    void clear_dirties()
     204    {
     205        if(special) special->clear_dirties();
     206    }
     207    void dither(palette *pal); // use a b&w palette!
     208    void resize(int16_t new_width, int16_t new_height);
     209    void change_size(int16_t new_width, int16_t new_height,
     210                     uint8_t *page = NULL);
     211    void flood_fill(int16_t x, int16_t y, uint8_t color);
     212    image *create_smooth(int16_t smoothness = 1); // 0 no smoothness
     213    void unpack_scanline(int16_t line, char bitsperpixel = 1);
     214    uint8_t brightest_color(palette *pal);
     215    void flip_x();
     216    void flip_y();
     217    void make_color(uint8_t color);
     218    uint8_t darkest_color(palette *pal, int16_t noblack = 0);
     219};
    173220
    174221class image_controller
    175222{
    176 public :
    177   image_controller() { image_init(); }
    178   ~image_controller()
    179   {
    180      image_uninit();
    181   }
    182 } ;
    183 
    184 
    185 
    186 #endif
    187 
    188 
    189 
    190 
    191 
    192 
    193 
    194 
     223public:
     224    image_controller()
     225    {
     226        image_init();
     227    }
     228    ~image_controller()
     229    {
     230        image_uninit();
     231    }
     232};
     233
     234#endif /* _IMAGE_HPP_ */
     235
  • abuse/trunk/src/imlib/morph.cpp

    r112 r115  
    3333  {
    3434    morph_point8 *m8=(morph_point8 *)p;
     35    screen->lock();
    3536    for (i=0;i<total;i++,m8++)
    3637    {
     
    5051      }           
    5152    }
     53    screen->unlock();
    5254  }   
    5355}
     
    6264  short cx1,cy1,cx2,cy2;
    6365  screen->get_clip(cx1,cy1,cx2,cy2);   
     66  screen->lock();
    6467  while (tot--)
    6568  {
     
    7679    }
    7780  }     
     81  screen->unlock();
    7882}
    7983
     
    8589  short cx1,cy1,cx2,cy2;
    8690  screen->get_clip(cx1,cy1,cx2,cy2);   
     91  screen->lock();
    8792  while (tot--)
    8893  {
     
    99104    }
    100105  }     
     106  screen->unlock();
    101107}
    102108
  • abuse/trunk/src/imlib/scroller.cpp

    r112 r115  
    5959  remap[2]=wm->dark_color();
    6060
     61  screen->lock();
    6162  for (int yc=ich;yc;yc--,y++)
    6263  {
     
    7273  }
    7374  screen->add_dirty(x,y,x+icw-1,y+ich-1);
     75  screen->unlock();
    7476}
    7577
  • 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  }
  • abuse/trunk/src/level.cpp

    r106 r115  
    16571657  fp->write_uint16(i->width());
    16581658  fp->write_uint16(i->height());
    1659   int y=0;
    1660   for (;y<i->height();y++)
     1659
     1660  i->lock();
     1661  for(int y = 0; y < i->height(); y++)
    16611662    fp->write(i->scan_line(y),i->width());
     1663  i->unlock();
    16621664
    16631665  delete i;
  • abuse/trunk/src/light.cpp

    r90 r115  
    776776  light_patch *first=make_patch_list(cx2-cx1+1,cy2-cy1+1,screenx,screeny);
    777777
    778   int scr_w=screen->width();
    779 
    780778  int prefix_x=(screenx&7);
    781779  int prefix=screenx&7;
     
    791789
    792790  light_patch *f=first;
     791
     792  screen->lock();
     793
     794  int scr_w=screen->width();
    793795  uint8_t *screen_line=screen->scan_line(cy1)+cx1;
    794796
     
    880882
    881883    screen_line-=prefix;
    882 
    883 
    884 
    885   }
    886 
     884  }
     885  screen->unlock();
    887886
    888887  while (first)
  • abuse/trunk/src/menu.cpp

    r113 r115  
    4949  percent=256-percent;
    5050
     51  screen->lock();
    5152  for (y=y1;y<=y2;y++)
    5253  {
     
    6263  }
    6364  screen->add_dirty(x1,y1,x2,y2); 
     65  screen->unlock();
    6466}
    6567
     
    7577  if (x2<x1 || y2<y1) return ;
    7678
     79  screen->lock();
    7780  for (y=y1;y<=y2;y++)
    7881  {
     
    8891  }
    8992  screen->add_dirty(x1,y1,x2,y2);
     93  screen->unlock();
    9094}
    9195
  • abuse/trunk/src/particle.cpp

    r56 r115  
    4545    last_anim->next=pan;
    4646    last_anim=pan;
    47   } 
     47  }
    4848}
    4949
     
    7676  args=lcdr(args);
    7777  pseqs[total_pseqs]=new part_sequence(args);
    78   total_pseqs++; 
     78  total_pseqs++;
    7979  return total_pseqs;
    8080}
     
    8484part_sequence::part_sequence(void *args)
    8585{
    86   char *fn=lstring_value(lcar(args)); 
     86  char *fn=lstring_value(lcar(args));
    8787  bFILE *fp=open_file(fn,"rb");
    8888  if (fp->open_failure())
     
    106106    if (sd.entries[i]->type==SPEC_PARTICLE) tframes++;
    107107  frames=(int *)jmalloc(sizeof(int)*tframes,"part_frame id list\n");
    108  
     108
    109109  int on=0;
    110110  for (i=0;i<sd.total;i++)
    111     if (sd.entries[i]->type==SPEC_PARTICLE)     
     111    if (sd.entries[i]->type==SPEC_PARTICLE)
    112112      frames[on++]=cash.reg(fn,sd.entries[i]->name,SPEC_PARTICLE,1);
    113113
     
    128128    if (y>y2) y2=x;
    129129    data[i].x=x;
    130     data[i].y=y;   
    131     data[i].color=fp->read_uint8(); 
     130    data[i].y=y;
     131    data[i].color=fp->read_uint8();
    132132  }
    133133}
     
    148148      p=p->next;
    149149      delete d;
    150     } else 
     150    } else
    151151    {
    152152      last=p;
     
    159159void draw_panims(view *v)
    160160{
    161   for (part_animation *p=first_anim;p;p=p->next)     
     161  for (part_animation *p=first_anim;p;p=p->next)
    162162  {
    163163    cash.part(p->seq->frames[p->frame])->draw(screen,p->x-v->xoff()+v->cx1,p->y-v->yoff()+v->cy1,p->dir);
     
    178178  while (i && pon->y<cy1) { pon++; i--; }
    179179  if (!i) return ;
     180  screen->lock();
    180181  if (dir>0)
    181182  {
     
    187188      i--;
    188189      pon++;
    189     }   
     190    }
    190191  } else
    191192  {
     
    197198      i--;
    198199      pon++;
    199     }   
    200   }
    201 
    202 }
    203 
    204 
    205 
     200    }
     201  }
     202  screen->unlock();
     203}
    206204
    207205void scatter_line(int x1, int y1, int x2, int y2, int c, int s)
    208206{
    209         int16_t cx1, cy1, cx2, cy2;
    210         screen->get_clip( cx1, cy1, cx2, cy2 );
    211 
    212         int t = abs( x2 - x1 ) > abs( y2 - y1 ) ? abs( x2 - x1 ) + 1 : abs( y2 - y1 ) + 1;
    213         long xo = x1 << 16, yo = y1 << 16, dx = ( ( x2 - x1 ) << 16 ) / t, dy = ( ( y2 - y1 ) << 16 ) / t, x, y;
    214 
    215         int xm = ( 1 << s );
    216         int ym = ( 1 << s );
    217         s = ( 15 - s );
    218 
    219         while( t-- )
    220         {
    221                 x = ( xo >> 16 ) + ( jrand() >> s ) - xm;
    222                 y = ( yo >> 16 ) + ( jrand() >> s ) - ym;
    223                 if( !( x < cx1 || y < cy1 || x > cx2 || y > cy2 ) )
    224                 {
    225                         *(screen->scan_line( y ) + x ) = c;
    226                 }
    227                 xo += dx;
    228                 yo += dy;
    229         }
     207    int16_t cx1, cy1, cx2, cy2;
     208    screen->get_clip( cx1, cy1, cx2, cy2 );
     209
     210    int t = abs( x2 - x1 ) > abs( y2 - y1 ) ? abs( x2 - x1 ) + 1 : abs( y2 - y1 ) + 1;
     211    long xo = x1 << 16, yo = y1 << 16, dx = ( ( x2 - x1 ) << 16 ) / t, dy = ( ( y2 - y1 ) << 16 ) / t, x, y;
     212
     213    int xm = ( 1 << s );
     214    int ym = ( 1 << s );
     215    s = ( 15 - s );
     216
     217    screen->lock();
     218    while( t-- )
     219    {
     220        x = ( xo >> 16 ) + ( jrand() >> s ) - xm;
     221        y = ( yo >> 16 ) + ( jrand() >> s ) - ym;
     222        if( !( x < cx1 || y < cy1 || x > cx2 || y > cy2 ) )
     223        {
     224            *(screen->scan_line( y ) + x ) = c;
     225        }
     226        xo += dx;
     227        yo += dy;
     228    }
     229    screen->unlock();
    230230}
    231231
     
    234234void ascatter_line(int x1, int y1, int x2, int y2, int c1, int c2, int s)
    235235{
    236         int16_t cx1, cy1, cx2, cy2;
    237         screen->get_clip( cx1, cy1, cx2, cy2 );
    238 
    239         int t = abs( x2 - x1 ) > abs( y2 - y1 ) ? abs( x2 - x1 ) + 1 : abs( y2 - y1 ) + 1;
    240         long xo = x1 << 16, yo = y1 << 16, dx = ( ( x2 - x1 ) << 16 ) / t, dy = ( ( y2 - y1 ) <<16 ) / t, x, y;
    241 
    242         int xm = ( 1 << s );
    243         int ym = ( 1 << s );
    244         s = ( 15 - s );
    245 
    246         int w = screen->width();
    247         uint8_t *addr;
    248 
    249         while( t-- )
    250         {
    251                 x = ( xo >> 16 ) + ( jrand() >> s ) - xm;
    252                 y = ( yo >> 16 ) + ( jrand() >> s ) - ym;
    253                 if( !( x <= cx1 || y <= cy1 || x >= cx2 || y >= cy2 ) )
    254                 {
    255                         addr = screen->scan_line( y ) + x;
    256                         *addr = c1;
    257                         *(addr + w) = c2;
    258                         *(addr - w) = c2;
    259                         *(addr - 1) = c2;
    260                         *(addr + 1) = c2;
    261                 }
    262                 xo += dx;
    263                 yo += dy;
    264         }
    265 }
     236    int16_t cx1, cy1, cx2, cy2;
     237    screen->get_clip( cx1, cy1, cx2, cy2 );
     238
     239    int t = abs( x2 - x1 ) > abs( y2 - y1 ) ? abs( x2 - x1 ) + 1 : abs( y2 - y1 ) + 1;
     240    long xo = x1 << 16, yo = y1 << 16, dx = ( ( x2 - x1 ) << 16 ) / t, dy = ( ( y2 - y1 ) <<16 ) / t, x, y;
     241
     242    int xm = ( 1 << s );
     243    int ym = ( 1 << s );
     244    s = ( 15 - s );
     245
     246    screen->lock();
     247
     248    int w = screen->width();
     249    uint8_t *addr;
     250
     251    while( t-- )
     252    {
     253        x = ( xo >> 16 ) + ( jrand() >> s ) - xm;
     254        y = ( yo >> 16 ) + ( jrand() >> s ) - ym;
     255        if( !( x <= cx1 || y <= cy1 || x >= cx2 || y >= cy2 ) )
     256        {
     257            addr = screen->scan_line( y ) + x;
     258            *addr = c1;
     259            *(addr + w) = c2;
     260            *(addr - w) = c2;
     261            *(addr - 1) = c2;
     262            *(addr + 1) = c2;
     263        }
     264        xo += dx;
     265        yo += dy;
     266    }
     267
     268    screen->unlock();
     269}
     270
Note: See TracChangeset for help on using the changeset viewer.