Subversion Repositories Kolibri OS

Rev

Go to most recent revision | Blame | Compare with Previous | Last modification | View Log | Download | RSS feed

  1.  
  2. static pixmap_t* alloc_pixmap()
  3. {
  4.      if( px_slab.available )
  5.      {
  6.         pixmap_t *pixmap;
  7.  
  8.         px_slab.available--;
  9.         pixmap = (pixmap_t*)px_slab.nextavail;
  10.         px_slab.nextavail = *(void**)pixmap;
  11.  
  12.         return pixmap;
  13.      }
  14.      return NULL;
  15. };
  16.  
  17. static void  free_pixmap(pixmap_t *pixmap)
  18. {
  19.      *(void**)pixmap = px_slab.nextavail;
  20.      px_slab.nextavail = pixmap;
  21.      px_slab.available++;
  22. };
  23.  
  24. pixmap_t* CreatePixmap(unsigned width, unsigned height, u32_t format, u32_t flags)
  25. {
  26.      pixmap_t *pixmap;
  27.  
  28.      if( (width  == 0) || ( width > 2048)||
  29.          (height == 0) || (height > 2048)||
  30.          (format != PICT_a8r8g8b8))
  31.         return NULL;
  32.  
  33.      pixmap = alloc_pixmap();
  34.  
  35.      if( pixmap )
  36.      {
  37.         void *raw;
  38.         int  pitch;
  39.  
  40.         pixmap->width   = width;
  41.         pixmap->height  = height;
  42.         pixmap->format  = format;
  43.         pixmap->flags   = flags;
  44.  
  45.         if( (srv_hw2d != 0) &&
  46.             ( (flags & PX_MEM_MASK)==PX_MEM_LOCAL) )
  47.         {
  48.            ioctl_t io;
  49.            io.handle   = srv_hw2d;
  50.            io.io_code  = PX_CREATE;
  51.            io.input    = pixmap;
  52.            io.inp_size = 7;
  53.            io.output   = NULL;
  54.            io.out_size = 0;
  55.  
  56.            if (call_service(&io)==ERR_OK)
  57.               return pixmap;
  58.            else
  59.            {
  60.               free_pixmap(pixmap) ;
  61.               return NULL;
  62.            }
  63.         }
  64.         else
  65.      {
  66. /*
  67.    Only system memory
  68. */
  69.         pixmap->flags &= ~PX_MEM_MASK;
  70.  
  71.         pitch = ((width+8)&~8)*4;
  72.         raw = UserAlloc(pitch * height);
  73.  
  74.         if (! raw)
  75.         {
  76.            free_pixmap(pixmap);
  77.            return NULL;
  78.         };
  79.         pixmap->pitch   = pitch;
  80.         pixmap->mapped  = raw;
  81.      };
  82.      return pixmap;
  83.   };
  84.   return NULL;
  85. };
  86.  
  87. int DestroyPixmap( pixmap_t *pixmap)
  88. {
  89.      int retval = ERR_OK;
  90.  
  91.      if(pixmap == (pixmap_t*)-1)
  92.         return ERR_PARAM;
  93.  
  94.      if( (srv_hw2d != 0) &&
  95.          ( (pixmap->flags & PX_MEM_MASK)==PX_MEM_LOCAL) )
  96.      {
  97.         int retval;
  98.  
  99.         ioctl_t io;
  100.         io.handle   = srv_hw2d;
  101.         io.io_code  = PX_DESTROY;
  102.         io.input    = pixmap;
  103.         io.inp_size = 7;
  104.         io.output   = NULL;
  105.         io.out_size = 0;
  106.  
  107.         retval = call_service(&io);
  108.      }
  109.      else
  110.      {
  111.         UserFree(pixmap->mapped);
  112.  
  113.         pixmap->pitch  = 0;
  114.         pixmap->mapped = 0;
  115.         pixmap->handle = 0;
  116.      };
  117.      free_pixmap(pixmap);
  118.  
  119.      return retval;
  120. };
  121.  
  122. void* LockPixmap(pixmap_t *pixmap)
  123. {
  124.      if(pixmap == (pixmap_t*)-1)
  125.         return scrn_pixmap.mapped;
  126.      else
  127.         return pixmap->mapped;
  128. }
  129.  
  130. int UnlockPixmap(pixmap_t *pixmap)
  131. {
  132.      return ERR_OK;
  133. };
  134.  
  135. int GetPixmapPitch(pixmap_t *pixmap)
  136. {
  137.      if(pixmap == (pixmap_t*)-1)
  138.         return scrn_pixmap.pitch;
  139.      else
  140.         return pixmap->pitch;
  141. };
  142.