Ignore:
Timestamp:
Apr 20, 2011, 9:02:21 PM (11 years ago)
Author:
Sam Hocevar
Message:

imlib: image::Pixel and image::PutPixel? now use vec2i arguments.

File:
1 edited

Legend:

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

    r513 r515  
    8282image_descriptor::image_descriptor(vec2i size,
    8383                   int keep_dirties, int static_memory)
    84 
    85 { clipx1=0; clipy1=0;
    86   l=size.x; h=size.y;
    87   clipx2=l-1; clipy2=h-1;
    88   keep_dirt=keep_dirties;
    89   static_mem=static_memory;
     84{
     85    clipx1 = 0; clipy1 = 0;
     86    l = size.x; h = size.y;
     87    clipx2 = l - 1; clipy2 = h - 1;
     88    keep_dirt = keep_dirties;
     89    static_mem = static_memory;
    9090}
    9191
    9292void image::SetSize(vec2i new_size, uint8_t *page)
    9393{
    94     delete_page();
     94    DeletePage();
    9595    m_size = new_size;
    96     make_page(new_size, page);
     96    MakePage(new_size, page);
     97}
     98
     99void image::MakePage(vec2i size, uint8_t *page_buffer)
     100{
     101    m_data = page_buffer ? page_buffer : (uint8_t *)malloc(size.x * size.y);
     102}
     103
     104void image::DeletePage()
     105{
     106    if(!m_special || !m_special->static_mem)
     107        free(m_data);
    97108}
    98109
     
    102113    {
    103114        fprintf(stderr, "Error: image is locked upon deletion\n");
    104         unlock();
     115        Unlock();
    105116    }
    106117
    107118    image_list.unlink((linked_node *)this);
    108     delete_page();
    109     if(special)
    110         delete special;
    111 }
    112 
    113 
    114 void make_block(size_t size)
    115 {
    116   void *dat=malloc(size);
    117   CONDITION(dat, "Memory error : could not make block\n");
    118   if (dat) free((char *)dat);
    119 }
    120 
    121 uint8_t image::pixel(int16_t x, int16_t y)
    122 {
    123   CONDITION(x>=0 && x<m_size.x && y>=0 && y<m_size.y,
    124      "image::pixel Bad pixel xy");
    125   return (*(scan_line(y)+x));
    126 }
    127 
    128 void image::putpixel(int16_t x, int16_t y, char color)
    129 {
    130   CONDITION(x>=0 && x<m_size.x && y>=0 && y<m_size.y,
    131      "image::putpixel Bad pixel xy");
    132   if (special)
    133   { if (x>=special->x1_clip() && x<=special->x2_clip() &&
    134     y>=special->y1_clip() && y<=special->y2_clip())
    135       (*(scan_line(y)+x))=color;
    136   } else (*(scan_line(y)+x))=color;
     119    DeletePage();
     120    delete m_special;
     121}
     122
     123uint8_t image::Pixel(vec2i pos)
     124{
     125    CONDITION(pos.x >= 0 && pos.x < m_size.x && pos.y >= 0 && pos.y < m_size.y,
     126              "image::Pixel Bad pixel xy");
     127    return scan_line(pos.y)[pos.x];
     128}
     129
     130void image::PutPixel(vec2i pos, uint8_t color)
     131{
     132    CONDITION(pos.x >= 0 && pos.x < m_size.x && pos.y >= 0 && pos.y < m_size.y,
     133              "image::PutPixel Bad pixel xy");
     134
     135    if (m_special &&
     136         pos.x >= m_special->x1_clip() && pos.x <= m_special->x2_clip() &&
     137         pos.y >= m_special->y1_clip() && pos.y <= m_special->y2_clip())
     138        return;
     139
     140    scan_line(pos.y)[pos.x] = color;
    137141}
    138142
     
    144148    {
    145149        if (create_descriptor==2)
    146             special=new image_descriptor(size, 1, (page_buffer!=NULL));
     150            m_special=new image_descriptor(size, 1, (page_buffer!=NULL));
    147151        else
    148             special=new image_descriptor(size, 0, (page_buffer!=NULL));
     152            m_special=new image_descriptor(size, 0, (page_buffer!=NULL));
    149153    }
    150154    else
    151         special = NULL;
    152     make_page(size, page_buffer);
     155        m_special = NULL;
     156    MakePage(size, page_buffer);
    153157    image_list.add_end((linked_node *)this);
    154158    m_locked = false;
     
    160164    m_size.x = fp->read_uint16();
    161165    m_size.y = fp->read_uint16();
    162     special = NULL;
    163     make_page(m_size, NULL);
     166    m_special = NULL;
     167    MakePage(m_size, NULL);
    164168    for (int i = 0; i < m_size.y; i++)
    165169        fp->read(scan_line(i), m_size.x);
     
    172176    m_size.x = fp->read_uint16();
    173177    m_size.y = fp->read_uint16();
    174     special = NULL;
    175     make_page(m_size, NULL);
     178    m_special = NULL;
     179    MakePage(m_size, NULL);
    176180    for (int i = 0; i < m_size.y; i++)
    177181        fp->read(scan_line(i), m_size.x);
     
    180184}
    181185
    182 void image::lock()
     186void image::Lock()
    183187{
    184188    /* This is currently a no-op, because it's unneeded with SDL */
     
    189193}
    190194
    191 void image::unlock()
     195void image::Unlock()
    192196{
    193197    /* This is currently a no-op, because it's unneeded with SDL */
     
    237241    uint8_t *c;
    238242
    239     lock();
     243    Lock();
    240244    for(co = 0, i = m_size.y - 1; i >= 0; i--)
    241245    {
     
    244248            if(*c != background) co++;
    245249    }
    246     unlock();
     250    Unlock();
    247251    return co;
    248252}
     
    252256    int16_t i;
    253257
    254     lock();
     258    Lock();
    255259    if(color == -1)
    256260        color = current_background;
    257     if(special)
    258     {
    259         if(special->x1_clip() <= special->x2_clip())
    260             for(i = special->y2_clip(); i >= special->y1_clip(); i--)
    261                 memset(scan_line(i) + special->x1_clip(), color,
    262                        special->x2_clip() - special->x1_clip() + 1);
     261    if(m_special)
     262    {
     263        if(m_special->x1_clip() <= m_special->x2_clip())
     264            for(i = m_special->y2_clip(); i >= m_special->y1_clip(); i--)
     265                memset(scan_line(i) + m_special->x1_clip(), color,
     266                       m_special->x2_clip() - m_special->x1_clip() + 1);
    263267    }
    264268    else
     
    266270            memset(scan_line(i), color, m_size.x);
    267271    add_dirty(0, 0, m_size.x - 1, m_size.y - 1);
    268     unlock();
     272    Unlock();
    269273}
    270274
    271275image *image::copy()
    272276{
    273     lock();
     277    Lock();
    274278    image *im = new image(m_size);
    275     im->lock();
     279    im->Lock();
    276280    for(int i = m_size.y - 1; i >= 0; i--)
    277281        memcpy(im->scan_line(i), scan_line(i), m_size.x);
    278     im->unlock();
    279     unlock();
     282    im->Unlock();
     283    Unlock();
    280284    return im;
    281285}
     
    392396  er=0;
    393397
    394   lock();
     398  Lock();
    395399  if (n>m)
    396400  {
     
    421425    }
    422426  }
    423   unlock();
     427  Unlock();
    424428}
    425429
     
    431435
    432436    // the screen is clipped then we only want to put part of the image
    433     if(screen->special)
     437    if(screen->m_special)
    434438    {
    435439        put_part(screen, x, y, 0, 0, m_size.x-1, m_size.y-1, transparent);
     
    462466
    463467        screen->add_dirty(x, y, x + xl - 1, y + yl - 1);
    464         screen->lock();
    465         lock();
     468        screen->Lock();
     469        Lock();
    466470        for(j = starty; j < yl; j++, y++)
    467471        {
     
    481485                memcpy(&pg1[x], pg2, xl); // straight copy
    482486        }
    483         unlock();
    484         screen->unlock();
     487        Unlock();
     488        screen->Unlock();
    485489    }
    486490}
     
    492496  CHECK(x1<=x2 && y1<=y2);  // we should have gotten this
    493497
    494   if (screen->special)
    495   { x1=screen->special->bound_x1(x1);
    496     y1=screen->special->bound_y1(y1);
    497     x2=screen->special->bound_x2(x2);
    498     y2=screen->special->bound_y2(y2);
     498  if (screen->m_special)
     499  { x1=screen->m_special->bound_x1(x1);
     500    y1=screen->m_special->bound_y1(y1);
     501    x2=screen->m_special->bound_x2(x2);
     502    y2=screen->m_special->bound_y2(y2);
    499503  }
    500504  else
     
    517521    starty=0;
    518522  }
    519   screen->lock();
    520   lock();
     523  screen->Lock();
     524  Lock();
    521525  for (j=y1; j<=y2; j++)
    522526  {
     
    535539    }
    536540  }
    537   unlock();
    538   screen->unlock();
     541  Unlock();
     542  screen->Unlock();
    539543}
    540544
     
    584588  screen->add_dirty(x, y, x+xlen-1, y+ylen-1);
    585589
    586   screen->lock();
    587   lock();
     590  screen->Lock();
     591  Lock();
    588592  pg1=screen->scan_line(y);
    589593  pg2=scan_line(y1);
     
    606610    pg2=next_line(y1+j, pg2);
    607611  }
    608   unlock();
    609   screen->unlock();
     612  Unlock();
     613  screen->Unlock();
    610614}
    611615
     
    626630  { y-=y1; y1=0; }
    627631
    628   if (screen->special)
    629   {
    630     screen->special->get_clip(cx1, cy1, cx2, cy2);
     632  if (screen->m_special)
     633  {
     634    screen->m_special->get_clip(cx1, cy1, cx2, cy2);
    631635    if (x>cx2 || y>cy2 || x+(x2-x1)<0 || y+(y2-y1)<0) return ;
    632636    if (x<cx1)
     
    656660      yl=screen->Size().y-y;
    657661    screen->add_dirty(x, y, x+xl-1, y+yl-1);
    658     screen->lock();
    659     lock();
     662    screen->Lock();
     663    Lock();
    660664    for (j=0; j<yl; j++)
    661665    {
     
    671675          *dest=*source;
    672676    }
    673     unlock();
    674     screen->unlock();
     677    Unlock();
     678    screen->Unlock();
    675679  }
    676680}
     
    686690  CHECK(x1<=x2 && y1<=y2);
    687691
    688   if (screen->special)
    689   {
    690     screen->special->get_clip(cx1, cy1, cx2, cy2);
     692  if (screen->m_special)
     693  {
     694    screen->m_special->get_clip(cx1, cy1, cx2, cy2);
    691695    if (x>cx2 || y>cy2 || x+(x2-x1)<0 || y+(y2-y1)<0) return ;
    692696    if (x<cx1)
     
    719723      yl=screen->Size().y-y-1;
    720724    screen->add_dirty(x, y, x+xl-1, y+yl-1);
    721     screen->lock();
    722     mask->lock();
    723     lock();
     725    screen->Lock();
     726    mask->Lock();
     727    Lock();
    724728    for (j=0; j<yl; j++)
    725729    {
     
    737741      }
    738742    }
    739     unlock();
    740     mask->unlock();
    741     screen->unlock();
     743    Unlock();
     744    mask->Unlock();
     745    screen->Unlock();
    742746  }
    743747}
     
    750754  int32_t brv;
    751755  brv=0; bri=0;
    752   lock();
     756  Lock();
    753757  for (j=0; j<m_size.y; j++)
    754758  {
     
    762766    }
    763767  }
    764   unlock();
     768  Unlock();
    765769  return bri;
    766770}
     
    771775  int32_t brv, x;
    772776  brv=(int32_t)258*(int32_t)258*(int32_t)258; bri=0;
    773   lock();
     777  Lock();
    774778  for (j=0; j<m_size.y; j++)
    775779  {
     
    784788    }
    785789  }
    786   unlock();
     790  Unlock();
    787791  return bri;
    788792}
     
    800804    // If the image does not already have an Image descriptor, allocate one
    801805    // with no dirty rectangle keeping.
    802     if(!special)
    803         special = new image_descriptor(m_size.x, m_size.y, 0);
     806    if(!m_special)
     807        m_special = new image_descriptor(m_size.x, m_size.y, 0);
    804808
    805809    // set the image descriptor what the clip
    806810    // should be it will adjust to fit within the image.
    807     special->set_clip(x1, y1, x2, y2);
     811    m_special->set_clip(x1, y1, x2, y2);
    808812}
    809813
    810814void image::get_clip (int16_t &x1, int16_t &y1, int16_t &x2, int16_t &y2)
    811815{
    812   if (special)
    813     special->get_clip(x1, y1, x2, y2);
     816  if (m_special)
     817    m_special->get_clip(x1, y1, x2, y2);
    814818  else
    815819  { x1=0; y1=0; x2=m_size.x-1; y2=m_size.y-1; }
     
    818822void image::in_clip  (int16_t x1, int16_t y1, int16_t x2, int16_t y2)
    819823{
    820   if (special)
    821   {
    822     if (x1<special->x1_clip())
    823       x1=special->x1_clip();
    824     if (y1<special->y1_clip())
    825       y1=special->y1_clip();
    826     if (x2>special->x2_clip())
    827       x2=special->x2_clip();
    828     if (y2>special->y2_clip())
    829       y2=special->y2_clip();
     824  if (m_special)
     825  {
     826    if (x1<m_special->x1_clip())
     827      x1=m_special->x1_clip();
     828    if (y1<m_special->y1_clip())
     829      y1=m_special->y1_clip();
     830    if (x2>m_special->x2_clip())
     831      x2=m_special->x2_clip();
     832    if (y2>m_special->y2_clip())
     833      y2=m_special->y2_clip();
    830834  }
    831835  set_clip(x1, y1, x2, y2);
     
    10371041  int16_t y;
    10381042  if (x1>x2 || y1>y2) return ;
    1039   if (special)
    1040   { x1=special->bound_x1(x1);
    1041     y1=special->bound_y1(y1);
    1042     x2=special->bound_x2(x2);
    1043     y2=special->bound_y2(y2);
     1043  if (m_special)
     1044  { x1=m_special->bound_x1(x1);
     1045    y1=m_special->bound_y1(y1);
     1046    x2=m_special->bound_x2(x2);
     1047    y2=m_special->bound_y2(y2);
    10441048  }
    10451049  else
     
    10511055  if (x2<0 || y2<0 || x1>=m_size.x || y1>=m_size.y || x2<x1 || y2<y1)
    10521056    return ;
    1053   lock();
     1057  Lock();
    10541058  for (y=y1; y<=y2; y++)
    10551059    memset(scan_line(y)+x1, color, (x2-x1+1));
    1056   unlock();
     1060  Unlock();
    10571061  add_dirty(x1, y1, x2, y2);
    10581062}
     
    10621066  int16_t y, x;
    10631067  if (x1>x2 || y1>y2) return ;
    1064   if (special)
    1065   { x1=special->bound_x1(x1);
    1066     y1=special->bound_y1(y1);
    1067     x2=special->bound_x2(x2);
    1068     y2=special->bound_y2(y2);
     1068  if (m_special)
     1069  { x1=m_special->bound_x1(x1);
     1070    y1=m_special->bound_y1(y1);
     1071    x2=m_special->bound_x2(x2);
     1072    y2=m_special->bound_y2(y2);
    10691073  }
    10701074  else
     
    10771081    return ;
    10781082
    1079   lock();
     1083  Lock();
    10801084  uint8_t *sl=scan_line(y1)+x1;
    10811085  for (y=y1; y<=y2; y++)
     
    10861090    sl+=m_size.x;
    10871091  }
    1088   unlock();
     1092  Unlock();
    10891093
    10901094  add_dirty(x1, y1, x2, y2);
     
    10981102  ex=(uint8_t *)malloc(m_size.x);
    10991103
    1100   lock();
     1104  Lock();
    11011105  sl=scan_line(line);
    11021106  memcpy(ex, sl, m_size.x);
    1103   unlock();
     1107  Unlock();
    11041108
    11051109  if (bitsperpixel==1)      { mask=128;           bt=8; }
     
    11241128
    11251129  uint8_t *sl;
    1126   lock();
     1130  Lock();
    11271131  for (y=m_size.y-1; y>=0; y--)
    11281132  {
     
    11361140    }
    11371141  }
    1138   unlock();
     1142  Unlock();
    11391143}
    11401144
     
    11541158    vec2i old_size = m_size;
    11551159    uint8_t *im = (uint8_t *)malloc(old_size.x * old_size.y);
    1156     lock();
     1160    Lock();
    11571161    memcpy(im, scan_line(0), old_size.x * old_size.y);
    11581162
    1159     delete_page();
    1160     make_page(new_size, NULL);
     1163    DeletePage();
     1164    MakePage(new_size, NULL);
    11611165    m_size = new_size; // set the new height and width
    11621166
     
    11761180    }
    11771181    free(im);
    1178     if (special)
    1179         special->resize(new_size.x, new_size.y);
    1180     unlock();
     1182    if (m_special)
     1183        m_special->resize(new_size.x, new_size.y);
     1184    Unlock();
    11811185}
    11821186
     
    11851189  int16_t cx1, cy1, cx2, cy2;
    11861190  CHECK(x1>=0 && y1>=0 && x1<x2 && y1<y2 && x2<m_size.x && y2<m_size.y);
    1187   if (special)
    1188   {
    1189     special->get_clip(cx1, cy1, cx2, cy2);
     1191  if (m_special)
     1192  {
     1193    m_special->get_clip(cx1, cy1, cx2, cy2);
    11901194    x1=Max(x1, cx1); y1=Max(cy1, y1); x2=Min(x2, cx2); y2=Min(y2, cy2);
    11911195  }
     
    12231227    for (l=-smoothness; l<=smoothness; l++)
    12241228      if (i+k>smoothness && i+k<m_size.x-smoothness && j+l<m_size.y-smoothness && j+l>smoothness)
    1225         t+=pixel(i+k, j+l);
    1226       else t+=pixel(i, j);
    1227       im->putpixel(i, j, t/d);
     1229        t+=Pixel(vec2i(i+k, j+l));
     1230      else t+=Pixel(vec2i(i, j));
     1231      im->PutPixel(vec2i(i, j), t/d);
    12281232    }
    12291233  return im;
     
    12541258  fill_rec *recs=NULL, *r;
    12551259  uint8_t fcolor;
    1256   lock();
     1260  Lock();
    12571261  sl=scan_line(y);
    12581262  fcolor=sl[x];
     
    13281332    }
    13291333  } while (recs);
    1330   unlock();
     1334  Unlock();
    13311335}
    13321336
     
    13831387  else
    13841388  {
    1385     ret->lock();
    1386     lock();
     1389    ret->Lock();
     1390    Lock();
    13871391    for (y=y1, ry=0, dity=(y1%4)*4; y<=y2; y++, ry++)
    13881392    {
     
    14051409      dity+=4; if (dity>12) dity=0;
    14061410    }
    1407     unlock();
    1408     ret->unlock();
     1411    Unlock();
     1412    ret->Unlock();
    14091413  }
    14101414  return ret;
     
    14181422
    14191423  /* FIXME: Abuse Win32 uses RestoreSurface() here instead of locking */
    1420   lock();
     1424  Lock();
    14211425  for (y=0; y<m_size.y; y++)
    14221426  { sl=scan_line(y);
     
    14251429    memcpy(sl, rev, m_size.x);
    14261430  }
    1427   unlock();
     1431  Unlock();
    14281432  free(rev);
    14291433}
     
    14361440
    14371441  /* FIXME: Abuse Win32 uses RestoreSurface() here instead of locking */
    1438   lock();
     1442  Lock();
    14391443  for (y=0; y<m_size.y/2; y++)
    14401444  { sl=scan_line(y);
     
    14431447    memcpy(scan_line(m_size.y-y-1), rev, m_size.x);
    14441448  }
    1445   unlock();
     1449  Unlock();
    14461450  free(rev);
    14471451}
     
    14511455  uint8_t *sl;
    14521456  int y, x;
    1453   lock();
     1457  Lock();
    14541458  for (y=0; y<m_size.y; y++)
    14551459  {
     
    14591463        *sl=color;
    14601464  }
    1461   unlock();
    1462 }
     1465  Unlock();
     1466}
Note: See TracChangeset for help on using the changeset viewer.