source: abuse/trunk/src/imlib/image.cpp @ 115

Last change on this file since 115 was 115, checked in by Sam Hocevar, 11 years ago
  • 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 size: 33.8 KB
RevLine 
[56]1/*
2 *  Abuse - dark 2D side-scrolling platform game
3 *  Copyright (c) 1995 Crack dot Com
4 *
5 *  This software was released into the Public Domain. As with most public
6 *  domain software, no warranty is made or implied by Crack dot Com or
7 *  Jonathan Clark.
8 */
[2]9
[56]10#include "config.h"
11
[2]12#include <math.h>
13#ifdef __DOS
[56]14#   include <dir.h>
[2]15#else
[56]16#   include <unistd.h>
[2]17#endif
18#include <stdlib.h>
19
[56]20#include "image.hpp"
21#include "macs.hpp"
22#include "system.h"
23#include "system.h"
24
[17]25extern uint8_t current_background;
[39]26
27char const *imerr_messages[] =
28{
29    "No error",
[112]30    "Error occurred while reading",
[39]31    "Incorrect file type",
32    "File is corrupted",
33    "File not found",
34    "Memory allocation trouble",
35    "Operation/file type not supported",
[112]36    "Error occurred while writing, (disk full?)"
[39]37};
[115]38           
[2]39                         
[17]40int16_t imerror=0;
41int16_t swpfile_num=0;
[2]42
[17]43int16_t current_error()
[2]44{ return imerror; }
45
46void clear_errors()
47{
48  if (imerror)
49  { printf("Program stopped, error : ");
50    if (imerror<=imMAX_ERROR)
[115]51      printf("%s\n", imerr_messages[imerror]);
[2]52    else
53      printf("Unsonsponsered error code, you got trouble\n");
54#ifdef __DOS_ONLY
55    sound(300);
56    delay(100);
57    nosound();
58#else
[115]59    printf("%c%c\n", 7, 8);
[2]60#endif
61    exit(1);
62  }
63}
64
[17]65void set_error(int16_t x)
[2]66{ imerror=x; }
67
[17]68int16_t last_error()
[2]69{
[17]70  int16_t ec;
[2]71  ec=imerror;
72  imerror=0;
73  return ec;
74}
75
76linked_list image_list;
77
78
[17]79image_descriptor::image_descriptor(int16_t length, int16_t height,
[115]80                   int keep_dirties, int static_memory)
[2]81
82{ clipx1=0; clipy1=0;
83  l=length; h=height;
84  clipx2=l-1; clipy2=h-1;
85  keep_dirt=keep_dirties;
86  static_mem=static_memory; 
87}
88
[17]89void image::change_size(int16_t new_width, int16_t new_height, uint8_t *page)
[2]90{
91  delete_page();
92  w=new_width;
93  h=new_height;
[115]94  make_page(new_width, new_height, page);
[2]95}
96
97image::~image()
98{
[115]99    if(_locked)
100    {
101        fprintf(stderr, "Error: image is locked upon deletion\n");
102        unlock();
103    }
[2]104
[115]105    image_list.unlink((linked_node *)this);
106    delete_page();
107    if(special)
108        delete special;
[2]109}
110
111
112void make_block(size_t size)
113{
[115]114  void *dat=jmalloc(size, "make_block : tmp");
115  CONDITION(dat, "Memory error : could not make block\n");
[2]116  if (dat) jfree((char *)dat);
117}
118
[17]119uint8_t image::pixel(int16_t x, int16_t y)
[2]120{
121  CONDITION(x>=0 && x<width() && y>=0 && y<height(),
122     "image::pixel Bad pixel xy");
123  return (*(scan_line(y)+x));
124}
125
[17]126void image::putpixel(int16_t x, int16_t y, char color)
[2]127{
128  CONDITION(x>=0 && x<width() && y>=0 && y<height(),
129     "image::putpixel Bad pixel xy");
130  if (special)
131  { if (x>=special->x1_clip() && x<=special->x2_clip() &&
[115]132    y>=special->y1_clip() && y<=special->y2_clip())
[2]133      (*(scan_line(y)+x))=color;
134  } else (*(scan_line(y)+x))=color;
135}
136
137
[17]138image::image(int16_t width, int16_t height, uint8_t *page_buffer, int16_t create_descriptor)
[2]139{
140  w=width;
141  h=height; 
142  if (create_descriptor || page_buffer)
143  {
144    if (create_descriptor==2)
[115]145      special=new image_descriptor(width, height, 1, (page_buffer!=NULL));
146    else special=new image_descriptor(width, height, 0, (page_buffer!=NULL));
[2]147  } else special=NULL;
[115]148  make_page(width, height, page_buffer);
[2]149  image_list.add_end((linked_node *) this);
[115]150    _locked = false;
[2]151}
152
153image::image(spec_entry *e, bFILE *fp)
154{
[17]155  int16_t i;
[115]156  fp->seek(e->offset, 0);
[17]157  w=fp->read_uint16();
158  h=fp->read_uint16();
[2]159  special=NULL;
[115]160  make_page(w, h, NULL);
161  for (i=0; i<h; i++)
162    fp->read(scan_line(i), w);
[2]163  image_list.add_end((linked_node *) this);
[115]164    _locked = false;
[2]165}
166
167image::image(bFILE *fp)
168{
[17]169  int16_t i;
170  w=fp->read_uint16();
171  h=fp->read_uint16();
[2]172  special=NULL;
[115]173  make_page(w, h, NULL);
174  for (i=0; i<h; i++)
175    fp->read(scan_line(i), w);
[2]176  image_list.add_end((linked_node *) this);
[115]177    _locked = false;
[2]178}
179
[115]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;
196}
197
[2]198void image_uninit()
199{
[115]200    /* FIXME: is this used at all? */
[2]201/*  image *im;
202  while (image_list.first())
203  {
204    im=(image *)image_list.first();
205    image_list.unlink((linked_node *)im);
206    delete im;
207  } */
208}
209
210
211void image_cleanup(int ret, void *arg)
212{ image_uninit(); }
213
214void image_init()
215{
[17]216  uint8_t bt[2];
[115]217  uint16_t wrd, *up;
[2]218  bt[0]=1;
219  bt[1]=0;
[17]220  up=(uint16_t *)bt;
221  wrd=uint16_to_intel(*up);
[2]222  if (wrd!=0x01)
[112]223  { printf("compiled with wrong endianness, edit system.h and try again\n");
[115]224    printf("1 (intel) = %d\n", (int)wrd);
[2]225    exit(1);
226  }
227  imerror=0;
228}
229
230
[17]231int32_t image::total_pixels(uint8_t background)
[2]232{
[115]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;
[2]246}
247
[17]248void image::clear(int16_t color)
[2]249{
[115]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();
[2]267}
268
269image *image::copy()
270{
[115]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;
[2]290}
291
[115]292void image::line(int16_t x1, int16_t y1, int16_t x2, int16_t y2, uint8_t color)
[2]293{
[115]294  int16_t i, xc, yc, er, n, m, xi, yi, xcxi, ycyi, xcyi;
295  unsigned dcy, dcx;
[2]296  // check to make sure that both endpoint are on the screen
297
[115]298  int16_t cx1, cy1, cx2, cy2;
[2]299
300  // check to see if the line is completly clipped off
[115]301  get_clip(cx1, cy1, cx2, cy2); 
[2]302  if ((x1<cx1 && x2<cx1) || (x1>cx2 && x2>cx2) ||
303      (y1<cy1 && y2<cy1) || (y1>cy2 && y2>cy2))
304    return ;
305 
306  if (x1>x2)        // make sure that x1 is to the left
307  {   
308    i=x1; x1=x2; x2=i;  // if not swap points
309    i=y1; y1=y2; y2=i;
310  } 
311
312  // clip the left side
313  if (x1<cx1)
314  { 
315    int my=(y2-y1);       
[115]316    int mx=(x2-x1), b;
[2]317    if (!mx) return ;
318    if (my)
319    {
320      b=y1-(y2-y1)*x1/mx;     
321      y1=my*cx1/mx+b;
322      x1=cx1;     
323    }
324    else x1=cx1;
325  }
326
327  // clip the right side
328  if (x2>cx2)
329  { 
330    int my=(y2-y1);       
[115]331    int mx=(x2-x1), b;
[2]332    if (!mx) return ;
333    if (my)
334    {
335      b=y1-(y2-y1)*x1/mx;     
336      y2=my*cx2/mx+b;
337      x2=cx2;     
338    }
339    else x2=cx2;
340  }
341
342  if (y1>y2)        // make sure that y1 is on top
343  {   
344    i=x1; x1=x2; x2=i;  // if not swap points
345    i=y1; y1=y2; y2=i;
346  } 
347
348  // clip the bottom
349  if (y2>cy2)
350  { 
351    int mx=(x2-x1);       
[115]352    int my=(y2-y1), b;
[2]353    if (!my)
354      return ;
355    if (mx)
356    {
357      b=y1-(y2-y1)*x1/mx;     
358      x2=(cy2-b)*mx/my;
359      y2=cy2;
360    }
361    else y2=cy2;
362  }
363
364  // clip the top
365  if (y1<cy1)
366  { 
367    int mx=(x2-x1);       
[115]368    int my=(y2-y1), b;
[2]369    if (!my) return ;
370    if (mx)
371    {
372      b=y1-(y2-y1)*x1/mx;     
373      x1=(cy1-b)*mx/my;
374      y1=cy1;
375    }
376    else y1=cy1;
377  }
378
379
380  // see if it got cliped into the box, out out
381  if (x1<cx1 || x2<cx1 || x1>cx2 || x2>cx2 || y1<cy1 || y2 <cy1 || y1>cy2 || y2>cy2)
382    return ;
383 
384   
385
386  if (x1>x2)
387  { xc=x2; xi=x1; }
388  else { xi=x2; xc=x1; }
389
390
391  // assume y1<=y2 from above swap operation
392  yi=y2; yc=y1;
393
[115]394  add_dirty(xc, yc, xi, yi);
[2]395  dcx=x1; dcy=y1;
396  xc=(x2-x1); yc=(y2-y1);
397  if (xc<0) xi=-1; else xi=1;
398  if (yc<0) yi=-1; else yi=1;
399  n=abs(xc); m=abs(yc);
400  ycyi=abs(2*yc*xi);
401  er=0;
402
[115]403  lock();
[2]404  if (n>m)
405  {
406    xcxi=abs(2*xc*xi);
[115]407    for (i=0; i<=n; i++)
[2]408    {
409      *(scan_line(dcy)+dcx)=color;
410      if (er>0)
411      { dcy+=yi;
[115]412    er-=xcxi;
[2]413      }
414      er+=ycyi;
415      dcx+=xi;
416    }
417  }
418  else
419  {
420    xcyi=abs(2*xc*yi);
[115]421    for (i=0; i<=m; i++)
[2]422    {
423      *(scan_line(dcy)+dcx)=color;
424      if (er>0)
425      { dcx+=xi;
[115]426    er-=ycyi;
[2]427      }
428      er+=xcyi;
429      dcy+=yi;
430    }
431  }
[115]432  unlock();
[2]433}
434
435
[17]436void image::put_image(image *screen, int16_t x, int16_t y, char transparent)
[2]437{
[115]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)
[2]443    {
[115]444        put_part(screen, x, y, 0, 0, width()-1, height()-1, transparent);
445        return;
446    }
[2]447
[115]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;
[2]456
[115]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        }
[2]468
[115]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();
[2]494    }
495}
496
[19]497void image::fill_image(image *screen, int16_t x1, int16_t y1, int16_t x2, int16_t y2, int16_t align)
[2]498{
[115]499  int16_t i, j, w, xx, start, xl, starty;
500  uint8_t *pg1, *pg2;
[2]501  CHECK(x1<=x2 && y1<=y2);  // we should have gotten this
502
503  if (screen->special)
504  { x1=screen->special->bound_x1(x1);
505    y1=screen->special->bound_y1(y1);
506    x2=screen->special->bound_x2(x2);
507    y2=screen->special->bound_y2(y2);
508  }
509  else
510  { if (x1<0) x1=0;
511    if (y2<0) y1=0;
512    if (x2>=screen->width())  x2=screen->width()-1;
513    if (y2>=screen->height()) y2=screen->height()-1;
514  }
515  if (x2<0 || y2<0 || x1>=screen->width() || y1>=screen->height())
516    return ;
[115]517  screen->add_dirty(x1, y1, x2, y2);
[2]518  w=width();
[19]519  if (align)
[2]520  {
521    start=x1%w;
522    starty=y1%height();
523  }
524  else
525  { start=0;
526    starty=0;
527  }
[115]528  screen->lock();
529  lock();
530  for (j=y1; j<=y2; j++)
[2]531  {
532    pg1=screen->scan_line(j);
533    pg2=scan_line(starty++);
534    if (starty>=height()) starty=0;
535    i=x1;
536    xx=start;
537    while (i<=x2)
538    {
[115]539      xl=min(w-xx, x2-i+1);
[2]540
[115]541      memcpy(&pg1[i], &pg2[xx], xl);
[2]542      xx=0;
543      i+=xl;
544    }
545  }
[115]546  unlock();
547  screen->unlock();
[2]548}
549
550
[17]551void image::put_part(image *screen, int16_t x, int16_t y,
[115]552        int16_t x1, int16_t y1, int16_t x2, int16_t y2, char transparent)
[2]553{
[115]554  int16_t xlen, ylen, j, i;
555  int16_t cx1, cy1, cx2, cy2;
556  uint8_t *pg1, *pg2, *source, *dest;
[2]557  CHECK(x1<=x2 && y1<=y2);
558
[115]559  screen->get_clip(cx1, cy1, cx2, cy2);
[2]560
561
562  // see if the are to be put is outside of actual image, if so adjust
563  // to fit in the image
564  if (x1<0) { x+=-x1; x1=0; } 
565  if (y1<0) { y+=-y1; y1=0; } 
566  if (x2>=width()) x2=width()-1;
567  if (y2>=height()) y2=height()-1;
568  if (x1>x2 || y1>y2) return ;      // return if it was adjusted so that nothing will be put
569   
570
[114]571  // see if the image gets clipped off the screen
[2]572  if (x>cx2 || y>cy2 || x+(x2-x1)<cx1 || y+(y2-y1)<cy1) return ;
573
574 
575  if (x<cx1)
576  { x1+=(cx1-x); x=cx1; }
577  if (y<cy1)
578  { y1+=(cy1-y); y=cy1; }
579
580  if (x+x2-x1+1>cx2)
581  { x2=cx2-x+x1; }
582
583  if (y+y2-y1+1>cy2)
584  { y2=cy2-y+y1; }
585  if (x1>x2 || y1>y2) return ;   
586
587 
588
589
[115]590  xlen=x2-x1+1;
591  ylen=y2-y1+1;
[2]592
[115]593  screen->add_dirty(x, y, x+xlen-1, y+ylen-1);
[2]594
[115]595  screen->lock();
596  lock();
[2]597  pg1=screen->scan_line(y);
598  pg2=scan_line(y1);
599
600  if (transparent)
601  {
[115]602    for (j=0; j<ylen; j++)       
[2]603    {
[115]604      for (i=0, source=&pg2[x1], dest=&pg1[x]; i<xlen; i++, source++, dest++)   
[2]605        if (*source!=current_background) *dest=*source;
[115]606      pg1=screen->next_line(y+j, pg1); 
607      pg2=next_line(y1+j, pg2);
[2]608    }     
609  }
610  else
[115]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);
[2]616  }   
[115]617  unlock();
618  screen->unlock();
[2]619}
620
[17]621void image::put_part_xrev(image *screen, int16_t x, int16_t y,
[115]622        int16_t x1, int16_t y1, int16_t x2, int16_t y2, char transparent)
[2]623{
[115]624  int16_t xl, yl, j, i;
625  int16_t cx1, cy1, cx2, cy2;
626  uint8_t *pg1, *pg2, *source, *dest;
[2]627  CHECK(x1<=x2 && y1<=y2);
628
629  i=x1; x1=width()-x2-1;  // reverse the x locations
630  x2=width()-i-1;
631
632  if (x1<0)
633  { x-=x1; x1=0; }
634  if (y1<0)
635  { y-=y1; y1=0; }
636
637  if (screen->special)
638  {
[115]639    screen->special->get_clip(cx1, cy1, cx2, cy2);
[2]640    if (x>cx2 || y>cy2 || x+(x2-x1)<0 || y+(y2-y1)<0) return ;
641    if (x<cx1)
642    { x1+=(cx1-x); x=cx1; }
643    if (y<cy1)
644    { y1+=(cy1-y); y=cy1; }
645    if (x+x2-x1+1>cx2)
646    { x2=cx2-x+x1; }
647    if (y+y2-y1+1>cy2)
648    { y2=cy2-y+y1; }
649  }
650  else  if (x>screen->width() || y>screen->height() || x+x2<0 || y+y2<0)
651    return ;
652
653  if (x<screen->width() && y<screen->height() && x1<width() && y1<height() &&
654      x1<=x2 && y1<=y2)
655  {
656    if (x2>=width())
657      x2=width()-1;
658    if (y2>=height())
659      y2=height()-1;
660    xl=x2-x1+1;
661    if (x+xl>screen->width())
662      xl=screen->width()-x;
663    yl=y2-y1+1;
664    if (y+yl>screen->height())
665      yl=screen->height()-y;
[115]666    screen->add_dirty(x, y, x+xl-1, y+yl-1);
667    screen->lock();
668    lock();
669    for (j=0; j<yl; j++)
[2]670    {
671      pg1=screen->scan_line(y+j);
672      pg2=scan_line(y1+j);
673      if (transparent)
674      {
[115]675    for (i=0, source=&pg2[x1], dest=&pg1[x+xl-1]; i<xl; i++, source++, dest--)
[2]676          if (*source!=current_background) *dest=*source;
677      }
678      else
[115]679    for (i=0, source=&pg2[x1], dest=&pg1[x+xl-1]; i<xl; i++, source++, dest++)
[2]680          *dest=*source;
681    }
[115]682    unlock();
683    screen->unlock();
[2]684  }
685}
686
687
[17]688void image::put_part_masked(image *screen, image *mask, int16_t x, int16_t y,
[115]689        int16_t maskx, int16_t masky,
690        int16_t x1, int16_t y1, int16_t x2, int16_t y2)
[2]691{
[115]692  int16_t xl, yl, j, i, ml, mh;
693  int16_t cx1, cy1, cx2, cy2;
694  uint8_t *pg1, *pg2, *pg3;
[2]695  CHECK(x1<=x2 && y1<=y2);
696
697  if (screen->special)
698  {
[115]699    screen->special->get_clip(cx1, cy1, cx2, cy2);
[2]700    if (x>cx2 || y>cy2 || x+(x2-x1)<0 || y+(y2-y1)<0) return ;
701    if (x<cx1)
702    { x1+=(cx1-x); x=cx1; }
703    if (y<cy1)
704    { y1+=(cy1-y); y=cy1; }
705    if (x+x2-x1>cx2)
706    { x2=cx2+x1-x; }
707    if (y+y2-y1>cy2)
708    { y2=cy2+y1-y; }
709  }
710  else  if (x>screen->width() || y>screen->height() || x+x1<0 || y+y1<0)
711    return ;
712
713  ml=mask->width();
714  mh=mask->height();
715  if (x<screen->width() && y<screen->height() && x1<width() && y1<height() &&
716      maskx<ml && masky<mh && x1<=x2 && y1<=y2)
717  {
718
719    if (x2>=width())
720      x2=width()-1;
721    if (y2>=height())
722      y2=height()-1;
723    xl=x2-x1+1;
724    if (x+xl>screen->width())
725      xl=screen->width()-x-1;
726    yl=y2-y1+1;
727    if (y+yl>screen->height())
728      yl=screen->height()-y-1;
[115]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++)
[2]734    {
735      pg1=screen->scan_line(y+j);
736      pg2=scan_line(y1+j);
737      pg3=mask->scan_line(masky++);
738      if (masky>=mh)           // wrap the mask around if out of bounds
[115]739    masky=0;
740      for (i=0; i<xl; i++)
[2]741      {
[115]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;
[2]746      }
747    }
[115]748    unlock();
749    mask->unlock();
750    screen->unlock();
[2]751  }
752}
753
754
755
[17]756uint8_t image::brightest_color(palette *pal)
[115]757{ uint8_t *p, r, g, b, bri;
758  int16_t i, j;
[17]759  int32_t brv;
[2]760  brv=0; bri=0;
[115]761  lock();
762  for (j=0; j<h; j++)
[2]763  {
764    p=scan_line(j);
[115]765    for (i=0; i<w; i++)
766    { pal->get(p[i], r, g, b);
[17]767      if ((int32_t)r*(int32_t)g*(int32_t)b>brv)
768      { brv=(int32_t)r*(int32_t)g*(int32_t)b;
[115]769    bri=p[i];
[2]770      }
771    }
772  }
[115]773  unlock();
[2]774  return bri;
775}
776
[17]777uint8_t image::darkest_color(palette *pal, int16_t noblack)
[115]778{ uint8_t *p, r, g, b, bri;
779  int16_t i, j;
780  int32_t brv, x;
[17]781  brv=(int32_t)258*(int32_t)258*(int32_t)258; bri=0;
[115]782  lock();
783  for (j=0; j<h; j++)
[2]784  {
785    p=scan_line(j);
[115]786    for (i=0; i<w; i++)
787    { pal->get(p[i], r, g, b);
[17]788      x=(int32_t)r*(int32_t)g*(int32_t)b;
[2]789      if (x<brv && (x || !noblack))
790      { brv=x;
[115]791    bri=p[i];
[2]792      }
793    }
794  }
[115]795  unlock();
[2]796  return bri;
797}
798
[115]799void image::rectangle(int16_t x1, int16_t y1, int16_t x2, int16_t y2, uint8_t color)
[2]800{
[115]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);
[2]805}
806
[17]807void image::set_clip(int16_t x1, int16_t y1, int16_t x2, int16_t y2)
[2]808{
[112]809    // If the image does not already have an Image descriptor, allocate one
810    // with no dirty rectangle keeping.
811    if(!special)
812        special = new image_descriptor(width(), height(), 0);
[2]813
[112]814    // set the image descriptor what the clip
815    // should be it will adjust to fit within the image.
816    special->set_clip(x1, y1, x2, y2);
[2]817}
818
[17]819void image::get_clip (int16_t &x1, int16_t &y1, int16_t &x2, int16_t &y2)
[2]820{
821  if (special)
[115]822    special->get_clip(x1, y1, x2, y2);
[2]823  else
824  { x1=0; y1=0; x2=width()-1; y2=height()-1; }
825}
826
[17]827void image::in_clip  (int16_t x1, int16_t y1, int16_t x2, int16_t y2)
[2]828{
829  if (special)
830  {
831    if (x1<special->x1_clip())
832      x1=special->x1_clip();
833    if (y1<special->y1_clip())
834      y1=special->y1_clip();
835    if (x2>special->x2_clip())
836      x2=special->x2_clip();
837    if (y2>special->y2_clip())
838      y2=special->y2_clip();
839  }
[115]840  set_clip(x1, y1, x2, y2);
[2]841}
[112]842
843//
844// reduce the number of dirty rectanges to 1 by finding the minmum area that
845// can contain all the rectangles and making this the new dirty area
846//
[2]847void image_descriptor::reduce_dirties()
848{
[115]849  dirty_rect *p, *q;
850  int16_t x1, y1, x2, y2, nn;
[2]851  x1=6000; y1=6000;
852  x2=0; y2=0;
853  p=(dirty_rect *)dirties.first();
854  nn=dirties.number_nodes();
855  while (nn>0)
856  {
857    if (p->dx1<x1) x1=p->dx1;
858    if (p->dy1<y1) y1=p->dy1;
859    if (p->dx2>x2) x2=p->dx2;
860    if (p->dy2>y2) y2=p->dy2;
861    q=p;
862    p=(dirty_rect *)p->next();
863    dirties.unlink((linked_node *)q);
864    delete q;
865    nn--;
866  }
[115]867  dirties.add_front((linked_node *) new dirty_rect(x1, y1, x2, y2));
[2]868}
869
870void image_descriptor::delete_dirty(int x1, int y1, int x2, int y2)
871{
[115]872  int16_t i, ax1, ay1, ax2, ay2;
873  dirty_rect *p, *next;
[2]874  if (keep_dirt)
875  {
876    if (x1<0) x1=0;
877    if (y1<0) y1=0;
878    if (x2>=(int)l) x2=l-1;
879    if (y2>=(int)h) y2=h-1;
880    if (x1>x2) return;
881    if (y1>y2) return ;
882
883    i=dirties.number_nodes();
884    if (!i)
885      return ;
886    else
887    {
[115]888      for (p=(dirty_rect *)dirties.first(); i; i--, p=(dirty_rect *)next)
[2]889      {
890        next=(dirty_rect *)p->next();
891        // are the two touching?
[115]892    if (!(x2<p->dx1 || y2<p->dy1 || x1>p->dx2 || y1>p->dy2))
[2]893        {
894          // does it take a x slice off? (across)
895          if (x2>=p->dx2 && x1<=p->dx1)
896          {
897            if (y2>=p->dy2 && y1<=p->dy1)
898            {
899              dirties.unlink((linked_node *)p);
900              delete p;
901            }
902            else if (y2>=p->dy2)
903              p->dy2=y1-1;
904            else if (y1<=p->dy1)
905              p->dy1=y2+1;
906            else
907            {
[115]908              dirties.add_front((linked_node *) new dirty_rect(p->dx1, p->dy1, p->dx2, y1-1));
[2]909              p->dy1=y2+1;
910            }
911          }
912          // does it take a y slice off (down)
913          else if (y2>=p->dy2 && y1<=p->dy1)
914          {
915            if (x2>=p->dx2)
916              p->dx2=x1-1;
917            else if (x1<=p->dx1)
918              p->dx1=x2+1;
919            else
920            {
[115]921              dirties.add_front((linked_node *) new dirty_rect(p->dx1, p->dy1, x1-1, p->dy2));
[2]922              p->dx1=x2+1;
923            }
924          }
925          // otherwise it just takes a little chunk off
926          else
927          {
928            if (x2>=p->dx2)      { ax1=p->dx1; ax2=x1-1; }
929            else if (x1<=p->dx1) { ax1=x2+1; ax2=p->dx2; }
930            else                { ax1=p->dx1; ax2=x1-1; }
931            if (y2>=p->dy2)      { ay1=y1; ay2=p->dy2; }
932            else if (y1<=p->dy1) { ay1=p->dy1; ay2=y2; }
933            else                { ay1=y1; ay2=y2; }
[115]934            dirties.add_front((linked_node *) new dirty_rect(ax1, ay1, ax2, ay2));
[2]935         
936            if (x2>=p->dx2 || x1<=p->dx1)  { ax1=p->dx1; ax2=p->dx2; }
937            else                         { ax1=x2+1; ax2=p->dx2; }
938
939            if (y2>=p->dy2)
940            { if (ax1==p->dx1) { ay1=p->dy1; ay2=y1-1; }
941                          else { ay1=y1; ay2=p->dy2;   } }
942            else if (y1<=p->dy1) { if (ax1==p->dx1) { ay1=y2+1; ay2=p->dy2; }
943                                             else  { ay1=p->dy1; ay2=y2; } }
944            else           { if (ax1==p->dx1) { ay1=p->dy1; ay2=y1-1; }
945                             else { ay1=y1; ay2=y2; } }
[115]946            dirties.add_front((linked_node *) new dirty_rect(ax1, ay1, ax2, ay2));
[2]947
948            if (x1>p->dx1 && x2<p->dx2)
949            {
950              if (y1>p->dy1 && y2<p->dy2)
951              {
[115]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));
[2]954              } else if (y1<=p->dy1)
[115]955                dirties.add_front((linked_node *) new dirty_rect(p->dx1, y2+1, p->dx2, p->dy2));
[2]956              else
[115]957                dirties.add_front((linked_node *) new dirty_rect(p->dx1, p->dy1, p->dx2, y1-1));
[2]958            } else if (y1>p->dy1 && y2<p->dy2)
[115]959              dirties.add_front((linked_node *) new dirty_rect(p->dx1, y2+1, p->dx2, p->dy2));
[2]960            dirties.unlink((linked_node *) p);
961            delete p;
962          }
963        }
964      }
965    }
966  }
967}
968
969// specifies that an area is a dirty
970void image_descriptor::add_dirty(int x1, int y1, int x2, int y2)
971{
[17]972  int16_t i;
[2]973  dirty_rect *p;
974  if (keep_dirt)
975  {
976    if (x1<0) x1=0;
977    if (y1<0) y1=0;
978    if (x2>=(int)l) x2=l-1;
979    if (y2>=(int)h) y2=h-1;
980    if (x1>x2) return;
981    if (y1>y2) return ;
982    i=dirties.number_nodes();
983    if (!i)
[115]984      dirties.add_front((linked_node *) new dirty_rect(x1, y1, x2, y2));
[2]985    else if (i>=MAX_DIRTY)
986    {
[115]987      dirties.add_front((linked_node *) new dirty_rect(x1, y1, x2, y2));
[2]988      reduce_dirties();  // reduce to one dirty rectangle, we have to many
989    }
990    else
991    { 
[115]992      for (p=(dirty_rect *)dirties.first(); i>0; i--)
[2]993      {
994
995        // check to see if this new rectangle completly encloses the check rectangle
[115]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    {     
[2]1007
1008
[115]1009     
[2]1010/*          if (x1<=p->dx1) { a+=p->dx1-x1; ax1=x1; } else ax1=p->dx1;
1011          if (y1<=p->dy1) { a+=p->dy1-y1; ay1=y1; } else ay1=p->dy1;
1012          if (x2>=p->dx2) { a+=x2-p->dx2; ax2=x2; } else ax2=p->dx2;
1013          if (y2>=p->dy2) { a+=y2-p->dy2; ay2=y2; } else ay2=p->dy2;
[115]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 ;
[2]1021      }
[115]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   
1037      }
[2]1038      CHECK(x1<=x2 && y1<=y2);
[115]1039      dirties.add_end((linked_node *)new dirty_rect(x1, y1, x2, y2));
[2]1040    }
1041  }
1042}
1043
[17]1044void image::bar      (int16_t x1, int16_t y1, int16_t x2, int16_t y2, uint8_t color)
[2]1045{
[17]1046  int16_t y;
[2]1047  if (x1>x2 || y1>y2) return ;
1048  if (special)
1049  { x1=special->bound_x1(x1);
1050    y1=special->bound_y1(y1);
1051    x2=special->bound_x2(x2);
1052    y2=special->bound_y2(y2);
1053  }
1054  else
1055  { if (x1<0) x1=0;
1056    if (y1<0) y1=0;
1057    if (x2>=width())  x2=width()-1;
1058    if (y2>=height()) y2=height()-1;
1059  }
1060  if (x2<0 || y2<0 || x1>=width() || y1>=height() || x2<x1 || y2<y1)
1061    return ;
[115]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);
[2]1067}
1068
[17]1069void image::xor_bar  (int16_t x1, int16_t y1, int16_t x2, int16_t y2, uint8_t color)
[2]1070{
[115]1071  int16_t y, x;
[2]1072  if (x1>x2 || y1>y2) return ;
1073  if (special)
1074  { x1=special->bound_x1(x1);
1075    y1=special->bound_y1(y1);
1076    x2=special->bound_x2(x2);
1077    y2=special->bound_y2(y2);
1078  }
1079  else
1080  { if (x1<0) x1=0;
1081    if (y1<0) y1=0;
1082    if (x2>=width())  x2=width()-1;
1083    if (y2>=height()) y2=height()-1;
1084  }
1085  if (x2<0 || y2<0 || x1>=width() || y1>=height() || x2<x1 || y2<y1)
1086    return ;
1087
[115]1088  lock();
[17]1089  uint8_t *sl=scan_line(y1)+x1;
[115]1090  for (y=y1; y<=y2; y++)
[2]1091  {
[17]1092    uint8_t *s=sl;
[115]1093    for (x=x1; x<=x2; x++, s++)
[2]1094      *s=(*s)^color;
1095    sl+=w;
1096  }
[115]1097  unlock();
[2]1098
[115]1099  add_dirty(x1, y1, x2, y2);
[2]1100}
1101
1102
[17]1103void image::unpack_scanline(int16_t line, char bitsperpixel)
[2]1104{
[17]1105  int16_t x;
[115]1106  uint8_t *sl, *ex, mask, bt, sh;
1107  ex=(uint8_t *)jmalloc(width(), "image::unpacked scanline");
1108
1109  lock();
[2]1110  sl=scan_line(line);
[115]1111  memcpy(ex, sl, width());
1112  unlock();
[2]1113
1114  if (bitsperpixel==1)      { mask=128;           bt=8; }
1115  else if (bitsperpixel==2) { mask=128+64;        bt=4; }
[115]1116  else                 {  mask=128+64+32+16; bt=2; }
[2]1117
[115]1118  for (x=0; x<width(); x++)
[2]1119  { sh=((x%bt)<<(bitsperpixel-1));
1120    sl[x]=(ex[x/bt]&(mask>>sh))>>(bt-sh-1);
1121  }
1122
1123  jfree((char *)ex);
1124}
1125
1126void image::dither(palette *pal)
1127{
[115]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};
[2]1133
[17]1134  uint8_t *sl;
[115]1135  lock();
1136  for (y=height()-1; y>=0; y--)
[2]1137  {
1138    sl=scan_line(y);
[115]1139    for (i=0, j=y%4, x=width()-1; x>=0; x--)
[2]1140    {
1141      if (pal->red(sl[x])>dt_matrix[j*4+i])
[115]1142    sl[x]=255;
[2]1143      else sl[x]=0;
1144      if (i==3) i=0; else i++;
1145    }
1146  }
[115]1147  unlock();
[2]1148}
1149
1150void image_descriptor::clear_dirties()
1151{
1152  dirty_rect *dr;
1153  dr=(dirty_rect *)dirties.first(); 
1154  while (dr)
1155  { dirties.unlink(dr);
1156    delete dr;
1157    dr=(dirty_rect *)dirties.first();
1158  }
1159}
1160
[17]1161void image::resize(int16_t new_width, int16_t new_height)
[2]1162{
[115]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());
[2]1167
1168  delete_page();
[115]1169  make_page(new_width, new_height, NULL);
[2]1170  w=new_width;      // set the new hieght and width
1171  h=new_height;
1172
[115]1173  uint8_t *sl1, *sl2;
1174  int16_t y, y2, x2;
1175  double yc, xc, yd, xd;
[2]1176
1177
1178
1179  yc=(double)old_height/(double)new_height;
1180  xc=(double)old_width/(double)new_width;
[115]1181  for (y2=0, yd=0; y2<new_height; yd+=yc, y2++)
[2]1182  {
1183    y=(int)yd;
1184    sl1=im+y*old_width;
1185    sl2=scan_line(y2);
[115]1186    for (xd=0, x2=0; x2<new_width; xd+=xc, x2++)
[2]1187    { sl2[x2]=sl1[(int)xd]; }
1188  }
1189  jfree(im);
[115]1190  if (special) special->resize(new_width, new_height);
1191  unlock();
[2]1192}
1193
[17]1194void image::scroll(int16_t x1, int16_t y1, int16_t x2, int16_t y2, int16_t xd, int16_t yd)
[2]1195{
[115]1196  int16_t cx1, cy1, cx2, cy2;
[2]1197  CHECK(x1>=0 && y1>=0 && x1<x2 && y1<y2 && x2<width() && y2<height());
1198  if (special)
1199  {
[115]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);
[2]1202  }
[115]1203  int16_t xsrc, ysrc, xdst, ydst, xtot=x2-x1-abs(xd)+1, ytot, xt;
1204  uint8_t *src, *dst;
[2]1205  if (xd<0) { xsrc=x1-xd; xdst=x1; } else { xsrc=x2-xd; xdst=x2; }
1206  if (yd<0) { ysrc=y1-yd; ydst=y1; } else { ysrc=y2-yd; ydst=y2; }
[115]1207  for (ytot=y2-y1-abs(yd)+1; ytot; ytot--)
[2]1208  { src=scan_line(ysrc)+xsrc;
1209    dst=scan_line(ydst)+xdst;
1210    if (xd<0)
[115]1211      for (xt=xtot; xt; xt--)
[2]1212        *(dst++)=*(src++);
[115]1213      else for (xt=xtot; xt; xt--)
[2]1214        *(dst--)=*(src--);
1215    if (yd<0) { ysrc++; ydst++; } else { ysrc--; ydst--; }
1216  }
[115]1217  add_dirty(x1, y1, x2, y2);
[2]1218}
1219
1220
[17]1221image *image::create_smooth(int16_t smoothness)
[2]1222{
[115]1223  int16_t i, j, k, l, t, d;
[2]1224  image *im;
1225  CHECK(smoothness>=0);
1226  if (!smoothness) return NULL;
1227  d=smoothness*2+1;
1228  d=d*d;
[115]1229  im=new image(width(), height());
1230  for (i=0; i<width(); i++)
1231    for (j=0; j<height(); j++)
[2]1232    {
[115]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);
[2]1239    }
1240  return im;
1241}
1242
[112]1243void image::widget_bar(int16_t x1, int16_t y1, int16_t x2, int16_t y2,
[115]1244       uint8_t light, uint8_t med, uint8_t dark)
[2]1245{
[115]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);
[2]1251}
1252
1253class fill_rec
1254{
1255public :
[115]1256  int16_t x, y;
[2]1257  fill_rec *last;
[17]1258  fill_rec(int16_t X, int16_t Y, fill_rec *Last)
[2]1259  { x=X; y=Y; last=Last; }
1260} ;
1261
[17]1262void image::flood_fill(int16_t x, int16_t y, uint8_t color)
[2]1263{
[115]1264  uint8_t *sl, *above, *below;
1265  fill_rec *recs=NULL, *r;
[17]1266  uint8_t fcolor;
[115]1267  lock();
[2]1268  sl=scan_line(y);
1269  fcolor=sl[x];
1270  if (fcolor==color) return ;
1271  do
1272  {
1273    if (recs)
1274    { r=recs;
1275      recs=recs->last;
1276      x=r->x; y=r->y;
1277      delete r;
1278    }
1279    sl=scan_line(y);
1280    if (sl[x]==fcolor)
1281    {
1282      while (sl[x]==fcolor && x>0) x--;
1283      if (sl[x]!=fcolor) x++;
1284      if (y>0)
1285      {
1286        above=scan_line(y-1);
1287        if (above[x]==fcolor)
[115]1288        { r=new fill_rec(x, y-1, recs);
[2]1289          recs=r; 
1290        }
1291      }
1292      if (y<height()-1)
1293      {
1294        above=scan_line(y+1);
1295        if (above[x]==fcolor)
[115]1296        { r=new fill_rec(x, y+1, recs);
[2]1297          recs=r;
1298        }
1299      }
1300
1301
1302
1303      do
1304      {
1305        sl[x]=color;
1306        if (y>0)
1307        { above=scan_line(y-1);
1308          if (x>0 && above[x-1]!=fcolor && above[x]==fcolor)
[115]1309          { r=new fill_rec(x, y-1, recs);
[2]1310            recs=r; 
1311          }
1312        }
1313        if (y<height()-1)
1314        { below=scan_line(y+1);
1315          if (x>0 && below[x-1]!=fcolor && below[x]==fcolor)
[115]1316          { r=new fill_rec(x, y+1, recs);
[2]1317            recs=r; 
1318          }
1319        }
1320        x++;
1321      } while (sl[x]==fcolor && x<width());
1322      x--;
1323      if (y>0)
1324      {
1325        above=scan_line(y-1);
1326        if (above[x]==fcolor)
[115]1327        { r=new fill_rec(x, y-1, recs);
[2]1328          recs=r;
1329        }
1330      }
1331      if (y<height()-1)
1332      {
1333        above=scan_line(y+1);
1334        if (above[x]==fcolor)
[115]1335        { r=new fill_rec(x, y+1, recs);
[2]1336          recs=r;
1337        }
1338      }
1339    }
1340  } while (recs);
[115]1341  unlock();
[2]1342}
1343
1344
1345#define LED_L 5
1346#define LED_H 5
[17]1347void image::burn_led(int16_t x, int16_t y, int32_t num, int16_t color, int16_t scale)
[2]1348{
1349  char st[100];
[115]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};
[2]1352
[115]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++)
[2]1358  {
1359    if (st[xx]!=' ')
1360    {
1361      if (st[xx]=='-')
[115]1362    zz=10;
[2]1363      else
[115]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);
[2]1369    }
1370    x+=6*scale;
1371  }
1372}
1373
[115]1374uint8_t dither_matrix[]={0,  136, 24, 170,
1375             68, 204, 102, 238,
1376             51, 187, 17, 153,
1377             119, 255, 85, 221};
[2]1378
[17]1379image *image::copy_part_dithered (int16_t x1, int16_t y1, int16_t x2, int16_t y2)
[2]1380{
[115]1381  int16_t x, y, cx1, cy1, cx2, cy2, ry, rx, bo, dity, ditx;
[2]1382  image *ret;
[115]1383  uint8_t *sl1, *sl2;
1384  get_clip(cx1, cy1, cx2, cy2);
[2]1385  if (y1<cy1) y1=cy1;
1386  if (x1<cx1) x1=cx1;
1387  if (y2>cy2) y2=cy2;
1388  if (x2>cx2) x2=cx2;
1389  CHECK(x2>=x1 && y2>=y1);
1390  if (x2<x1 || y2<y1) return NULL;
[115]1391  ret=new image((x2-x1+8)/8, (y2-y1+1));
[2]1392  if (!last_loaded())
1393    ret->clear();
1394  else
[115]1395  {
1396    ret->lock();
1397    lock();
1398    for (y=y1, ry=0, dity=(y1%4)*4; y<=y2; y++, ry++)
[2]1399    {
1400      sl1=ret->scan_line(ry);     // sl1 is the scan linefo the return image
1401      sl2=scan_line(y);          // sl2 is the orginal image scan line
[115]1402      memset(sl1, 0, (x2-x1+8)/8);
1403      for (bo=7, rx=0, x=x1, ditx=x1%4; x<=x2; x++)
[2]1404      {
1405        if (last_loaded()->red(sl2[x])>dither_matrix[ditx+dity])
[115]1406          sl1[rx]|=1<<bo;
[2]1407        if (bo!=0)
[115]1408      bo--;
[2]1409        else
1410        {
[115]1411        rx++;
1412      bo=7;
[2]1413        }
1414        ditx+=1; if (ditx>3) ditx=0;
1415      }
1416      dity+=4; if (dity>12) dity=0;
1417    }
[115]1418    unlock();
1419    ret->unlock();
1420  }
[2]1421  return ret;
1422}
1423
1424void image::flip_x()
1425{
[115]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++)
[2]1433  { sl=scan_line(y);
[115]1434    for (i=0, x=width()-1; x>=0; x--, i++)
[2]1435      rev[i]=sl[x];
[115]1436    memcpy(sl, rev, width());
[2]1437  }
[115]1438  unlock();
[2]1439  jfree(rev);
1440}
1441
1442void image::flip_y()
1443{
[115]1444  uint8_t *rev=(uint8_t *)jmalloc(width(), "image::flipped_y"), *sl;
1445  CONDITION(rev, "memory allocation");
[2]1446  int y;
[115]1447
1448  /* FIXME: Abuse Win32 uses RestoreSurface() here instead of locking */
1449  lock();
1450  for (y=0; y<height()/2; y++)
[2]1451  { sl=scan_line(y);
[115]1452    memcpy(rev, sl, width());
1453    memcpy(sl, scan_line(height()-y-1), width());
1454    memcpy(scan_line(height()-y-1), rev, width());
[2]1455  }
[115]1456  unlock();
1457  jfree(rev);
[2]1458}
1459
[17]1460void image::make_color(uint8_t color)
[2]1461{
[17]1462  uint8_t *sl;
[115]1463  int y, x;
1464  lock();
1465  for (y=0; y<height(); y++)
[2]1466  {
1467    sl=scan_line(y);
[115]1468    for (x=width(); x; x--, sl++)
[2]1469      if (*sl)
1470        *sl=color;
1471  }
[115]1472  unlock();
[2]1473}
Note: See TracBrowser for help on using the repository browser.