Subversion Repositories Kolibri OS

Rev

Rev 882 | 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.                 free_pixmap(pixmap) ;
  60.                 return NULL;
  61.             }
  62.         }
  63.         else
  64.         {
  65. /*
  66.    Only system memory
  67. */
  68.             pixmap->flags &= ~PX_MEM_MASK;
  69.  
  70.             pitch = ((width+8)&~8)*4;
  71.             raw = UserAlloc(pitch * height);
  72.  
  73.             if ( !raw ){
  74.                 free_pixmap(pixmap);
  75.                 return NULL;
  76.             };
  77.             pixmap->pitch   = pitch;
  78.             pixmap->mapped  = raw;
  79.         };
  80.         return pixmap;
  81.     };
  82.     return NULL;
  83. };
  84.  
  85. int DestroyPixmap( pixmap_t *pixmap)
  86. {
  87.      int retval = ERR_OK;
  88.  
  89.      if(pixmap == (pixmap_t*)-1)
  90.         return ERR_PARAM;
  91.  
  92.      if( (srv_hw2d != 0) &&
  93.          ( (pixmap->flags & PX_MEM_MASK)==PX_MEM_LOCAL) )
  94.      {
  95.         int retval;
  96.  
  97.         ioctl_t io;
  98.         io.handle   = srv_hw2d;
  99.         io.io_code  = PX_DESTROY;
  100.         io.input    = pixmap;
  101.         io.inp_size = 7;
  102.         io.output   = NULL;
  103.         io.out_size = 0;
  104.  
  105.         retval = call_service(&io);
  106.      }
  107.      else
  108.      {
  109.         UserFree(pixmap->mapped);
  110.  
  111.         pixmap->pitch  = 0;
  112.         pixmap->mapped = 0;
  113.         pixmap->handle = 0;
  114.      };
  115.      free_pixmap(pixmap);
  116.  
  117.      return retval;
  118. };
  119.  
  120. void* LockPixmap(pixmap_t *pixmap)
  121. {
  122.      if(pixmap == (pixmap_t*)-1)
  123.         return scrn_pixmap.mapped;
  124.      else
  125.         return pixmap->mapped;
  126. }
  127.  
  128. int UnlockPixmap(pixmap_t *pixmap)
  129. {
  130.      return ERR_OK;
  131. };
  132.  
  133. int GetPixmapPitch(pixmap_t *pixmap)
  134. {
  135.      if(pixmap == (pixmap_t*)-1)
  136.         return scrn_pixmap.pitch;
  137.      else
  138.         return pixmap->pitch;
  139. };
  140.