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

Legend:

Unmodified
Added
Removed
  • abuse/trunk/src/imlib/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}
Note: See TracChangeset for help on using the changeset viewer.