Subversion Repositories Kolibri OS

#include 

#include "system.h"

#define SRV_GET_CAPS         3

#define SRV_DESTROY_SURFACE     11

#define SRV_LOCK_SURFACE    12

#define SRV_UNLOCK_SURFACE      13

#define SRV_RESIZE_SURFACE      14

#define SRV_BLIT_BITMAP         15

#define SRV_BLIT_TEXTURE        16

#define SRV_BLIT_VIDEO          17

#define __ALIGN_MASK(x,mask)  (((x)+(mask))&~(mask))

#define ALIGN(x,a)            __ALIGN_MASK(x,(typeof(x))(a)-1)

void sna_fini();

void sna_destroy_bitmap(bitmap_t *bitmap);

void sna_lock_bitmap(bitmap_t *bitmap);

int  sna_blit_copy(bitmap_t *src_bitmap, int dst_x, int dst_y,

                  int w, int h, int src_x, int src_y);

int  sna_blit_tex(bitmap_t *src_bitmap, int dst_x, int dst_y,

                  int w, int h, int src_x, int src_y);

static uint32_t blit_caps;

static uint32_t screen_width;

static uint32_t screen_height;

{

  unsigned      handle;

  unsigned      io_code;

  void          *input;

  int           inp_size;

  void          *output;

  int           out_size;

}ioctl_t;

{

    uint32_t  idx;

    union

    {

        uint32_t opt[2];

        struct {

            uint32_t max_tex_width;

            uint32_t max_tex_height;

        }cap1;

    };

}hwcaps_t;

{

  uint32_t retval = 0;

  asm volatile ("int $0x40"

      :"=a"(retval)

      :"a"(68),"b"(16),"c"(name)

      :"memory");

};

{

  int retval;

      :"=a"(retval)

      :"a"(68),"b"(17),"c"(io)

      :"memory","cc");

};

{

    uint32_t  api_version;

    uint32_t  screensize;

    hwcaps_t  hwcaps;

    ioctl_t   io;

    screen_width  = screensize >> 16;

    screen_height = screensize & 0xFFFF;

    if(service == 0)

        goto fail;

    io.io_code  = SRV_GETVERSION;

    io.input    = NULL;

    io.inp_size = 0;

    io.output   = &api_version;

    io.out_size = BUFFER_SIZE(1);

        goto fail;

        (DISPLAY_VERSION < (api_version >> 16)))

        goto fail;

/*

 * Let's see what this service can do

*/

    hwcaps.idx  = 0;

    io.io_code  = SRV_GET_CAPS;

    io.input    = &hwcaps;

    io.inp_size = sizeof(hwcaps);

    io.output   = NULL;

    io.out_size = 0;

        goto fail;

        printf("service caps %s%s%s\n",

               (blit_caps & HW_BIT_BLIT) != 0 ?"HW_BIT_BLIT ":"",

               (blit_caps & HW_TEX_BLIT) != 0 ?"HW_TEX_BLIT ":"",

               (blit_caps & HW_VID_BLIT) != 0 ?"HW_VID_BLIT ":"");

#endif

        printf("service caps %s%s%s\n",

               (blit_caps & HW_BIT_BLIT) != 0 ?"HW_BIT_BLIT ":"",

               (blit_caps & HW_TEX_BLIT) != 0 ?"HW_TEX_BLIT ":"",

               (blit_caps & HW_VID_BLIT) != 0 ?"HW_VID_BLIT ":"");

    service = 0;

    return 0;

};

{

{

 //    __asm__ __volatile__("int3");

    uint32_t   pitch;

    uint8_t   *buffer;

        return sna_create_bitmap(bitmap);

//        return sna_create_bitmap(bitmap);

    size  = pitch * bitmap->height;

    if( buffer )

    {

        bitmap->handle = 0;

        bitmap->pitch  = pitch;

        bitmap->data   = buffer;

        bitmap->flags  = 0;

        return 0;

    };

{

    if( bitmap->flags & (HW_BIT_BLIT | HW_TEX_BLIT ))

        sna_destroy_bitmap(bitmap);

    return 0;

};

{

 //    __asm__ __volatile__("int3");

        sna_lock_bitmap(bitmap);

};

                int w, int h)

{

    int err;

        return sna_blit_tex(bitmap, dst_x, dst_y, w, h, 0, 0);

    bc.dsty = dst_y;

    bc.w    = w;

    bc.h    = h;

    bc.srcx = 0;

    bc.srcy = 0;

    bc.srcw = w;

    bc.srch = h;

    bc.stride = bitmap->pitch;

    bc.bitmap = bitmap->data;

    "int $0x40"

    :"=a"(err)

    :"a"(73),"b"(0x00),"c"(&bc)

    :"memory");

};

{

 //    __asm__ __volatile__("int3");

    {

        struct __attribute__((packed))

        {

            uint32_t  handle;

            char     *data;

            uint32_t  new_w;

            uint32_t  new_h;

            uint32_t  pitch;

        }io_14;

        int     err;

        io_14.new_w  = bitmap->width;

        io_14.new_h  = bitmap->height;

        io.io_code   = SRV_RESIZE_SURFACE;

        io.input     = &io_14;

        io.inp_size  = BUFFER_SIZE(5);

        io.output    = NULL;

        io.out_size  = 0;

        if(err==0)

    {

            bitmap->pitch  = io_14.pitch;

            bitmap->data   = io_14.data;

        };

        return err;

    };

    uint32_t   pitch;

    uint8_t   *buffer;

    size  = pitch * bitmap->height;

    if( buffer )

    {

        bitmap->handle = 0;

        bitmap->pitch  = pitch;

        bitmap->data   = buffer;

        return 0;

    };

};