kolibrios/programs/develop/libraries/pixlib/pixmap.inc

static pixmap_t* alloc_pixmap()
{
     if( px_slab.available )
     {
        pixmap_t *pixmap;

        px_slab.available--;
        pixmap = (pixmap_t*)px_slab.nextavail;
        px_slab.nextavail = *(void**)pixmap;

        return pixmap;
     }
     return NULL;
};

static void  free_pixmap(pixmap_t *pixmap)
{
     *(void**)pixmap = px_slab.nextavail;
     px_slab.nextavail = pixmap;
     px_slab.available++;
};

pixmap_t* CreatePixmap(unsigned width, unsigned height, u32_t format, u32_t flags)
{
     pixmap_t *pixmap;

     if( (width  == 0) || ( width > 2048)||
         (height == 0) || (height > 2048)||
         (format != PICT_a8r8g8b8))
        return NULL;

     pixmap = alloc_pixmap();

     if( pixmap )
     {
        void *raw;
        int  pitch;

        pixmap->width   = width;
        pixmap->height  = height;
        pixmap->format  = format;
        pixmap->flags   = flags;

        if( (srv_hw2d != 0) &&
            ( (flags & PX_MEM_MASK)==PX_MEM_LOCAL) )
        {
           ioctl_t io;
           io.handle   = srv_hw2d;
           io.io_code  = PX_CREATE;
           io.input    = pixmap;
           io.inp_size = 7;
           io.output   = NULL;
           io.out_size = 0;

           if (call_service(&io)==ERR_OK)
              return pixmap;
           else
           {
              free_pixmap(pixmap) ;
              return NULL;
           }
        }
        else
     {
/*
   Only system memory
*/
        pixmap->flags &= ~PX_MEM_MASK;

        pitch = ((width+8)&~8)*4;
        raw = UserAlloc(pitch * height);

        if (! raw)
        {
           free_pixmap(pixmap);
           return NULL;
        };
        pixmap->pitch   = pitch;
        pixmap->mapped  = raw;
     };
     return pixmap;
  };
  return NULL;
};

int DestroyPixmap( pixmap_t *pixmap)
{
     int retval = ERR_OK;

     if(pixmap == (pixmap_t*)-1)
        return ERR_PARAM;

     if( (srv_hw2d != 0) &&
         ( (pixmap->flags & PX_MEM_MASK)==PX_MEM_LOCAL) )
     {
        int retval;

        ioctl_t io;
        io.handle   = srv_hw2d;
        io.io_code  = PX_DESTROY;
        io.input    = pixmap;
        io.inp_size = 7;
        io.output   = NULL;
        io.out_size = 0;

        retval = call_service(&io);
     }
     else
     {
        UserFree(pixmap->mapped);

        pixmap->pitch  = 0;
        pixmap->mapped = 0;
        pixmap->handle = 0;
     };
     free_pixmap(pixmap);

     return retval;
};

void* LockPixmap(pixmap_t *pixmap)
{
     if(pixmap == (pixmap_t*)-1)
        return scrn_pixmap.mapped;
     else
        return pixmap->mapped;
}

int UnlockPixmap(pixmap_t *pixmap)
{
     return ERR_OK;
};

int GetPixmapPitch(pixmap_t *pixmap)
{
     if(pixmap == (pixmap_t*)-1)
        return scrn_pixmap.pitch;
     else
        return pixmap->pitch;
};