Ignore:
Timestamp:
Apr 22, 2011, 4:13:04 AM (11 years ago)
Author:
Sam Hocevar
Message:

imlib: some cleaning up in trans_image before I templatise half of it.

File:
1 edited

Legend:

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

    r521 r527  
    1717image *trans_image::make_image()
    1818{
    19   image *im=new image(vec2i(w,h));
     19  image *im = new image(m_size);
    2020
    2121  im->Lock();
    22   uint8_t *d=im->scan_line(0),*dp=data,*dline;
     22  uint8_t *d=im->scan_line(0),*dp=m_data,*dline;
    2323  int y,x;
    24   for (y=0; y<h; y++)
     24  for (y=0; y<m_size.y; y++)
    2525  {
    2626    x=0;
    2727    dline=d;
    28     memset(dline,0,w);
    29     while(x<w)
     28    memset(dline,0,m_size.x);
     29    while(x<m_size.x)
    3030    {
    3131      int skip=*(dp++);
    3232      dline+=skip;
    3333      x+=skip;
    34       if (x<w)
     34      if (x<m_size.x)
    3535      {
    3636    int run=*(dp++);
     
    5151  int size=0,x,y;
    5252  uint8_t *sl,*datap,*marker;
    53   w=im->Size().x;
    54   h=im->Size().y;
     53  m_size = im->Size();
    5554
    5655  im->Lock();
     
    6160    sl=im->scan_line(y);
    6261    x=0;
    63     while (x<w)
     62    while (x<m_size.x)
    6463    {
    6564      size++;
    66       while (x<w && *sl==0) { sl++; x++; }
    67 
    68       if (x<w)
     65      while (x<m_size.x && *sl==0) { sl++; x++; }
     66
     67      if (x<m_size.x)
    6968      {
    7069        size++;  // byte for the size of the run
    71         while (x<w && (*sl)!=0)
     70        while (x<m_size.x && (*sl)!=0)
    7271        {
    7372      size++;
     
    7978  }
    8079
    81   data=(uint8_t *)malloc(size);
     80  m_data=(uint8_t *)malloc(size);
    8281  int ww=im->Size().x,hh=im->Size().y;
    83   datap=data;
     82  datap=m_data;
    8483  if (!datap)
    8584  { printf("size = %d %d (%d)\n",im->Size().x,im->Size().y,size);  }
    86   CONDITION(datap,"malloc error for trans_image::data");
     85  CONDITION(datap,"malloc error for trans_image::m_data");
    8786
    8887  for (y=0; y<hh; y++)  // now actually make the runs
     
    116115}
    117116
     117trans_image::~trans_image()
     118{
     119    free(m_data);
     120}
     121
    118122void trans_image::put_scan_line(image *screen, int x, int y, int line)   // always transparent
    119123{
    120124  int x1, y1, x2, y2;
    121125  screen->GetClip(x1, y1, x2, y2);
    122   if (y + line < y1 || y + line >= y2 || x >= x2 || x + w - 1 < x1)
     126  if (y + line < y1 || y + line >= y2 || x >= x2 || x + m_size.x - 1 < x1)
    123127    return; // clipped off completely?
    124128
    125   uint8_t *datap=data;
     129  uint8_t *datap=m_data;
    126130  int ix;
    127131  while (line)            // skip scan line data until we get to the line of interest
    128132  {
    129     for (ix=0; ix<w; )
     133    for (ix=0; ix<m_size.x; )
    130134    {
    131135      ix+=*datap;        // skip blank space
    132136      datap++;
    133       if (ix<w)
     137      if (ix<m_size.x)
    134138      {
    135139    int run_length=*datap;     // skip run
     
    147151  uint8_t *screen_line=screen->scan_line(y)+x;
    148152
    149   for (ix=0; ix<w; )
     153  for (ix=0; ix<m_size.x; )
    150154  {
    151155    int skip=*datap;              // how much space to skip?
     
    154158    ix+=skip;
    155159
    156     if (ix<w)
     160    if (ix<m_size.x)
    157161    {
    158162      int run_length=*datap;
     
    204208{
    205209    // check to see if it is totally clipped out first
    206     if (y + h <= y1 || y >= y2 || x >= x2 || x + w <= x1)
     210    if (y + m_size.y <= y1 || y >= y2 || x >= x2 || x + m_size.x <= x1)
    207211        return NULL;
    208212
    209     uint8_t *parser = data;
     213    uint8_t *parser = m_data;
    210214
    211215    int skiplines = Max(y1 - y, 0); // number of lines to skip
    212     ysteps = Min(y2 - y, height() - skiplines); // number of lines to draw
     216    ysteps = Min(y2 - y, m_size.y - skiplines); // number of lines to draw
    213217    y += skiplines; // first line to draw
    214218
    215219    while (skiplines--)
    216220    {
    217         for (int ix = 0; ix < w; )
     221        for (int ix = 0; ix < m_size.x; )
    218222        {
    219223            ix += *parser++; // skip over empty space
    220224
    221             if (ix >= w)
     225            if (ix >= m_size.x)
    222226                break;
    223227
     
    227231    }
    228232
    229     screen->AddDirty(Max(x, x1), y, Min(x + width(), x2), y + h);
     233    screen->AddDirty(Max(x, x1), y, Min(x + m_size.x, x2), y + m_size.y);
    230234    return parser;
    231235}
     
    246250
    247251  screen_line=screen->scan_line(y)+x;
    248   int sw=screen->Size().x-w;
     252  int sw=screen->Size().x-m_size.x;
    249253  x1 -= x; x2 -= x;
    250254  for (; ysteps>0; ysteps--)
    251255  {
    252256    int ix,slam_length;
    253     for (ix=0; ix<w; )
     257    for (ix=0; ix<m_size.x; )
    254258    {
    255259      int blank=(*datap);
     
    259263
    260264      datap++;
    261       if (ix<w)
     265      if (ix<m_size.x)
    262266      {
    263267    slam_length=*datap;     // find the length of this run
     
    310314void trans_image::put_image_offseted(image *screen, uint8_t *s_off)   // if screen x & y offset already calculated save a mul
    311315{
    312   int ix,ysteps=height();
     316  int ix,ysteps=m_size.y;
    313317  int screen_skip;
    314   uint8_t skip,*datap=data;
     318  uint8_t skip,*datap=m_data;
    315319
    316320  screen->Lock();
    317   screen_skip = screen->Size().x - w;
     321  screen_skip = screen->Size().x - m_size.x;
    318322  for (; ysteps; ysteps--)
    319323  {
    320     for (ix=0; ix<w; )
     324    for (ix=0; ix<m_size.x; )
    321325    {
    322326      skip=*datap;       // skip leading blank space
     
    329333
    330334
    331       if (ix<w)
     335      if (ix<m_size.x)
    332336      {
    333337    skip=*datap;
     
    364368  {
    365369    int ix,slam_length;
    366     for (ix=0; ix<w; )
     370    for (ix=0; ix<m_size.x; )
    367371    {
    368372      ix+=(*datap);       // skip over empty space
    369373      datap++;
    370       if (ix<w)
     374      if (ix<m_size.x)
    371375      {
    372376    slam_length=*datap;     // find the length of this run
     
    430434  {
    431435    int ix,slam_length;
    432     for (ix=0; ix<w; )
     436    for (ix=0; ix<m_size.x; )
    433437    {
    434438      ix+=(*datap);       // skip over empty space
    435439      datap++;
    436       if (ix<w)
     440      if (ix<m_size.x)
    437441      {
    438442    slam_length=*datap;     // find the length of this run
     
    509513  {
    510514    int ix,slam_length;
    511     for (ix=0; ix<w; )
     515    for (ix=0; ix<m_size.x; )
    512516    {
    513517      ix+=(*datap);       // skip over empty space
    514518      datap++;
    515       if (ix<w)
     519      if (ix<m_size.x)
    516520      {
    517521    slam_length=*datap;     // find the length of this run
     
    592596    screen_line=screen->scan_line(y);
    593597
    594     for (ix=0; ix<w; )
     598    for (ix=0; ix<m_size.x; )
    595599    {
    596600      ix+=(*datap);       // skip over empty space
    597601      datap++;
    598       if (ix<w)
     602      if (ix<m_size.x)
    599603      {
    600604    slam_length=*datap;     // find the length of this run
     
    687691    screen_line=screen->scan_line(y);
    688692
    689     for (ix=0; ix<w; )
     693    for (ix=0; ix<m_size.x; )
    690694    {
    691695      ix+=(*datap);       // skip over empty space
    692696      datap++;
    693       if (ix<w)
     697      if (ix<m_size.x)
    694698      {
    695699    slam_length=*datap;     // find the length of this run
     
    771775    screen_line=screen->scan_line(y);
    772776
    773     for (ix=0; ix<w; )
     777    for (ix=0; ix<m_size.x; )
    774778    {
    775779      ix+=(*datap);       // skip over empty space
    776780      datap++;
    777       if (ix<w)
     781      if (ix<m_size.x)
    778782      {
    779783    slam_length=*datap;     // find the length of this run
     
    844848
    845849
    846     for (ix=0; ix<w; )
     850    for (ix=0; ix<m_size.x; )
    847851    {
    848852      ix+=(*datap);       // skip over empty space
    849853      datap++;
    850       if (ix<w)
     854      if (ix<m_size.x)
    851855      {
    852856    slam_length=*datap;     // find the length of this run
     
    935939
    936940  // see if the last scanline is clipped off
    937   if (y + ysteps == y2 - 1) ysteps -= 2;
    938   else if (y + ysteps == y2 - 2) ysteps--;
    939 /*  {
    940     for (int x=0; x<w; )
    941     {
    942       int skip=*datap; datap++;
    943       x+=skip;
    944       if (x<w)
    945       {
    946     int run_size=*datap;
    947     datap+=run_size+1;
    948     x+=run_size;
    949       }
    950     }
    951     if (y==y2 - 1)
    952       return;
    953     else
    954       y++;
    955   }*/
     941  ysteps = Min(ysteps, y2 - 1 - y - 2);
    956942
    957943  screen->Lock();
     
    962948  {
    963949    int ix,slam_length;
    964     for (ix=0; ix<w; )
     950    for (ix=0; ix<m_size.x; )
    965951    {
    966952      ix+=(*datap);       // skip over empty space
    967953      datap++;
    968       if (ix<w)
     954      if (ix<m_size.x)
    969955      {
    970956    slam_length=*datap;     // find the length of this run
     
    1011997}
    1012998
    1013 int trans_image::size()
    1014 {
    1015   uint8_t *d=data;
    1016   int t=0;
    1017   for (int y=0; y<h; y++)
    1018   {
    1019     int x=0;
    1020     while (x<w)
    1021     {
    1022       x+=*d; d++; t++;
    1023       if (x<w)
    1024       {
    1025     int s=*d; d++; t+=s+1;
    1026     d+=s;
    1027     x+=s;
    1028       }
    1029     }
    1030   }
    1031   return t+4+4;
    1032 }
     999size_t trans_image::MemUsage()
     1000{
     1001    uint8_t *d = m_data;
     1002    size_t t = 0;
     1003
     1004    for (int y = 0; y < m_size.y; y++)
     1005    {
     1006        for (int x = 0; x < m_size.x; x++)
     1007        {
     1008            x += *d; d++; t++;
     1009
     1010            if (x >= m_size.x)
     1011                break;
     1012
     1013            int s = *d; d++; t += s + 1; d += s; x += s;
     1014        }
     1015    }
     1016    return t + 4 + 4;
     1017}
     1018
Note: See TracChangeset for help on using the changeset viewer.