WebSVN – Kolibri OS – Diff – /programs/develop/libraries/pixlib/draw.inc


#include 
 
 
static void HLine(char *addr,int width, color_t color)
{
     __m64 dst_color;
 
     dst_color = _mm_cvtsi32_si64(color);
     dst_color = _mm_unpacklo_pi32(dst_color, dst_color);
 
     while (width >= 8)
     {
        __asm__ __volatile__ (
        "movq %[clr],   (%0)\n\t"
        "movq %[clr],  8(%0)\n\t"
        "movq %[clr], 16(%0)\n\t"
        "movq %[clr], 24(%0)\n\t"
        :: "r" (addr), [clr] "y" (dst_color));
        addr += 32;
        width -= 8;
     }
     if (width >= 4)
     {
        __asm__ __volatile__ (
        "movq %[clr],   (%0)\n\t"
        "movq %[clr],  8(%0)\n\t"
        :: "r" (addr), [clr] "y" (dst_color));
        addr += 16;
        width -= 4;
     }
     if (width >= 2)
     {
        __asm__ __volatile__ (
        "movq %[clr],  (%0)\n\t"
        :: "r" (addr), [clr] "y" (dst_color));
        addr += 8;
        width -= 2;
     }
     if ( width )
        __asm__ __volatile__ (
        "movd %[clr],  (%0)\n\t"
        :: "r" (addr), [clr] "y" (dst_color));
 
     _mm_empty();
}
 
static void pxDraw(char *dst_addr, int pitch, int w, int h, color_t dst_color)
{
     __m64 color;
 
     color = _mm_cvtsi32_si64(dst_color);
     color = _mm_unpacklo_pi32(color, color);
 
     while(h--)
     {
        char *tmp_dst =dst_addr;
        int width = w;
        dst_addr += pitch;
 
        while(width >= 8)
        {
           __asm__ __volatile__
           ("movq %[clr],   (%0)\n\t"
            "movq %[clr],  8(%0)\n\t"
            "movq %[clr], 16(%0)\n\t"
            "movq %[clr], 24(%0)\n\t"
            :: "r" (tmp_dst), [clr] "y" (color));
           tmp_dst += 32;
           width -= 8;
        };
        if(width >= 4)
        {
           __asm__ __volatile__
           ("movq %[clr],  (%0)\n\t"
            "movq %[clr], 8(%0)\n\t"
            :: "r" (tmp_dst), [clr] "y" (color));
           tmp_dst += 16;
           width -= 4;
        };
 
        if (width >= 2)
        {
           __asm__ __volatile__
           ("movq %[clr],  (%0)\n\t"
            :: "r" (tmp_dst), [clr] "y" (color));
           tmp_dst += 8;
           width -= 2;
        };
        if(width)
           __asm__ __volatile__
           ("movd %[clr], (%0)\n\t"
            :: "r" (tmp_dst), [clr] "y" (color));
     };
     _mm_empty();
};
 
int ClearPixmap(pixmap_t *pixmap, color_t color)
{
     if( (srv_hw2d != 0) &&
         ( ((int)pixmap == -1) ||
           ( (pixmap->flags & PX_MEM_MASK)==PX_MEM_LOCAL) ) )
     {
       ioctl_t io;
 
       if((int)pixmap != -1)
          pixmap = (pixmap_t*)pixmap->handle;
 
       io.handle   = srv_hw2d;
       io.io_code  = PX_CLEAR;
       io.input    = &pixmap;
       io.inp_size = 2;
       io.output   = NULL;
       io.out_size = 0;
 
       return call_service(&io);
     }
 
     pixmap = (pixmap == (void*)-1) ? &scrn_pixmap : pixmap ;
 
     pxDraw(pixmap->mapped, pixmap->pitch,
            pixmap->width, pixmap->height, color);
     return ERR_OK;
};
 
int Line(pixmap_t *pixmap, int x0, int y0, int x1, int y1, color_t color)
{
 
     clip_t clip;
 
     if( (srv_hw2d != 0) &&
         ( (pixmap == (void*)-1) ||
           ( (pixmap->flags & PX_MEM_MASK)==PX_MEM_LOCAL) ) )
     {
       ioctl_t io;
 
       if((int)pixmap != -1)
          pixmap = (pixmap_t*)pixmap->handle;
 
       io.handle   = srv_hw2d;
       io.io_code  = PX_LINE;
       io.input    = &pixmap;
       io.inp_size = 6;
       io.output   = NULL;
       io.out_size = 0;
 
       return call_service(&io);
     }
 
     pixmap = (pixmap == (void*)-1) ? &scrn_pixmap : pixmap ;
 
     clip.xmin = 0;
     clip.ymin = 0;
     clip.xmax = pixmap->width-1;
     clip.ymax = pixmap->height-1;
 
     if ( !LineClip( &clip, &x0, &y0, &x1, &y1 ))
     {
        int dx, dy;
        int sx, sy;
        int e, e1, e2, e3;
 
        char *addr;
 
        dx = x1 - x0;
        dy = y1 - y0;
 
        if( dx || dy)
        {
           if( dy == 0 )
           {
              if (dx < 0)
              {
                 dx = -dx;
                 x0 =  x1;
              };
 
              addr = &((char*)(pixmap->mapped))[pixmap->pitch*y0 + x0*4];
              HLine(addr, dx, color);
 
              return ERR_OK;
           };
           if( dx == 0 )
           {
              if (dy < 0)
              {
                 dy = -dy;
                 y0 =  y1;
              };
              addr = &((char*)(pixmap->mapped))[pixmap->pitch*y0 + x0*4];
 
              while ( dy-- )
              {
                 *(color_t*)addr = color;
                 addr += pixmap->pitch;
              }
              return ERR_OK;
           }
 
           sx = 4;
           if ( dx < 0 )
           {
              dx = -dx;
              sx = -sx;
           }
           sy = pixmap->pitch;
           if ( dy < 0 )
           {
              dy = -dy;
              sy = -sy;
           };
 
           addr = &((char*)(pixmap->mapped))[pixmap->pitch*y0 + x0*4];
 
           if (dx > dy)
           {
              e1 = dy << 1;
              e2 = e1 - (dx << 1);
              e  = e1 - dx;
 
              e3 = e2 - e1;
              e  = e - e1;
 
 
              while (dx--)
              {
                 *(color_t*)addr = color;
                 addr += sx;
                 e += e1;
                 if (e >= 0)
                 {
                    addr += sy;
                    e += e3;
                 }
              }
           }
           else
           {
              e1 = dx << 1;
              e2 = e1 - (dy << 1);
              e  = e1 - dy;
              e3 = e2 - e1;
              e  = e - e1;
 
              while (dy--)
              {
                 *(color_t*)addr = color;
                 addr += sy;
                 e += e1;
                 if (e >= 0)
                 {
                    addr += sx;
                    e += e3;
                 }
              }
           }
        }    /*  ( dx || dy ) */
     }
     return ERR_OK;
}
 
int DrawRect(pixmap_t *pixmap, int xorg, int yorg,
               int width, int height,
               color_t dst_color, color_t border)
{
 
     if( ( width <= 0 ) || ( height<=0 ) )
        return ERR_PARAM;
 
/*   if "hardware acceleration present" and
     "destinastion is primary screen or local videomemory"
*/
 
     if( (srv_hw2d != 0) &&
         ( (pixmap == (void*)-1) ||
           ( (pixmap->flags & PX_MEM_MASK)==PX_MEM_LOCAL) ) )
     {
       ioctl_t io;
 
       if((int)pixmap != -1)
          pixmap = (pixmap_t*)pixmap->handle;
 
       io.handle   = srv_hw2d;
       io.io_code  = PX_DRAW_RECT;
       io.input    = &pixmap;
       io.inp_size = 7;
       io.output   = NULL;
       io.out_size = 0;
 
       return call_service(&io);
     }
     else
/*     no acceleration or destination in system memory  */
     {
        clip_t clip;
        int x0, y0, x1, y1, xend, yend;
 
        pixmap = (pixmap == (void*)-1) ? &scrn_pixmap : pixmap ;
 
        x0 = xorg;
        y0 = yorg;
 
        xend = x1 = x0 + width - 1;
        yend = y1 = y0 + height - 1;
 
        clip.xmin = 0;
        clip.ymin = 0;
        clip.xmax = pixmap->width-1;
        clip.ymax = pixmap->height-1;
 
        if( ! BlockClip( &clip, &x0, &y0, &x1, &y1))
        {
           int w, h;
 
           char *dst_addr;
 
           w = x1 - x0 + 1;
           h = y1 - y0 + 1;
 
           if( (dst_color == border) ||
               ((border & 0xFF000000)==0))
           {
              dst_addr  = &((char*)(pixmap->mapped))[pixmap->pitch*y0 + x0*4];
              pxDraw(dst_addr, pixmap->pitch, w, h, dst_color);
           }
           else
           {
              if( y0 == yorg)
              {
                 dst_addr  = &((char*)(pixmap->mapped))[pixmap->pitch*y0 + x0*4];
                 HLine(dst_addr, w, border);
                 y0++;
                 h--;
              }
              if( y1 == yend )
              {
                 dst_addr  = &((char*)(pixmap->mapped))[pixmap->pitch*y1 + x0*4];
                 HLine(dst_addr, w, border);
                 h--;
              }
              if( (h > 0) && (x0 == xorg))
              {
                 int dy = h;
 
                 dst_addr  = &((char*)(pixmap->mapped))[pixmap->pitch*y0 + x0*4];
 
                 while ( dy-- )
                 {
                    *(color_t*)dst_addr = border;
                    dst_addr += pixmap->pitch;
                 }
                 x0++;
                 w--;
              }
              if( (h > 0) && (x1 == xend))
              {
                 int dy = h;
 
                 dst_addr  = &((char*)(pixmap->mapped))[pixmap->pitch*y0 + x1*4];
 
                 while ( dy-- )
                 {
                    *(color_t*)dst_addr = border;
                    dst_addr += pixmap->pitch;
                 }
                 w--;
              }
              if( (w > 0) && (h > 0) )
              {
                 dst_addr  = &((char*)(pixmap->mapped))[pixmap->pitch*y0 + x0*4];
                 pxDraw(dst_addr, pixmap->pitch, w, h, dst_color);
              }
           }
        };
     };
     return ERR_OK;
};
 
int FillRect(pixmap_t *pixmap, int xorg, int yorg,
               int width, int height,
               brush_t *dst_brush, color_t border)
{
     if( ( width <= 0 ) || ( height<=0 ) )
        return ERR_PARAM;
 
/*   if "hardware acceleration present" and
     "destinastion is primary screen or local videomemory"
*/
 
     if( (srv_hw2d != 0) &&
         ( (pixmap == (void*)-1) ||
           ( (pixmap->flags & PX_MEM_MASK)==PX_MEM_LOCAL) ) )
     {
        fill_t fill;
        ioctl_t io;
 
        fill.dstpix = ((int)pixmap == -1) ? (pixmap_t*)-1 : (pixmap_t*)pixmap->handle;
        fill.x = xorg;
        fill.y = yorg;
        fill.w = width;
        fill.h = height;
        fill.bkcolor = dst_brush->bkcolor;
        fill.fcolor  = dst_brush->fcolor;
        fill.bmp0 = dst_brush->bmp[0];
        fill.bmp1 = dst_brush->bmp[1];
        fill.border = border;
 
        io.handle   = srv_hw2d;
        io.io_code  = PX_FILL_RECT;
        io.input    = &fill;
        io.inp_size = 10;
        io.output   = NULL;
        io.out_size = 0;
 
        return call_service(&io);
     }
     else
/*      no acceleration or destination in system memory  */
     {
        clip_t clip;
        int x0, y0, x1, y1, xend, yend;
 
        pixmap = (pixmap == (void*)-1) ? &scrn_pixmap : pixmap ;
 
        x0 = xorg;
        y0 = yorg;
        x1 = xend = x0 + width - 1;
        y1 = yend = y0 + height - 1;
 
        clip.xmin = 0;
        clip.ymin = 0;
        clip.xmax = pixmap->width-1;
        clip.ymax = pixmap->height-1;
 
        if( ! BlockClip( &clip, &x0, &y0, &x1, &y1))
        {
           int w, h, bh, bm_y;
 
           __m64 clr_bb, clr_bf, clr_fb, clr_ff;
           char *dst_addr;
 
           clr_bb = _mm_cvtsi32_si64(dst_brush->bkcolor);
           clr_ff = _mm_cvtsi32_si64(dst_brush->fcolor);
 
           clr_bb = _mm_unpacklo_pi32(clr_bb, clr_bb);
           clr_ff = _mm_unpacklo_pi32(clr_ff, clr_ff);
 
           clr_bf = _mm_unpacklo_pi32(clr_ff, clr_bb);
           clr_fb = _mm_unpacklo_pi32(clr_bb, clr_ff);
 
           w = x1 -x0 + 1;
           bh = h = y1 -y0 + 1;
 
           dst_addr  = & ((char*)(pixmap->mapped))[pixmap->pitch*y0+x0*4];
 
           bm_y = y0 & 7;
 
           while(h--)
           {
              u8_t mask = dst_brush->bits[bm_y];
 
              char *tmp_dst = dst_addr;
              int width = w;
              dst_addr += pixmap->pitch;
              bm_y = (bm_y+1) & 7;
 
              while(width>=2)
              {
                 __asm__ __volatile__
                 ("rolb $2, %0 \n\t"
                  :"+g" (mask):"g"(mask)
                  :"cc");
 
                 switch( mask & 3 )
                 {
                    case 0:
                       __asm__ __volatile__
                       ("movq %[clr], (%0)\n\t" :: "r" (tmp_dst), [clr] "y" (clr_bb));
                       break;
 
                    case 1:
                       __asm__ __volatile__
                       ("movq %[clr], (%0)\n\t" :: "r" (tmp_dst), [clr] "y" (clr_fb));
                       break;
 
                    case 2:
                       __asm__ __volatile__
                       ("movq %[clr], (%0)\n\t" :: "r" (tmp_dst), [clr] "y" (clr_bf));
                       break;
 
                    case 3:
                       __asm__ __volatile__
                       ("movq %[clr], (%0)\n\t" :: "r" (tmp_dst), [clr] "y" (clr_ff));
                       break;
                 }
                 width   -=2;
                 tmp_dst +=8;
              }
              if( width )
                 if( mask & 1 )
                    __asm__ __volatile__
                    ("movd %[clr], (%0)\n\t" :: "r" (tmp_dst), [clr] "y" (clr_ff));
                 else
                    __asm__ __volatile__
                    ("movd %[clr], (%0)\n\t" :: "r" (tmp_dst), [clr] "y" (clr_bb));
           };
 
           if( (border & 0xFF000000) != 0)
           {
              if( y0 == yorg)
              {
                 dst_addr  = &((char*)(pixmap->mapped))[pixmap->pitch*y0 + x0*4];
                 HLine(dst_addr, w, border);
                 y0++;
                 bh--;
              }
              if( y1 == yend )
              {
                 dst_addr  = &((char*)(pixmap->mapped))[pixmap->pitch*y1 + x0*4];
                 HLine(dst_addr, w, border);
                 bh--;
              }
              if( (bh > 0) && (x0 == xorg))
              {
                 int dy = bh;
 
                 dst_addr  = &((char*)(pixmap->mapped))[pixmap->pitch*y0 + x0*4];
 
                 while ( dy-- )
                 {
                    *(color_t*)dst_addr = border;
                    dst_addr += pixmap->pitch;
                 }
              }
              if( (bh > 0) && (x1 == xend))
              {
                 int dy = bh;
 
                 dst_addr  = &((char*)(pixmap->mapped))[pixmap->pitch*y0 + x1*4];
 
                 while ( dy-- )
                 {
                    *(color_t*)dst_addr = border;
                    dst_addr += pixmap->pitch;
                 }
              }
           };
 
           _mm_empty();
        };
     };
     return ERR_OK;
};
 
 
int Blit(pixmap_t *dst_pixmap, int dst_x, int dst_y,
         pixmap_t *src_pixmap, int src_x, int src_y,
         int width, int height)
{
 
    clip_t src_clip, dst_clip;
 
    if( ( width <= 0 ) || ( height<=0 ) )
        return ERR_PARAM;
 
/*  if "hardware acceleration present" and
    "destinastion is primary screen or local videomemory"
*/
 
    if( (srv_hw2d != 0) &&
        ( (dst_pixmap == (void*)-1) ||
           ( (dst_pixmap->flags & PX_MEM_MASK)==PX_MEM_LOCAL) ) /* &&
         ( (src_pixmap == (void*)-1) ||
           ( (src_pixmap->flags & PX_MEM_MASK)==PX_MEM_LOCAL) ) */ )
    {
        ioctl_t io;
        pxblit_t *blit = (pxblit_t*)&dst_pixmap;
 
        if((int)dst_pixmap != -1)
            blit->dst_pixmap = (pixmap_t*)dst_pixmap->handle;
 
        if( (int)src_pixmap != -1 &&
            (src_pixmap->flags & PX_MEM_MASK) != PX_MEM_SYSTEM)
            blit->src_pixmap = (pixmap_t*)src_pixmap->handle;
 
        io.handle   = srv_hw2d;
        io.io_code  = PX_BLIT;
        io.input    = blit;
        io.inp_size = 8;
        io.output   = NULL;
        io.out_size = 0;
 
        return call_service(&io);
    }
 
    dst_pixmap = (dst_pixmap == (void*)-1) ? &scrn_pixmap : dst_pixmap ;
    src_pixmap = (src_pixmap == (void*)-1) ? &scrn_pixmap : src_pixmap ;
 
    src_clip.xmin = 0;
    src_clip.ymin = 0;
    src_clip.xmax = src_pixmap->width-1;
    src_clip.ymax = src_pixmap->height-1;
 
    dst_clip.xmin = 0;
    dst_clip.ymin = 0;
    dst_clip.xmax = dst_pixmap->width-1;
    dst_clip.ymax = dst_pixmap->height-1;
 
    if( !blit_clip(&dst_clip, &dst_x, &dst_y,
                   &src_clip, &src_x, &src_y,
                   &width, &height) )
    {
        color_t *src_addr = &((color_t*)(src_pixmap->mapped))[src_pixmap->pitch*src_y/4+src_x];
        color_t *dst_addr = &((color_t*)(dst_pixmap->mapped))[dst_pixmap->pitch*dst_y/4+dst_x];
 
        while( height-- )
        {
            int w = width;
            color_t *tmp_src = src_addr;
            color_t *tmp_dst = dst_addr;
 
            src_addr += src_pixmap->pitch/4;
            dst_addr += dst_pixmap->pitch/4;
 
            while( w >= 8)
            {
                __asm__ __volatile__ (
                "movq     (%0),   %%mm0\n"
                "movq    8(%0),   %%mm1\n"
                "movq   16(%0),   %%mm2\n"
                "movq   24(%0),   %%mm3\n"
                "movq   %%mm0,    (%1)\n"
                "movq   %%mm1,   8(%1)\n"
                "movq   %%mm2,  16(%1)\n"
                "movq   %%mm3,  24(%1)\n"
                :: "r" (tmp_src), "r" (tmp_dst)
                : "memory", "%mm0", "%mm1", "%mm2", "%mm3");
                w -= 8;
                tmp_src += 8;
                tmp_dst += 8;
            };
            if( w >= 4 )
            {
                __asm__ __volatile__ (
                "movq     (%0),   %%mm0\n"
                "movq    8(%0),   %%mm1\n"
                "movq   %%mm0,    (%1)\n"
                "movq   %%mm1,   8(%1)\n"
                :: "r" (tmp_src), "r" (tmp_dst)
                : "memory", "%mm0", "%mm1");
                w -= 4;
                tmp_src += 4;
                tmp_dst += 4;
            };
            if( w >= 2 )
            {
                __asm__ __volatile__ (
                "movq     (%0),   %%mm0\n"
                "movq   %%mm0,    (%1)\n"
                :: "r" (tmp_src), "r" (tmp_dst)
                : "memory", "%mm0");
                w -= 2;
                tmp_src += 2;
                tmp_dst += 2;
            };
            if( w )
                *tmp_dst = *tmp_src;
        };
    };
    return ERR_OK;
};
 
int TransparentBlit(pixmap_t *dst_pixmap, int dst_x, int dst_y,
         pixmap_t *src_pixmap, int src_x, int src_y,
         int width, int height, color_t key)
{
     clip_t src_clip, dst_clip;
 
/*   if "hardware acceleration present" and
     "destinastion is primary screen or local videomemory"  and
     "source is primary screen or local videomemory"
*/
 
     if( (srv_hw2d != 0) &&
         ( (dst_pixmap == (void*)-1) ||
           ( (dst_pixmap->flags & PX_MEM_MASK)==PX_MEM_LOCAL) )  &&
         ( (src_pixmap == (void*)-1) ||
           ( (src_pixmap->flags & PX_MEM_MASK)==PX_MEM_LOCAL) ) )
     {
        ioctl_t io;
        pxblit_t *blit = (pxblit_t*)&dst_pixmap;
 
        if((int)dst_pixmap != -1)
           blit->dst_pixmap = (pixmap_t*)dst_pixmap->handle;
 
        if((int)src_pixmap != -1)
           blit->src_pixmap = (pixmap_t*)src_pixmap->handle;
 
        io.handle   = srv_hw2d;
        io.io_code  = PX_BLIT_TRANSPARENT;
        io.input    = blit;
        io.inp_size = 9;
        io.output   = NULL;
        io.out_size = 0;
 
        return call_service(&io);
     };
 
     dst_pixmap = (dst_pixmap == (void*)-1) ? &scrn_pixmap : dst_pixmap ;
     src_pixmap = (src_pixmap == (void*)-1) ? &scrn_pixmap : src_pixmap ;
 
     src_clip.xmin = 0;
     src_clip.ymin = 0;
     src_clip.xmax = src_pixmap->width-1;
     src_clip.ymax = src_pixmap->height-1;
 
     dst_clip.xmin = 0;
     dst_clip.ymin = 0;
     dst_clip.xmax = dst_pixmap->width-1;
     dst_clip.ymax = dst_pixmap->height-1;
 
 
     if( !blit_clip(&dst_clip, &dst_x, &dst_y,
                    &src_clip, &src_x, &src_y,
                    &width, &height) )
     {
        __m64 clr_key;
 
 
 
 
        color_t *src_addr = &((color_t*)(src_pixmap->mapped))[src_pixmap->pitch*src_y/4+src_x];
        color_t *dst_addr = &((color_t*)(dst_pixmap->mapped))[dst_pixmap->pitch*dst_y/4+dst_x];
 
        clr_key = _mm_cvtsi32_si64(key);
        clr_key = _mm_unpacklo_pi32(clr_key, clr_key);
 
        while( height-- )
        {
           int w = width;
           color_t *tmp_src = src_addr;
           color_t *tmp_dst = dst_addr;
 
           src_addr += src_pixmap->pitch/4;
           dst_addr += dst_pixmap->pitch/4;
 
           while( w >= 2)
           {
              __asm__ __volatile__ (
              "movq    %[clr_key], %%mm0      \n\t"
              "pcmpeqd %[src_clr], %%mm0      \n\t"
              "pand    %%mm0,      %[dst_clr] \n\t"
              "pandn   %[src_clr], %%mm0      \n\t"
              "por     %%mm0,      %[dst_clr] \n\t"
              "movq    %[dst_clr], (%0)"
              :: "r" (tmp_dst),
              [src_clr] "y" (*(__m64*)tmp_src),
              [dst_clr] "y" (*(__m64*)tmp_dst),
              [clr_key] "y" (clr_key)
              :"memory","mm0");
 
              w -= 2;
              tmp_src += 2;
              tmp_dst += 2;
           };
           if( w && (*tmp_src != key) )
              *tmp_dst = *tmp_src;
        };
     };
     return ERR_OK;
}
 
unsigned long long m_0080 = 0x0080008000800080ULL;
 
int BlitAlpha(pixmap_t *dst_pixmap, int dst_x, int dst_y,
              pixmap_t *src_pixmap, int src_x, int src_y,
              int width, int height, u32_t alpha)
{
     clip_t src_clip, dst_clip;
 
     if( (srv_hw2d != 0) &&
         ( (dst_pixmap == (void*)-1) ||
           ( (dst_pixmap->flags & PX_MEM_MASK)==PX_MEM_LOCAL) )  &&
         ( (src_pixmap == (void*)-1) ||
           ( (src_pixmap->flags & PX_MEM_MASK)==PX_MEM_LOCAL) ) )
     {
        ioctl_t io;
        pxblit_t *blit = (pxblit_t*)&dst_pixmap;
 
        if((int)dst_pixmap != -1)
           blit->dst_pixmap = (pixmap_t*)dst_pixmap->handle;
 
        if((int)src_pixmap != -1)
           blit->src_pixmap = (pixmap_t*)src_pixmap->handle;
 
        io.handle   = srv_hw2d;
        io.io_code  = PX_BLIT_ALPHA;
        io.input    = blit;
        io.inp_size = 9;
        io.output   = NULL;
        io.out_size = 0;
 
        return call_service(&io);
     };
 
     dst_pixmap = (dst_pixmap == (void*)-1) ? &scrn_pixmap : dst_pixmap ;
     src_pixmap = (src_pixmap == (void*)-1) ? &scrn_pixmap : src_pixmap ;
 
     src_clip.xmin = 0;
     src_clip.ymin = 0;
     src_clip.xmax = src_pixmap->width-1;
     src_clip.ymax = src_pixmap->height-1;
 
     dst_clip.xmin = 0;
     dst_clip.ymin = 0;
     dst_clip.xmax = dst_pixmap->width-1;
     dst_clip.ymax = dst_pixmap->height-1;
 
 
     if( !blit_clip(&dst_clip, &dst_x, &dst_y,
                    &src_clip, &src_x, &src_y,
                    &width, &height) )
     {
        __m64 m_alpha;
        __m64 m_one_alpha;
 
        color_t *src_addr = &((color_t*)(src_pixmap->mapped))[src_pixmap->pitch*src_y/4+src_x];
        color_t *dst_addr = &((color_t*)(dst_pixmap->mapped))[dst_pixmap->pitch*dst_y/4+dst_x];
 
        m_alpha = _mm_cvtsi32_si64((alpha << 16) | alpha);
        m_alpha = _mm_unpacklo_pi32(m_alpha, m_alpha);
        m_one_alpha = _mm_subs_pu16((__m64)0x00FF00FF00FF00FFULL, m_alpha);
 
        while( height-- )
        {
           int w = width;
           color_t *tmp_src = src_addr;
           color_t *tmp_dst = dst_addr;
 
           src_addr += src_pixmap->pitch/4;
           dst_addr += dst_pixmap->pitch/4;
 
           while( w-- )
           {
              __asm__ __volatile__ (
              "movd (%0), %%mm0               \n\t"
              "pxor    %%mm1, %%mm1           \n\t"
              "punpcklbw  %%mm1, %%mm0        \n\t"
              "pmullw  %[clr_key], %%mm0       \n\t"
       //       "paddw   %[m_0080], %%mm0       \n\t"
 
              "movd (%1), %%mm2               \n\t"
              "punpcklbw  %%mm1, %%mm2        \n\t"
              "pmullw  %[m_one_alpha], %%mm2  \n\t"
       //       "paddw   %[m_0080], %%mm2       \n\t"
 
              "paddw   %%mm2, %%mm0           \n\t"
              "psrlw   $8, %%mm0              \n\t"
              "packuswb %%mm0, %%mm0          \n\t"
              "movd    %%mm0, (%1)"
              :: "r" (tmp_src),
                 "r" (tmp_dst),
              [clr_key] "y" (m_alpha),
              [m_one_alpha] "y" (m_one_alpha)
              :"memory","mm0", "mm1", "mm2");
 
              tmp_src++;
              tmp_dst++;
           };
//           if( w && (*tmp_src != alpha) )
//              *tmp_dst = *tmp_src;
        };
     };
     return ERR_OK;
}

Rev 882	Rev 1002
1	#include	1	#include
2		2
3		3
4	static void HLine(char *addr,int width, color_t color)	4	static void HLine(char *addr,int width, color_t color)
5	{	5	{
6	__m64 dst_color;	6	__m64 dst_color;
7		7
8	dst_color = _mm_cvtsi32_si64(color);	8	dst_color = _mm_cvtsi32_si64(color);
9	dst_color = _mm_unpacklo_pi32(dst_color, dst_color);	9	dst_color = _mm_unpacklo_pi32(dst_color, dst_color);
10		10
11	while (width >= 8)	11	while (width >= 8)
12	{	12	{
13	__asm__ __volatile__ (	13	__asm__ __volatile__ (
14	"movq %[clr], (%0)\n\t"	14	"movq %[clr], (%0)\n\t"
15	"movq %[clr], 8(%0)\n\t"	15	"movq %[clr], 8(%0)\n\t"
16	"movq %[clr], 16(%0)\n\t"	16	"movq %[clr], 16(%0)\n\t"
17	"movq %[clr], 24(%0)\n\t"	17	"movq %[clr], 24(%0)\n\t"
18	:: "r" (addr), [clr] "y" (dst_color));	18	:: "r" (addr), [clr] "y" (dst_color));
19	addr += 32;	19	addr += 32;
20	width -= 8;	20	width -= 8;
21	}	21	}
22	if (width >= 4)	22	if (width >= 4)
23	{	23	{
24	__asm__ __volatile__ (	24	__asm__ __volatile__ (
25	"movq %[clr], (%0)\n\t"	25	"movq %[clr], (%0)\n\t"
26	"movq %[clr], 8(%0)\n\t"	26	"movq %[clr], 8(%0)\n\t"
27	:: "r" (addr), [clr] "y" (dst_color));	27	:: "r" (addr), [clr] "y" (dst_color));
28	addr += 16;	28	addr += 16;
29	width -= 4;	29	width -= 4;
30	}	30	}
31	if (width >= 2)	31	if (width >= 2)
32	{	32	{
33	__asm__ __volatile__ (	33	__asm__ __volatile__ (
34	"movq %[clr], (%0)\n\t"	34	"movq %[clr], (%0)\n\t"
35	:: "r" (addr), [clr] "y" (dst_color));	35	:: "r" (addr), [clr] "y" (dst_color));
36	addr += 8;	36	addr += 8;
37	width -= 2;	37	width -= 2;
38	}	38	}
39	if ( width )	39	if ( width )
40	__asm__ __volatile__ (	40	__asm__ __volatile__ (
41	"movd %[clr], (%0)\n\t"	41	"movd %[clr], (%0)\n\t"
42	:: "r" (addr), [clr] "y" (dst_color));	42	:: "r" (addr), [clr] "y" (dst_color));
43		43
44	_mm_empty();	44	_mm_empty();
45	}	45	}
46		46
47	static void pxDraw(char *dst_addr, int pitch, int w, int h, color_t dst_color)	47	static void pxDraw(char *dst_addr, int pitch, int w, int h, color_t dst_color)
48	{	48	{
49	__m64 color;	49	__m64 color;
50		50
51	color = _mm_cvtsi32_si64(dst_color);	51	color = _mm_cvtsi32_si64(dst_color);
52	color = _mm_unpacklo_pi32(color, color);	52	color = _mm_unpacklo_pi32(color, color);
53		53
54	while(h--)	54	while(h--)
55	{	55	{
56	char *tmp_dst =dst_addr;	56	char *tmp_dst =dst_addr;
57	int width = w;	57	int width = w;
58	dst_addr += pitch;	58	dst_addr += pitch;
59		59
60	while(width >= 8)	60	while(width >= 8)
61	{	61	{
62	__asm__ __volatile__	62	__asm__ __volatile__
63	("movq %[clr], (%0)\n\t"	63	("movq %[clr], (%0)\n\t"
64	"movq %[clr], 8(%0)\n\t"	64	"movq %[clr], 8(%0)\n\t"
65	"movq %[clr], 16(%0)\n\t"	65	"movq %[clr], 16(%0)\n\t"
66	"movq %[clr], 24(%0)\n\t"	66	"movq %[clr], 24(%0)\n\t"
67	:: "r" (tmp_dst), [clr] "y" (color));	67	:: "r" (tmp_dst), [clr] "y" (color));
68	tmp_dst += 32;	68	tmp_dst += 32;
69	width -= 8;	69	width -= 8;
70	};	70	};
71	if(width >= 4)	71	if(width >= 4)
72	{	72	{
73	__asm__ __volatile__	73	__asm__ __volatile__
74	("movq %[clr], (%0)\n\t"	74	("movq %[clr], (%0)\n\t"
75	"movq %[clr], 8(%0)\n\t"	75	"movq %[clr], 8(%0)\n\t"
76	:: "r" (tmp_dst), [clr] "y" (color));	76	:: "r" (tmp_dst), [clr] "y" (color));
77	tmp_dst += 16;	77	tmp_dst += 16;
78	width -= 4;	78	width -= 4;
79	};	79	};
80		80
81	if (width >= 2)	81	if (width >= 2)
82	{	82	{
83	__asm__ __volatile__	83	__asm__ __volatile__
84	("movq %[clr], (%0)\n\t"	84	("movq %[clr], (%0)\n\t"
85	:: "r" (tmp_dst), [clr] "y" (color));	85	:: "r" (tmp_dst), [clr] "y" (color));
86	tmp_dst += 8;	86	tmp_dst += 8;
87	width -= 2;	87	width -= 2;
88	};	88	};
89	if(width)	89	if(width)
90	__asm__ __volatile__	90	__asm__ __volatile__
91	("movd %[clr], (%0)\n\t"	91	("movd %[clr], (%0)\n\t"
92	:: "r" (tmp_dst), [clr] "y" (color));	92	:: "r" (tmp_dst), [clr] "y" (color));
93	};	93	};
94	_mm_empty();	94	_mm_empty();
95	};	95	};
96		96
97	int ClearPixmap(pixmap_t *pixmap, color_t color)	97	int ClearPixmap(pixmap_t *pixmap, color_t color)
98	{	98	{
99	if( (srv_hw2d != 0) &&	99	if( (srv_hw2d != 0) &&
100	( ((int)pixmap == -1) \|\|	100	( ((int)pixmap == -1) \|\|
101	( (pixmap->flags & PX_MEM_MASK)==PX_MEM_LOCAL) ) )	101	( (pixmap->flags & PX_MEM_MASK)==PX_MEM_LOCAL) ) )
102	{	102	{
103	ioctl_t io;	103	ioctl_t io;
104		104
105	if((int)pixmap != -1)	105	if((int)pixmap != -1)
106	pixmap = (pixmap_t*)pixmap->handle;	106	pixmap = (pixmap_t*)pixmap->handle;
107		107
108	io.handle = srv_hw2d;	108	io.handle = srv_hw2d;
109	io.io_code = PX_CLEAR;	109	io.io_code = PX_CLEAR;
110	io.input = &pixmap;	110	io.input = &pixmap;
111	io.inp_size = 2;	111	io.inp_size = 2;
112	io.output = NULL;	112	io.output = NULL;
113	io.out_size = 0;	113	io.out_size = 0;
114		114
115	return call_service(&io);	115	return call_service(&io);
116	}	116	}
117		117
118	pixmap = (pixmap == (void*)-1) ? &scrn_pixmap : pixmap ;	118	pixmap = (pixmap == (void*)-1) ? &scrn_pixmap : pixmap ;
119		119
120	pxDraw(pixmap->mapped, pixmap->pitch,	120	pxDraw(pixmap->mapped, pixmap->pitch,
121	pixmap->width, pixmap->height, color);	121	pixmap->width, pixmap->height, color);
122	return ERR_OK;	122	return ERR_OK;
123	};	123	};
124		124
125	int Line(pixmap_t *pixmap, int x0, int y0, int x1, int y1, color_t color)	125	int Line(pixmap_t *pixmap, int x0, int y0, int x1, int y1, color_t color)
126	{	126	{
127		127
128	clip_t clip;	128	clip_t clip;
129		129
130	if( (srv_hw2d != 0) &&	130	if( (srv_hw2d != 0) &&
131	( (pixmap == (void*)-1) \|\|	131	( (pixmap == (void*)-1) \|\|
132	( (pixmap->flags & PX_MEM_MASK)==PX_MEM_LOCAL) ) )	132	( (pixmap->flags & PX_MEM_MASK)==PX_MEM_LOCAL) ) )
133	{	133	{
134	ioctl_t io;	134	ioctl_t io;
135		135
136	if((int)pixmap != -1)	136	if((int)pixmap != -1)
137	pixmap = (pixmap_t*)pixmap->handle;	137	pixmap = (pixmap_t*)pixmap->handle;
138		138
139	io.handle = srv_hw2d;	139	io.handle = srv_hw2d;
140	io.io_code = PX_LINE;	140	io.io_code = PX_LINE;
141	io.input = &pixmap;	141	io.input = &pixmap;
142	io.inp_size = 6;	142	io.inp_size = 6;
143	io.output = NULL;	143	io.output = NULL;
144	io.out_size = 0;	144	io.out_size = 0;
145		145
146	return call_service(&io);	146	return call_service(&io);
147	}	147	}
148		148
149	pixmap = (pixmap == (void*)-1) ? &scrn_pixmap : pixmap ;	149	pixmap = (pixmap == (void*)-1) ? &scrn_pixmap : pixmap ;
150		150
151	clip.xmin = 0;	151	clip.xmin = 0;
152	clip.ymin = 0;	152	clip.ymin = 0;
153	clip.xmax = pixmap->width-1;	153	clip.xmax = pixmap->width-1;
154	clip.ymax = pixmap->height-1;	154	clip.ymax = pixmap->height-1;
155		155
156	if ( !LineClip( &clip, &x0, &y0, &x1, &y1 ))	156	if ( !LineClip( &clip, &x0, &y0, &x1, &y1 ))
157	{	157	{
158	int dx, dy;	158	int dx, dy;
159	int sx, sy;	159	int sx, sy;
160	int e, e1, e2, e3;	160	int e, e1, e2, e3;
161		161
162	char *addr;	162	char *addr;
163		163
164	dx = x1 - x0;	164	dx = x1 - x0;
165	dy = y1 - y0;	165	dy = y1 - y0;
166		166
167	if( dx \|\| dy)	167	if( dx \|\| dy)
168	{	168	{
169	if( dy == 0 )	169	if( dy == 0 )
170	{	170	{
171	if (dx < 0)	171	if (dx < 0)
172	{	172	{
173	dx = -dx;	173	dx = -dx;
174	x0 = x1;	174	x0 = x1;
175	};	175	};
176		176
177	addr = &((char)(pixmap->mapped))[pixmap->pitchy0 + x0*4];	177	addr = &((char)(pixmap->mapped))[pixmap->pitchy0 + x0*4];
178	HLine(addr, dx, color);	178	HLine(addr, dx, color);
179		179
180	return ERR_OK;	180	return ERR_OK;
181	};	181	};
182	if( dx == 0 )	182	if( dx == 0 )
183	{	183	{
184	if (dy < 0)	184	if (dy < 0)
185	{	185	{
186	dy = -dy;	186	dy = -dy;
187	y0 = y1;	187	y0 = y1;
188	};	188	};
189	addr = &((char)(pixmap->mapped))[pixmap->pitchy0 + x0*4];	189	addr = &((char)(pixmap->mapped))[pixmap->pitchy0 + x0*4];
190		190
191	while ( dy-- )	191	while ( dy-- )
192	{	192	{
193	(color_t)addr = color;	193	(color_t)addr = color;
194	addr += pixmap->pitch;	194	addr += pixmap->pitch;
195	}	195	}
196	return ERR_OK;	196	return ERR_OK;
197	}	197	}
198		198
199	sx = 4;	199	sx = 4;
200	if ( dx < 0 )	200	if ( dx < 0 )
201	{	201	{
202	dx = -dx;	202	dx = -dx;
203	sx = -sx;	203	sx = -sx;
204	}	204	}
205	sy = pixmap->pitch;	205	sy = pixmap->pitch;
206	if ( dy < 0 )	206	if ( dy < 0 )
207	{	207	{
208	dy = -dy;	208	dy = -dy;
209	sy = -sy;	209	sy = -sy;
210	};	210	};
211		211
212	addr = &((char)(pixmap->mapped))[pixmap->pitchy0 + x0*4];	212	addr = &((char)(pixmap->mapped))[pixmap->pitchy0 + x0*4];
213		213
214	if (dx > dy)	214	if (dx > dy)
215	{	215	{
216	e1 = dy << 1;	216	e1 = dy << 1;
217	e2 = e1 - (dx << 1);	217	e2 = e1 - (dx << 1);
218	e = e1 - dx;	218	e = e1 - dx;
219		219
220	e3 = e2 - e1;	220	e3 = e2 - e1;
221	e = e - e1;	221	e = e - e1;
222		222
223		223
224	while (dx--)	224	while (dx--)
225	{	225	{
226	(color_t)addr = color;	226	(color_t)addr = color;
227	addr += sx;	227	addr += sx;
228	e += e1;	228	e += e1;
229	if (e >= 0)	229	if (e >= 0)
230	{	230	{
231	addr += sy;	231	addr += sy;
232	e += e3;	232	e += e3;
233	}	233	}
234	}	234	}
235	}	235	}
236	else	236	else
237	{	237	{
238	e1 = dx << 1;	238	e1 = dx << 1;
239	e2 = e1 - (dy << 1);	239	e2 = e1 - (dy << 1);
240	e = e1 - dy;	240	e = e1 - dy;
241	e3 = e2 - e1;	241	e3 = e2 - e1;
242	e = e - e1;	242	e = e - e1;
243		243
244	while (dy--)	244	while (dy--)
245	{	245	{
246	(color_t)addr = color;	246	(color_t)addr = color;
247	addr += sy;	247	addr += sy;
248	e += e1;	248	e += e1;
249	if (e >= 0)	249	if (e >= 0)
250	{	250	{
251	addr += sx;	251	addr += sx;
252	e += e3;	252	e += e3;
253	}	253	}
254	}	254	}
255	}	255	}
256	} /* ( dx \|\| dy ) */	256	} /* ( dx \|\| dy ) */
257	}	257	}
258	return ERR_OK;	258	return ERR_OK;
259	}	259	}
260		260
261	int DrawRect(pixmap_t *pixmap, int xorg, int yorg,	261	int DrawRect(pixmap_t *pixmap, int xorg, int yorg,
262	int width, int height,	262	int width, int height,
263	color_t dst_color, color_t border)	263	color_t dst_color, color_t border)
264	{	264	{
265		265
266	if( ( width <= 0 ) \|\| ( height<=0 ) )	266	if( ( width <= 0 ) \|\| ( height<=0 ) )
267	return ERR_PARAM;	267	return ERR_PARAM;
268		268
269	/* if "hardware acceleration present" and	269	/* if "hardware acceleration present" and
270	"destinastion is primary screen or local videomemory"	270	"destinastion is primary screen or local videomemory"
271	*/	271	*/
272		272
273	if( (srv_hw2d != 0) &&	273	if( (srv_hw2d != 0) &&
274	( (pixmap == (void*)-1) \|\|	274	( (pixmap == (void*)-1) \|\|
275	( (pixmap->flags & PX_MEM_MASK)==PX_MEM_LOCAL) ) )	275	( (pixmap->flags & PX_MEM_MASK)==PX_MEM_LOCAL) ) )
276	{	276	{
277	ioctl_t io;	277	ioctl_t io;
278		278
279	if((int)pixmap != -1)	279	if((int)pixmap != -1)
280	pixmap = (pixmap_t*)pixmap->handle;	280	pixmap = (pixmap_t*)pixmap->handle;
281		281
282	io.handle = srv_hw2d;	282	io.handle = srv_hw2d;
283	io.io_code = PX_DRAW_RECT;	283	io.io_code = PX_DRAW_RECT;
284	io.input = &pixmap;	284	io.input = &pixmap;
285	io.inp_size = 7;	285	io.inp_size = 7;
286	io.output = NULL;	286	io.output = NULL;
287	io.out_size = 0;	287	io.out_size = 0;
288		288
289	return call_service(&io);	289	return call_service(&io);
290	}	290	}
291	else	291	else
292	/* no acceleration or destination in system memory */	292	/* no acceleration or destination in system memory */
293	{	293	{
294	clip_t clip;	294	clip_t clip;
295	int x0, y0, x1, y1, xend, yend;	295	int x0, y0, x1, y1, xend, yend;
296		296
297	pixmap = (pixmap == (void*)-1) ? &scrn_pixmap : pixmap ;	297	pixmap = (pixmap == (void*)-1) ? &scrn_pixmap : pixmap ;
298		298
299	x0 = xorg;	299	x0 = xorg;
300	y0 = yorg;	300	y0 = yorg;
301		301
302	xend = x1 = x0 + width - 1;	302	xend = x1 = x0 + width - 1;
303	yend = y1 = y0 + height - 1;	303	yend = y1 = y0 + height - 1;
304		304
305	clip.xmin = 0;	305	clip.xmin = 0;
306	clip.ymin = 0;	306	clip.ymin = 0;
307	clip.xmax = pixmap->width-1;	307	clip.xmax = pixmap->width-1;
308	clip.ymax = pixmap->height-1;	308	clip.ymax = pixmap->height-1;
309		309
310	if( ! BlockClip( &clip, &x0, &y0, &x1, &y1))	310	if( ! BlockClip( &clip, &x0, &y0, &x1, &y1))
311	{	311	{
312	int w, h;	312	int w, h;
313		313
314	char *dst_addr;	314	char *dst_addr;
315		315
316	w = x1 - x0 + 1;	316	w = x1 - x0 + 1;
317	h = y1 - y0 + 1;	317	h = y1 - y0 + 1;
318		318
319	if( (dst_color == border) \|\|	319	if( (dst_color == border) \|\|
320	((border & 0xFF000000)==0))	320	((border & 0xFF000000)==0))
321	{	321	{
322	dst_addr = &((char)(pixmap->mapped))[pixmap->pitchy0 + x0*4];	322	dst_addr = &((char)(pixmap->mapped))[pixmap->pitchy0 + x0*4];
323	pxDraw(dst_addr, pixmap->pitch, w, h, dst_color);	323	pxDraw(dst_addr, pixmap->pitch, w, h, dst_color);
324	}	324	}
325	else	325	else
326	{	326	{
327	if( y0 == yorg)	327	if( y0 == yorg)
328	{	328	{
329	dst_addr = &((char)(pixmap->mapped))[pixmap->pitchy0 + x0*4];	329	dst_addr = &((char)(pixmap->mapped))[pixmap->pitchy0 + x0*4];
330	HLine(dst_addr, w, border);	330	HLine(dst_addr, w, border);
331	y0++;	331	y0++;
332	h--;	332	h--;
333	}	333	}
334	if( y1 == yend )	334	if( y1 == yend )
335	{	335	{
336	dst_addr = &((char)(pixmap->mapped))[pixmap->pitchy1 + x0*4];	336	dst_addr = &((char)(pixmap->mapped))[pixmap->pitchy1 + x0*4];
337	HLine(dst_addr, w, border);	337	HLine(dst_addr, w, border);
338	h--;	338	h--;
339	}	339	}
340	if( (h > 0) && (x0 == xorg))	340	if( (h > 0) && (x0 == xorg))
341	{	341	{
342	int dy = h;	342	int dy = h;
343		343
344	dst_addr = &((char)(pixmap->mapped))[pixmap->pitchy0 + x0*4];	344	dst_addr = &((char)(pixmap->mapped))[pixmap->pitchy0 + x0*4];
345		345
346	while ( dy-- )	346	while ( dy-- )
347	{	347	{
348	(color_t)dst_addr = border;	348	(color_t)dst_addr = border;
349	dst_addr += pixmap->pitch;	349	dst_addr += pixmap->pitch;
350	}	350	}
351	x0++;	351	x0++;
352	w--;	352	w--;
353	}	353	}
354	if( (h > 0) && (x1 == xend))	354	if( (h > 0) && (x1 == xend))
355	{	355	{
356	int dy = h;	356	int dy = h;
357		357
358	dst_addr = &((char)(pixmap->mapped))[pixmap->pitchy0 + x1*4];	358	dst_addr = &((char)(pixmap->mapped))[pixmap->pitchy0 + x1*4];
359		359
360	while ( dy-- )	360	while ( dy-- )
361	{	361	{
362	(color_t)dst_addr = border;	362	(color_t)dst_addr = border;
363	dst_addr += pixmap->pitch;	363	dst_addr += pixmap->pitch;
364	}	364	}
365	w--;	365	w--;
366	}	366	}
367	if( (w > 0) && (h > 0) )	367	if( (w > 0) && (h > 0) )
368	{	368	{
369	dst_addr = &((char)(pixmap->mapped))[pixmap->pitchy0 + x0*4];	369	dst_addr = &((char)(pixmap->mapped))[pixmap->pitchy0 + x0*4];
370	pxDraw(dst_addr, pixmap->pitch, w, h, dst_color);	370	pxDraw(dst_addr, pixmap->pitch, w, h, dst_color);
371	}	371	}
372	}	372	}
373	};	373	};
374	};	374	};
375	return ERR_OK;	375	return ERR_OK;
376	};	376	};
377		377
378	int FillRect(pixmap_t *pixmap, int xorg, int yorg,	378	int FillRect(pixmap_t *pixmap, int xorg, int yorg,
379	int width, int height,	379	int width, int height,
380	brush_t *dst_brush, color_t border)	380	brush_t *dst_brush, color_t border)
381	{	381	{
382	if( ( width <= 0 ) \|\| ( height<=0 ) )	382	if( ( width <= 0 ) \|\| ( height<=0 ) )
383	return ERR_PARAM;	383	return ERR_PARAM;
384		384
385	/* if "hardware acceleration present" and	385	/* if "hardware acceleration present" and
386	"destinastion is primary screen or local videomemory"	386	"destinastion is primary screen or local videomemory"
387	*/	387	*/
388		388
389	if( (srv_hw2d != 0) &&	389	if( (srv_hw2d != 0) &&
390	( (pixmap == (void*)-1) \|\|	390	( (pixmap == (void*)-1) \|\|
391	( (pixmap->flags & PX_MEM_MASK)==PX_MEM_LOCAL) ) )	391	( (pixmap->flags & PX_MEM_MASK)==PX_MEM_LOCAL) ) )
392	{	392	{
393	fill_t fill;	393	fill_t fill;
394	ioctl_t io;	394	ioctl_t io;
395		395
396	fill.dstpix = ((int)pixmap == -1) ? (pixmap_t)-1 : (pixmap_t)pixmap->handle;	396	fill.dstpix = ((int)pixmap == -1) ? (pixmap_t)-1 : (pixmap_t)pixmap->handle;
397	fill.x = xorg;	397	fill.x = xorg;
398	fill.y = yorg;	398	fill.y = yorg;
399	fill.w = width;	399	fill.w = width;
400	fill.h = height;	400	fill.h = height;
401	fill.bkcolor = dst_brush->bkcolor;	401	fill.bkcolor = dst_brush->bkcolor;
402	fill.fcolor = dst_brush->fcolor;	402	fill.fcolor = dst_brush->fcolor;
403	fill.bmp0 = dst_brush->bmp[0];	403	fill.bmp0 = dst_brush->bmp[0];
404	fill.bmp1 = dst_brush->bmp[1];	404	fill.bmp1 = dst_brush->bmp[1];
405	fill.border = border;	405	fill.border = border;
406		406
407	io.handle = srv_hw2d;	407	io.handle = srv_hw2d;
408	io.io_code = PX_FILL_RECT;	408	io.io_code = PX_FILL_RECT;
409	io.input = &fill;	409	io.input = &fill;
410	io.inp_size = 10;	410	io.inp_size = 10;
411	io.output = NULL;	411	io.output = NULL;
412	io.out_size = 0;	412	io.out_size = 0;
413		413
414	return call_service(&io);	414	return call_service(&io);
415	}	415	}
416	else	416	else
417	/* no acceleration or destination in system memory */	417	/* no acceleration or destination in system memory */
418	{	418	{
419	clip_t clip;	419	clip_t clip;
420	int x0, y0, x1, y1, xend, yend;	420	int x0, y0, x1, y1, xend, yend;
421		421
422	pixmap = (pixmap == (void*)-1) ? &scrn_pixmap : pixmap ;	422	pixmap = (pixmap == (void*)-1) ? &scrn_pixmap : pixmap ;
423		423
424	x0 = xorg;	424	x0 = xorg;
425	y0 = yorg;	425	y0 = yorg;
426	x1 = xend = x0 + width - 1;	426	x1 = xend = x0 + width - 1;
427	y1 = yend = y0 + height - 1;	427	y1 = yend = y0 + height - 1;
428		428
429	clip.xmin = 0;	429	clip.xmin = 0;
430	clip.ymin = 0;	430	clip.ymin = 0;
431	clip.xmax = pixmap->width-1;	431	clip.xmax = pixmap->width-1;
432	clip.ymax = pixmap->height-1;	432	clip.ymax = pixmap->height-1;
433		433
434	if( ! BlockClip( &clip, &x0, &y0, &x1, &y1))	434	if( ! BlockClip( &clip, &x0, &y0, &x1, &y1))
435	{	435	{
436	int w, h, bh, bm_y;	436	int w, h, bh, bm_y;
437		437
438	__m64 clr_bb, clr_bf, clr_fb, clr_ff;	438	__m64 clr_bb, clr_bf, clr_fb, clr_ff;
439	char *dst_addr;	439	char *dst_addr;
440		440
441	clr_bb = _mm_cvtsi32_si64(dst_brush->bkcolor);	441	clr_bb = _mm_cvtsi32_si64(dst_brush->bkcolor);
442	clr_ff = _mm_cvtsi32_si64(dst_brush->fcolor);	442	clr_ff = _mm_cvtsi32_si64(dst_brush->fcolor);
443		443
444	clr_bb = _mm_unpacklo_pi32(clr_bb, clr_bb);	444	clr_bb = _mm_unpacklo_pi32(clr_bb, clr_bb);
445	clr_ff = _mm_unpacklo_pi32(clr_ff, clr_ff);	445	clr_ff = _mm_unpacklo_pi32(clr_ff, clr_ff);
446		446
447	clr_bf = _mm_unpacklo_pi32(clr_ff, clr_bb);	447	clr_bf = _mm_unpacklo_pi32(clr_ff, clr_bb);
448	clr_fb = _mm_unpacklo_pi32(clr_bb, clr_ff);	448	clr_fb = _mm_unpacklo_pi32(clr_bb, clr_ff);
449		449
450	w = x1 -x0 + 1;	450	w = x1 -x0 + 1;
451	bh = h = y1 -y0 + 1;	451	bh = h = y1 -y0 + 1;
452		452
453	dst_addr = & ((char)(pixmap->mapped))[pixmap->pitchy0+x0*4];	453	dst_addr = & ((char)(pixmap->mapped))[pixmap->pitchy0+x0*4];
454		454
455	bm_y = y0 & 7;	455	bm_y = y0 & 7;
456		456
457	while(h--)	457	while(h--)
458	{	458	{
459	u8_t mask = dst_brush->bits[bm_y];	459	u8_t mask = dst_brush->bits[bm_y];
460		460
461	char *tmp_dst = dst_addr;	461	char *tmp_dst = dst_addr;
462	int width = w;	462	int width = w;
463	dst_addr += pixmap->pitch;	463	dst_addr += pixmap->pitch;
464	bm_y = (bm_y+1) & 7;	464	bm_y = (bm_y+1) & 7;
465		465
466	while(width>=2)	466	while(width>=2)
467	{	467	{
468	__asm__ __volatile__	468	__asm__ __volatile__
469	("rolb $2, %0 \n\t"	469	("rolb $2, %0 \n\t"
470	:"+g" (mask):"g"(mask)	470	:"+g" (mask):"g"(mask)
471	:"cc");	471	:"cc");
472		472
473	switch( mask & 3 )	473	switch( mask & 3 )
474	{	474	{
475	case 0:	475	case 0:
476	__asm__ __volatile__	476	__asm__ __volatile__
477	("movq %[clr], (%0)\n\t" :: "r" (tmp_dst), [clr] "y" (clr_bb));	477	("movq %[clr], (%0)\n\t" :: "r" (tmp_dst), [clr] "y" (clr_bb));
478	break;	478	break;
479		479
480	case 1:	480	case 1:
481	__asm__ __volatile__	481	__asm__ __volatile__
482	("movq %[clr], (%0)\n\t" :: "r" (tmp_dst), [clr] "y" (clr_fb));	482	("movq %[clr], (%0)\n\t" :: "r" (tmp_dst), [clr] "y" (clr_fb));
483	break;	483	break;
484		484
485	case 2:	485	case 2:
486	__asm__ __volatile__	486	__asm__ __volatile__
487	("movq %[clr], (%0)\n\t" :: "r" (tmp_dst), [clr] "y" (clr_bf));	487	("movq %[clr], (%0)\n\t" :: "r" (tmp_dst), [clr] "y" (clr_bf));
488	break;	488	break;
489		489
490	case 3:	490	case 3:
491	__asm__ __volatile__	491	__asm__ __volatile__
492	("movq %[clr], (%0)\n\t" :: "r" (tmp_dst), [clr] "y" (clr_ff));	492	("movq %[clr], (%0)\n\t" :: "r" (tmp_dst), [clr] "y" (clr_ff));
493	break;	493	break;
494	}	494	}
495	width -=2;	495	width -=2;
496	tmp_dst +=8;	496	tmp_dst +=8;
497	}	497	}
498	if( width )	498	if( width )
499	if( mask & 1 )	499	if( mask & 1 )
500	__asm__ __volatile__	500	__asm__ __volatile__

Subversion Repositories Kolibri OS

(root)/programs/develop/libraries/pixlib/draw.inc @ 882 – Rev 882 → 1002