Subversion Repositories Kolibri OS

#include 

#include 

#include 

#include "pixdriver.h"

#define SRV_GET_CAPS                3

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

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

{

	uint32_t width;

	uint32_t height;

	void *data;

	uint32_t pitch;

	uint32_t bo;

	uint32_t bo_size;

	uint32_t flags;

} surface_t;

static uint32_t hw_caps;

static struct pix_driver pix_driver;

{

    void *lib;

    uint32_t (*drventry)(uint32_t service, struct pix_driver *driver);

	ioctl_t io;

		return caps & hw_caps;

	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;

    if(lib == 0)

        lib = load_library("intel-uxa.drv");

    if(lib == 0)

        goto fail;

        goto fail;

		printf("2D caps %s%s%s\n",

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

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

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

	service = 0;

	return 0;

};

{

	if (hw_caps != 0)

        pix_driver.fini();

};

{

	uint32_t size, bo_size;

	uint32_t pitch, max_pitch;

	void *buffer;

	surface_t *sf;

	bitmap->data = (void *) -1;

	bitmap->pitch = -1;

       return pix_driver.create_bitmap(bitmap);

	max_pitch = ALIGN(bitmap->max_width * 4, 16);

	bo_size = ALIGN(max_pitch * bitmap->max_height, 4096);

		bo_size = size;

	if (sf == NULL)

		return -1;

	{

		free(sf);

		return -1;

	};

	sf->height = bitmap->height;

	sf->data = buffer;

	sf->pitch = pitch;

	sf->bo = 0;

	sf->bo_size = bo_size;

	sf->flags = bitmap->flags;

//            bitmap, bitmap->handle, bitmap->data, bitmap->width, bitmap->height);

};

{

	surface_t *sf = to_surface(bitmap);

        return pix_driver.destroy_bitmap(bitmap);

	free(sf);

	bitmap->data = (void *) -1;

	bitmap->pitch = -1;

};

{

	surface_t *sf = to_surface(bitmap);

		return 0;

       return pix_driver.lock_bitmap(bitmap);

	bitmap->pitch = sf->pitch;

};

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

{

	struct blit_call bc;

	int ret;

        return pix_driver.blit(bitmap, 0, 0, dst_x, dst_y, w, h, src_x, src_y);

	bc.dsty     = dst_y;

	bc.w        = w;

	bc.h        = h;

	bc.srcx     = 0;

	bc.srcy     = 0;

	bc.srcw     = w;

	bc.srch     = h;

	bc.stride   = sf->pitch;

	bc.bitmap   = sf->data;

    "int $0x40":"=a"(ret):"a"(73), "b"(0x00),

	"c"(&bc):"memory");

	bitmap->pitch = -1;

};

{

	struct blit_call bc;

	int ret;

        return pix_driver.blit(bitmap, 1, 1, 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 = sf->pitch;

	bc.bitmap = sf->data;

    "int $0x40":"=a"(ret):"a"(73), "b"(0x00),

	"c"(&bc):"memory");

	bitmap->pitch = -1;

};

{

	uint32_t size;

	uint32_t pitch;

        return pix_driver.resize_bitmap(bitmap);

	size = ALIGN(pitch * bitmap->height, 4096);

	bitmap->data = (void *) -1;

	{

		sf->data = user_realloc(sf->data, size);	/* grow buffer */

		if (sf->data == NULL)

			return -1;

	} else if (size < sf->bo_size)

		user_unmap(sf->data, size, sf->bo_size - size);	/* unmap unused pages */

	sf->height = bitmap->height;

	sf->pitch  = pitch;

};

{

    return 0;

}