#include "config.h"
#include "types.h"

#include "bmp.h"

#include "sys.h"
#include "memory.h"
#include "maths3D.h"

#include "vdp.h"
#include "vdp_tile.h"
#include "vdp_bg.h"

#include "dma.h"

#include "mapper.h"
#include "memory.h"
#include "tools.h"
#include "string.h"


#define BMP_FLAG_DOUBLEBUFFER   (1 << 0)
#define BMP_FLAG_COPYBUFFER     (1 << 1)

#define BMP_STAT_FLIPPING       (1 << 0)
#define BMP_STAT_BLITTING       (1 << 1)
#define BMP_STAT_FLIPWAITING    (1 << 2)

#define HAS_DOUBLEBUFFER        (flag & BMP_FLAG_DOUBLEBUFFER)
#define HAS_BUFFERCOPY          (flag & BMP_FLAG_COPYBUFFER)

#define READ_IS_FB0             (bmp_buffer_read == bmp_buffer_0)
#define READ_IS_FB1             (bmp_buffer_read == bmp_buffer_1)
#define WRITE_IS_FB0            (bmp_buffer_write == bmp_buffer_0)
#define WRITE_IS_FB1            (bmp_buffer_write == bmp_buffer_1)

#define GET_YOFFSET             ((HAS_DOUBLEBUFFER && READ_IS_FB1)?((BMP_PLANE_HEIGHT / 2) + 4):4)

#define BMP_PLANE_ADDR          (*bmp_plane_addr)

#define BMP_FB0_TILEMAP_BASE    BMP_PLANE_ADDR
#define BMP_FB1_TILEMAP_BASE    (BMP_PLANE_ADDR + ((BMP_PLANE_WIDTH * (BMP_PLANE_HEIGHT / 2)) * 2))
#define BMP_FB_TILEMAP_OFFSET   (((BMP_PLANE_WIDTH * BMP_TILE_YOFFSET) + BMP_TILE_XOFFSET) * 2)


#define NTSC_TILES_BW           7
#define PAL_TILES_BW            10


// we don't want to share them
extern vu16 VBlankProcess;
extern u16 text_basetile;

u8 *bmp_buffer_read;
u8 *bmp_buffer_write;

static u8 *bmp_buffer_0;
static u8 *bmp_buffer_1;

VDPPlane bmp_plan;
u16 *bmp_plane_addr;

// internals
static u16 flag;
static u16 pal;
static u16 prio;
static vu16 state;
static vs16 phase;


// ASM methods
extern void clearBitmapBuffer(u8 *bmp_buffer);
extern void copyBitmapBuffer(u8 *src, u8 *dst);

static void doFlip();
static void flipBuffer();
static void initTilemap(u16 index);
static void clearVRAMBuffer(u16 index);
static u16 doBlit();
static void drawLine_old(u16 x1, u16 y1, s16 dx, s16 dy, s16 step_x, s16 step_y, u8 col);
static HINTERRUPT_CALLBACK hint();


NO_INLINE void BMP_init(u16 double_buffer, VDPPlane plane, u16 palette, u16 priority)
{
    flag = (double_buffer) ? BMP_FLAG_DOUBLEBUFFER : 0;
    bmp_plan = plane;
    pal = palette & 3;
    prio = priority & 1;

    switch(plane)
    {
        default:
        case BG_B:
            bmp_plane_addr = &bgb_addr;
            break;

        case BG_A:
            bmp_plane_addr = &bga_addr;
            break;

        case WINDOW:
            bmp_plane_addr = &window_addr;
            break;
    }

    bmp_buffer_0 = NULL;
    bmp_buffer_1 = NULL;

    BMP_reset();
}

NO_INLINE void BMP_end()
{
    // cancel interrupt processing
    SYS_setHIntCallback(NULL);
    VBlankProcess &= ~PROCESS_BITMAP_TASK;

    // better to disable ints here
    // FIXME: for some reason disabling interrupts generally break BMP init :-/
//    SYS_disableInts();

    // disable H-Int
    VDP_setHInterrupt(0);
    // re enabled VDP if it was disabled because of extended blank
    VDP_setEnable(1);
    // reset hint counter
    VDP_setHIntCounter(255);

    // reset back vertical scroll to 0
    VDP_setVerticalScroll(bmp_plan, 0);

    // release memory
    if (bmp_buffer_0)
    {
        MEM_free(bmp_buffer_0);
        bmp_buffer_0 = NULL;
    }
    if (bmp_buffer_1)
    {
        MEM_free(bmp_buffer_1);
        bmp_buffer_1 = NULL;
    }

    // try to pack memory free blocks (before to avoid memory fragmentation)
    MEM_pack();

    // restore 64x32 cells sized plane
    VDP_setPlaneSize(64, 32, TRUE);

    // we can re enable ints
    // FIXME: for some reason disabling interrupts generally break BMP init :-/
//    SYS_enableInts();
}

NO_INLINE void BMP_reset()
{
    // cancel bitmap interrupt processing
    SYS_setHIntCallback(NULL);
    VBlankProcess &= ~PROCESS_BITMAP_TASK;

    // better to disable ints here
    // FIXME: for some reason disabling interrupts generally break BMP init :-/
//    SYS_disableInts();

    // disable H-Int
    VDP_setHInterrupt(0);
    // re enabled VDP if it was disabled because of extended blank
    VDP_setEnable(1);
    // reset hint counter
    VDP_setHIntCounter(255);

    // allocate bitmap buffer if needed
    if (!bmp_buffer_0)
        bmp_buffer_0 = MEM_alloc(BMP_PITCH * BMP_HEIGHT * sizeof(u8));
    if (!bmp_buffer_1)
        bmp_buffer_1 = MEM_alloc(BMP_PITCH * BMP_HEIGHT * sizeof(u8));

    // need 64x64 cells sized plane
    VDP_setPlaneSize(64, 64, TRUE);
    // we need to tweak VRAM setup as Bitmap mode may require double buffering in VRAM
    VDP_setSpriteListAddress(0xBC00);
    VDP_setHScrollTableAddress(0xB800);
    // so window plan can be use only on first top half of the screen

    // clear plane (complete tilemap)
    VDP_clearPlane(bmp_plan, TRUE);

    // reset state and phase
    state = 0;
    phase = -1;

    // default
    bmp_buffer_read = bmp_buffer_0;
    bmp_buffer_write = bmp_buffer_1;

    // prepare tilemap
    initTilemap(0);
    clearVRAMBuffer(0);
    if (HAS_DOUBLEBUFFER)
    {
        initTilemap(1);
        clearVRAMBuffer(1);
    }

    // clear both buffer in memory
    clearBitmapBuffer(bmp_buffer_0);
    clearBitmapBuffer(bmp_buffer_1);

    // set back vertical scroll to 0
    VDP_setVerticalScroll(bmp_plan, 0);

    // prepare hint for extended blank on next frame
    VDP_setHIntCounter(((screenHeight - BMP_HEIGHT) >> 1) - 1);
    // enabled bitmap interrupt processing
    SYS_setHIntCallback(hint);
    VBlankProcess |= PROCESS_BITMAP_TASK;
    VDP_setHInterrupt(1);

    // we can re enable ints
    // FIXME: for some reason disabling interrupts generally break BMP init :-/
//    SYS_enableInts();

//    // first init, clear and flip
//    BMP_clear();
//    BMP_flip(FALSE);
//    // second init, clear and flip for correct init (double buffer)
//    BMP_clear();
//    BMP_flip(FALSE);
}

void BMP_setBufferCopy(u16 value)
{
    if (value) flag |= BMP_FLAG_COPYBUFFER;
    else flag &= ~BMP_FLAG_COPYBUFFER;
}


u16 BMP_hasFlipRequestPending()
{
    if (state & BMP_STAT_FLIPWAITING) return 1;

    return 0;
}

void BMP_waitWhileFlipRequestPending()
{
    while (BMP_hasFlipRequestPending());
}

u16 BMP_hasFlipInProgess()
{
    if (state & BMP_STAT_FLIPPING) return 1;

    return 0;
}

void BMP_waitFlipComplete()
{
    while (BMP_hasFlipInProgess());
}


NO_INLINE u16 BMP_flip(u16 async)
{
    // wait until pending flip is processed
    BMP_waitWhileFlipRequestPending();

    // currently flipping ?
    if (state & BMP_STAT_FLIPPING)
    {
        // set a pending flip
        state |= BMP_STAT_FLIPWAITING;

        // wait completion
        if (!async) BMP_waitFlipComplete();

        return 1;
    }

    // flip bitmap buffer
    flipBuffer();
    // flip started (will be processed in blank period --> BMP_doBlankProcess)
    state |= BMP_STAT_FLIPPING;

    // wait completion
    if (!async) BMP_waitFlipComplete();

    return 0;
}


void BMP_drawText(const char *str, u16 x, u16 y)
{
    VDP_drawTextBG(bmp_plan, str, x, y + GET_YOFFSET);
}

void BMP_clearText(u16 x, u16 y, u16 w)
{
    VDP_clearTextBG(bmp_plan, x, y + GET_YOFFSET, w);
}

void BMP_clearTextLine(u16 y)
{
    VDP_clearTextLineBG(bmp_plan, y + GET_YOFFSET);
}


void BMP_showFPS(u16 float_display, u16 x, u16 y)
{
    char str[16];
    y = GET_YOFFSET + y;

    if (float_display)
    {
        fix32ToStr(SYS_getFPSAsFloat(), str, 1);
        // display FPS
        VDP_drawTextBGFill(bmp_plan, str, x, y, 4);
    }
    else
    {
        uintToStr(SYS_getFPS(), str, 1);
        // display FPS
        VDP_drawTextBGFill(bmp_plan, str, x, y, 2);
    }
}


// graphic drawing functions
////////////////////////////

void BMP_clear()
{
    clearBitmapBuffer(bmp_buffer_write);
}


u8* BMP_getWritePointer(u16 x, u16 y)
{
    const u16 off = (y * BMP_PITCH) + (x >> 1);
    // return write address
    return bmp_buffer_write + off;
}

u8* BMP_getReadPointer(u16 x, u16 y)
{
    const u16 off = (y * BMP_PITCH) + (x >> 1);
    // return read address
    return bmp_buffer_read + off;
}

// inlining allow C functions to perform better than assembly methods
inline u8 BMP_getPixelFast(u16 x, u16 y)
{
    const u16 off = (y * BMP_PITCH) + (x >> 1);
    u8* dst = bmp_buffer_write + off;

    if (x & 1) return *dst >> 4;
    else  return *dst & 0x0F;
}

// inlining allow C functions to perform better than assembly methods
inline u8 BMP_getPixel(u16 x, u16 y)
{
    // pixel in screen ?
    if ((x < BMP_WIDTH) && (y < BMP_HEIGHT)) return BMP_getPixelFast(x, y);

    return 0;
}

// inlining allow C functions to perform better than assembly methods
inline void BMP_setPixelFast(u16 x, u16 y, u8 col)
{
    const u16 off = (y * BMP_PITCH) + (x >> 1);
    u8* dst = bmp_buffer_write + off;

    if (x & 1) *dst = (*dst & 0xF0) | (col & 0x0F);
    else *dst = (*dst & 0x0F) | (col & 0xF0);
}

// inlining allow C functions to perform better than assembly methods
inline void BMP_setPixel(u16 x, u16 y, u8 col)
{
    // pixel in screen ?
    if ((x < BMP_WIDTH) && (y < BMP_HEIGHT)) BMP_setPixelFast(x, y, col);
}

// obsolete: replaced by assembly function
void BMP_setPixels_V2D_old(const Vect2D_u16 *crd, u8 col, u16 num)
{
    const Vect2D_u16 *v;
    u8* base;
    u16 i;

    const u8 mu = 0xF0;
    const u8 md = 0x0F;
    const u8 cu = col & mu;
    const u8 cd = col & md;

    base = bmp_buffer_write;
    v = crd;
    i = num;

    while (i--)
    {
        const u16 x = v->x;
        const u16 y = v->y;

        if ((x < BMP_WIDTH) && (y < BMP_HEIGHT))
        {
            const u16 off = (y * BMP_PITCH) + (x >> 1);
            u8* dst = base + off;

            if (x & 1) *dst = (*dst & mu) | cd;
            else *dst = (*dst & md) | cu;
        }

        // next pixel
        v++;
    }
}

// obsolete: replaced by assembly function
void BMP_setPixelsFast_V2D_old(const Vect2D_u16 *crd, u8 col, u16 num)
{
    const Vect2D_u16 *v;
    u8* base;
    u16 i;

    const u8 mu = 0xF0;
    const u8 md = 0x0F;
    const u8 cu = col & mu;
    const u8 cd = col & md;

    base = bmp_buffer_write;
    v = crd;
    i = num;

    while (i--)
    {
        const u16 x = v->x;
        const u16 y = v->y;
        const u16 off = (y * BMP_PITCH) + (x >> 1);
        u8* dst = base + off;

        if (x & 1) *dst = (*dst & mu) | cd;
        else *dst = (*dst & md) | cu;

        // next pixel
        v++;
    }
}

// obsolete: replaced by assembly function
void BMP_setPixels_old(const Pixel *pixels, u16 num)
{
    const Pixel *p;
    u8* base;
    u16 i;

    const u8 mu = 0xF0;
    const u8 md = 0x0F;

    base = bmp_buffer_write;
    p = pixels;
    i = num;

    while (i--)
    {
        const u16 x = p->pt.x;
        const u16 y = p->pt.y;

        if ((x < BMP_WIDTH) && (y < BMP_HEIGHT))
        {
            const u16 off = (y * BMP_PITCH) + (x >> 1);
            u8* dst = base + off;
            const u8 c = p->col;

            if (x & 1) *dst = (*dst & mu) | (c & md);
            else *dst = (*dst & md) | (c & mu);
        }

        // next pixel
        p++;
    }
}

// obsolete: replaced by assembly function
void BMP_setPixelsFast_old(const Pixel *pixels, u16 num)
{
    const Pixel *p;
    u8* base;
    u16 i;

    const u8 mu = 0xF0;
    const u8 md = 0x0F;

    base = bmp_buffer_write;
    p = pixels;
    i = num;

    while (i--)
    {
        const u16 x = p->pt.x;
        const u16 y = p->pt.y;
        const u16 off = (y * BMP_PITCH) + (x >> 1);
        u8* dst = base + off;
        const u8 c = p->col;

        if (x & 1) *dst = (*dst & mu) | (c & md);
        else *dst = (*dst & md) | (c & mu);

        // next pixel
        p++;
    }
}


void BMP_drawLine_old(Line *l)
{
    // process clipping (exit if outside screen)
    if (BMP_clipLine(l))
    {
        s16 dx, dy;
        s16 step_x, step_y;

        const s16 x1 = l->pt1.x;
        const s16 y1 = l->pt1.y;
        // calcul new deltas
        dx = l->pt2.x - x1;
        dy = l->pt2.y - y1;

        if (dx < 0)
        {
            dx = -dx;
            step_x = -1;
        }
        else
            step_x = 1;

        if (dy < 0)
        {
            dy = -dy;
            step_y = -BMP_PITCH;
        }
        else
            step_y = BMP_PITCH;

        drawLine_old(x1, y1, dx, dy, step_x, step_y, l->col);
    }
}

//void BMP_drawLineFast(Line *l)
//{
//    s16 x0, y0;
//    s16 x1, y1;
//    s16 dx, dy;
//    s16 stepx, stepy;
//    s16 length, extras;
//    s16 incr1, incr2
//    s16 i, c, d;
//
//    x0 = l->x0;
//    y0 = l->y0;
//    x1 = l->x1;
//    y1 = l->y1;
//    dy = y1 - y0;
//    dx = x1 - x0;
//
//    if (dy < 0)
//    {
//        dy = -dy;
//        stepy = -1;
//    }
//    else stepy = 1;
//    if (dx < 0)
//    {
//        dx = -dx;
//        stepx = -1;
//    }
//    else stepx = 1;
//
//    setpix(x0, y0);
//    setpix(x1, y1);
//
//    if (dx > dy)
//    {
//        length = (dx - 1) >> 2;
//        extras = (dx - 1) & 3;
//        incr2 = (dy << 2) - (dx << 1);
//
//        if (incr2 < 0)
//        {
//            c = dy << 1;
//            incr1 = c << 1;
//
//            d = incr1 - dx;
//
//            for (i = 0; i < length; i++)
//            {
//                x0 += stepx;
//                x1 -= stepx;
//
//                if (d < 0)                // Pattern:
//                {
//                    setpix(x0, y0);       //
//                    x0 += stepx;          //
//                    setpix(x0, y0);       //  x o o
//                    setpix(x1, y1);       //
//                    x1 -= stepx;
//                    setpix(x1, y1);
//                    d += incr1;
//                }
//                else
//                {
//                    if (d < c)              // Pattern:
//                    {
//                        setpix(x0, y0);     //
//                        x0 += stepx;        //
//                        y0 += stepy;        //      o
//                        setpix(x0, y0);     //  x o
//                        setpix(x1, y1);     //
//                        x1 -= stepx;
//                        y1 -= stepy;
//                        setpix(x1, y1);
//                    }
//                    else
//                    {
//                        y0 += stepy;
//                        setpix(x0, y0);     // Pattern:
//                        x0 += stepx;        //
//                        setpix(x0, y0);     //    o o
//                        y1 -= stepy;        //  x
//                        setpix(x1, y1);
//                        x1 -= stepx;
//                        setpix(x1, y1);
//                    }
//
//                    d += incr2;
//                }
//            }
//
//            if (extras > 0)
//            {
//                if (d < 0)
//                {
//                    x0 += stepx;
//                    setpix(x0, y0);
//
//                    if (extras > 1)
//                    {
//                        x0 += stepx;
//                        setpix(x0, y0);
//                    }
//
//                    if (extras > 2)
//                    {
//                        x1 -= stepx;
//                        setpix(x1, y1);
//                    }
//                }
//                else if (d < c)
//                {
//                    x0 += stepx;
//                    setpix(x0, y0);
//
//                    if (extras > 1)
//                    {
//                        x0 += stepx;
//                        y0 += stepy;
//                        setpix(x0, y0);
//                    }
//
//                    if (extras > 2)
//                    {
//                        x1 -= stepx;
//                        setpix(x1, y1);
//                    }
//                }
//                else
//                {
//                    x0 += stepx;
//                    y0 += stepy;
//                    setpix(x0, y0);
//
//                    if (extras > 1)
//                    {
//                        x0 += stepx;
//                        setpix(x0, y0);
//                    }
//
//                    if (extras > 2)
//                    {
//                        x1 -= stepx;
//                        y1 -= stepy;
//                        setpix(x1, y1);
//                    }
//                }
//            }
//        }
//        else
//        {
//            c = (dy - dx) << 1;
//            incr1 = c << 1;
//            d =  incr1 + dx;
//
//            for (i = 0; i < length; i++)
//            {
//                x0 += stepx;
//                x1 -= stepx;
//
//                if (d > 0)
//                {
//                    y0 += stepy;
//                    setpix(x0, y0);
//                    x0 += stepx;            // Pattern:
//                    y0 += stepy;            //
//                    setpix(x0, y0);         //      o
//                    y1 -= stepy;            //    o
//                    setpix(x1, y1);         //  x
//                    x1 -= stepx;
//                    y1 -= stepy;
//                    setpix(x1, y1);
//                    d += incr1;
//                }
//                else
//                {
//                    if (d < c)
//                    {
//                        setpix(x0, y0);
//                        x0 += stepx;        // Pattern:
//                        y0 += stepy;        //
//                        setpix(x0, y0);     //      o
//                        setpix(x1, y1);     //  x o
//                        x1 -= stepx;
//                        y1 -= stepy;
//                        setpix(x1, y1);
//                    }
//                    else
//                    {
//                        y0 += stepy;
//                        setpix(x0, y0);     // Pattern:
//                        x0 += stepx;
//                        setpix(x0, y0);     //    o o
//                        y1 -= stepy;        //  x
//                        setpix(x1, y1);
//                        x1 -= stepx;
//                        setpix(x1, y1);
//                    }
//
//                    d += incr2;
//                }
//            }
//
//            if (extras > 0)
//            {
//                if (d > 0)
//                {
//                    x0 += stepx;
//                    y0 += stepy;
//                    setpix(x0, y0);
//
//                    if (extras > 1)
//                    {
//                        x0 += stepx;
//                        y0 += stepy;
//                        setpix(x0, y0);
//                    }
//
//                    if (extras > 2)
//                    {
//                        x1 -= stepx;
//                        y1 -= stepy;
//                        setpix(x1, y1);
//                    }
//                }
//                else if (d < c)
//                {
//                    x0 += stepx;
//                    setpix(x0, y0);
//
//                    if (extras > 1)
//                    {
//                        x0 += stepx;
//                        y0 += stepy;
//                        setpix(x0, y0);
//                    }
//
//                    if (extras > 2)
//                    {
//                        x1 -= stepx;
//                        setpix(x1, y1);
//                    }
//                }
//                else
//                {
//                    x0 += stepx;
//                    y0 += stepy;
//                    setpix(x0, y0);
//
//                    if (extras > 1)
//                    {
//                        x0 += stepx;
//                        setpix(x0, y0);
//                    }
//
//                    if (extras > 2)
//                    {
//                        if (d > c)
//                        {
//                            x1 -= stepx;
//                            y1 -= stepy;
//                            setpix(x1, y1);
//                        }
//                        else
//                        {
//                            x1 -= stepx;
//                            setpix(x1, y1);
//                        }
//                    }
//                }
//            }
//        }
//    }
//    else
//    {
//        length = (dy - 1) >> 2;
//        extras = (dy - 1) & 3;
//        incr2 = (dx << 2) - (dy << 1);
//
//        if (incr2 < 0)
//        {
//            c = dx << 1;
//            incr1 = c << 1;
//            d =  incr1 - dy;
//
//            for (i = 0; i < length; i++)
//            {
//                y0 += stepy;
//                y1 -= stepy;
//
//                if (d < 0)
//                {
//                    setpix(x0, y0);
//                    y0 += stepy;
//                    setpix(x0, y0);
//                    setpix(x1, y1);
//                    y1 -= stepy;
//                    setpix(x1, y1);
//                    d += incr1;
//                }
//                else
//                {
//                    if (d < c)
//                    {
//                        setpix(x0, y0);
//                        x0 += stepx;
//                        y0 += stepy;
//                        setpix(x0, y0);
//                        setpix(x1, y1);
//                        x1 -= stepx;
//                        y1 -= stepy;
//                        setpix(x1, y1);
//                    }
//                    else
//                    {
//                        x0 += stepx;
//                        setpix(x0, y0);
//                        y0 += stepy;
//                        setpix(x0,y0);
//                        x1 -= stepx;
//                        setpix(x1,y1);
//                        y1 -= stepy;
//                        setpix(x1,y1);
//                    }
//
//                    d += incr2;
//                }
//            }
//
//            if (extras > 0)
//            {
//                if (d < 0)
//                {
//                    y0 += stepy;
//                    setpix(x0, y0);
//
//                    if (extras > 1)
//                    {
//                        y0 += stepy;
//                        setpix(x0,y0);
//                    }
//
//                    if (extras > 2)
//                    {
//                        y1 -= stepy;
//                        setpix(x1,y1);
//                    }
//                }
//                else
//                {
//                    if (d < c)
//                    {
//                        y0 += stepy;
//                        setpix(x0,y0);
//
//                        if (extras > 1)
//                        {
//                            x0 += stepx;
//                            y0 += stepy;
//                            setpix(x0,y0);
//                        }
//
//                        if (extras > 2)
//                        {
//                            y1 -= stepy;
//                            setpix(x1,y1);
//                        }
//                    }
//                    else
//                    {
//                        x0 += stepx;
//                        y0 += stepy;
//                        setpix(x0,y0);
//
//                        if (extras > 1)
//                        {
//                            y0 += stepy;
//                            setpix(x0,y0);
//                        }
//                        if (extras > 2)
//                        {
//                            x1 -= stepx;
//                            y1 -= stepy;
//                            setpix(x1,y1);
//                        }
//                    }
//                }
//            }
//        }
//        else
//        {
//            c = (dx - dy) << 1;
//            incr1 = c << 1;
//            d =  incr1 + dy;
//
//            for (i = 0; i < length; i++)
//            {
//                y0 += stepy;
//                y1 -= stepy;
//
//                if (d > 0)
//                {
//                    x0 += stepx;
//                    setpix(x0,y0);
//                    x0 += stepx;
//                    y0 += stepy;
//                    setpix(x0,y0);
//                    x1 -= stepy;
//                    setpix(x1,y1);
//                    x1 -= stepx;
//                    y1 -= stepy;
//                    setpix(x1,y1);
//                    d+=incr1;
//                }
//                else
//                {
//                    if (d < c)
//                    {
//                        setpix(x0,y0);
//                        x0 += stepx;
//                        y0 += stepy;
//                        setpix(x0,y0);
//                        setpix(x1,y1);
//                        x1 -= stepx;
//                        y1 -= stepy;
//                        setpix(x1,y1);
//                    }
//                    else
//                    {
//                        x0 += stepx;
//                        setpix(x0,y0);
//                        y0 += stepy;
//                        setpix(x0,y0);
//                        x1 -= stepy;
//                        setpix(x1,y1);
//                        y1 -= stepy;
//                        setpix(x1,y1);
//                    }
//
//                    d += incr2;
//                }
//            }
//
//            if (extras > 0)
//            {
//                if (d > 0)
//                {
//                    x0 += stepx;
//                    y0 += stepy;
//                    setpix(x0,y0);
//
//                    if (extras > 1)
//                    {
//                        x0 += stepx;
//                        y0 += stepy;
//                        setpix(x0,y0);
//                    }
//
//                    if (extras > 2)
//                    {
//                        x1 -= stepx;
//                        y1 -= stepy;
//                        setpix(x1,y1);
//                    }
//                }
//                else
//                {
//                    if (d < c)
//                    {
//                        y0 += stepy;
//                        setpix(x0,y0);
//
//                        if (extras > 1)
//                        {
//                            x0 += stepx;
//                            y0 += stepy;
//                            setpix(x0,y0);
//                        }
//
//                        if (extras > 2)
//                        {
//                            y1 -= stepy;
//                            setpix(x1,y1);
//                        }
//                    }
//                    else
//                    {
//                        x0 += stepx;
//                        y0 += stepy;
//                        setpix(x0,y0);
//
//                        if (extras > 1)
//                        {
//                            y0 += stepy;
//                            setpix(x0,y0);
//                        }
//
//                        if (extras > 2)
//                        {
//                            if (d > c)
//                            {
//                                x1 -= stepx;
//                                y1 -= stepy;
//                                setpix(x1,y1);
//                            }
//                            else
//                            {
//                                y1 -= stepy;
//                                setpix(x1,y1);
//                            }
//                        }
//                    }
//                }
//            }
//        }
//    }
//}


NO_INLINE void BMP_drawBitmapData(const u8 *image, u16 x, u16 y, u16 w, u16 h, u32 pitch)
{
    // pixel out screen ?
    if ((x >= BMP_WIDTH) || (y >= BMP_HEIGHT))
        return;

    u16 adj_w, adj_h;
    const u8 *src;
    u8 *dst;

    // limit bitmap size if larger than bitmap screen
    if ((w + x) > BMP_WIDTH) adj_w = (BMP_WIDTH - (w + x)) >> 1;
    else adj_w = w >> 1;

    if ((h + y) > BMP_HEIGHT) adj_h = BMP_HEIGHT - (h + y);
    else adj_h = h;

    // prepare source and destination
    src = image;
    dst = BMP_getWritePointer(x, y);

    while(adj_h--)
    {
        memcpy(dst, src, adj_w);
        src += pitch;
        dst += BMP_PITCH;
    }
}

NO_INLINE bool BMP_drawBitmap(const Bitmap *bitmap, u16 x, u16 y, bool loadpal)
{
    u16 w, h;

    // get the image width
    w = bitmap->w;
    // get the image height
    h = bitmap->h;

    // compressed bitmap ?
    if (bitmap->compression != COMPRESSION_NONE)
    {
        Bitmap *b = unpackBitmap(bitmap, NULL);

        if (b == NULL) return FALSE;

        BMP_drawBitmapData(b->image, x, y, w, h, w >> 1);
        MEM_free(b);
    }
    else
        BMP_drawBitmapData((u8*) FAR_SAFE(bitmap->image, mulu(w , h) / 2), x, y, w, h, w >> 1);

    // load the palette
    if (loadpal)
        PAL_setPaletteColors(pal << 4, bitmap->palette, CPU);

    return TRUE;
}

NO_INLINE bool BMP_drawBitmapScaled(const Bitmap *bitmap, u16 x, u16 y, u16 w, u16 h, bool loadpal)
{
    u16 bmp_wb, bmp_h;

    // get the image width in byte
    bmp_wb = bitmap->w >> 1;
    // get the image height
    bmp_h = bitmap->h;

    // compressed bitmap ?
    if (bitmap->compression != COMPRESSION_NONE)
    {
        Bitmap *b = unpackBitmap(bitmap, NULL);

        if (b == NULL) return FALSE;

        BMP_scale(b->image, bmp_wb, bmp_h, bmp_wb, BMP_getWritePointer(x, y), w >> 1, h, BMP_PITCH);
        MEM_free(b);
    }
    else
        BMP_scale(FAR_SAFE(bitmap->image, mulu(w, h) / 2), bmp_wb, bmp_h, bmp_wb, BMP_getWritePointer(x, y), w >> 1, h, BMP_PITCH);

    // load the palette
    if (loadpal)
        PAL_setPaletteColors(pal << 4, bitmap->palette, CPU);

    return TRUE;
}


// works only for 8 bits image (x doubled)
NO_INLINE void BMP_scale(const u8 *src_buf, u16 src_wb, u16 src_h, u16 src_pitch, u8 *dst_buf, u16 dst_wb, u16 dst_h, u16 dst_pitch)
{
    const s32 yd = mulu(divu(src_h, dst_h), src_wb) - src_wb;
    const u16 yr = modu(src_h, dst_h);
    const u32 xd = divu(src_wb, dst_wb);
    const u16 xr = modu(src_wb, dst_wb);

    const u32 adj_src = src_pitch - src_wb;
    const u32 adj_dst = dst_pitch - dst_wb;

    const u8 *src = src_buf;
    u8 *dst = dst_buf;

    u16 y = dst_h;
    s16 ye = 0;

    while(y--)
    {
        u16 x = dst_wb;
        s16 xe = 0;

        while(x--)
        {
            // write pixel
            *dst++ = *src;

            // adjust offset
            src += xd;

            if ((xe += xr) >= (s16) dst_wb)
            {
                xe -= dst_wb;
                src++;
            }
        }

        src += adj_src;
        dst += adj_dst;

        // adjust offset
        src += yd;

        if ((ye += yr) >= (s16) dst_h)
        {
            ye -= dst_h;
            src += src_wb;
        }
    }
}


// internals blank processes
////////////////////////////

void BMP_doVBlankProcess()
{
    // reset phase
    phase = 0;
}

// called on h-interrupt
static HINTERRUPT_CALLBACK hint()
{
    // vborder low
    if (phase == 0)
    {
        const u16 vcnt = GET_VCOUNTER;
        const u16 scrh = screenHeight;
        const u16 vborder = (scrh - BMP_HEIGHT) >> 1;

        // enable VDP
        VDP_setEnable(1);
        // prepare hint to disable VDP and doing blit process
        VDP_setHIntCounter((scrh - vborder) - (VDP_getHIntCounter() + vcnt + 3));
        // update phase
        phase = 1;
    }
    // in active screen
    else if (phase == 1)
    {
        phase = 2;
    }
    // vborder high
    else if (phase == 2)
    {
        // disable VDP
        VDP_setEnable(0);
        // prepare hint to re enable VDP
        VDP_setHIntCounter(((screenHeight - BMP_HEIGHT) >> 1) - 1);
        // update phase
        phase = 3;

        // flip requested or not complete ? --> start / continu flip
        if (state & BMP_STAT_FLIPPING) doFlip();
    }
}


// internals helper methods
///////////////////////////

static NO_INLINE void initTilemap(u16 index)
{
    vu32 *plctrl;
    vu16 *pwdata;
    u16 tile_ind;
    u32 addr_tilemap;
    u16 i, j;

    VDP_setAutoInc(2);

    // calculated
    const u32 offset = BMP_FB_TILEMAP_OFFSET;

    if (index == 0)
    {
        addr_tilemap = BMP_FB0_TILEMAP_BASE + offset;
        tile_ind = TILE_ATTR_FULL(pal, prio, 0, 0, BMP_FB0_TILE_INDEX);
    }
    else
    {
        addr_tilemap = BMP_FB1_TILEMAP_BASE + offset;
        tile_ind = TILE_ATTR_FULL(pal, prio, 0, 0, BMP_FB1_TILE_INDEX);
    }

    // point to vdp port
    plctrl = (u32 *) VDP_CTRL_PORT;
    pwdata = (u16 *) VDP_DATA_PORT;

    i = BMP_TILE_HEIGHT;

    while(i--)
    {
        // set destination address for tilemap
        *plctrl = VDP_WRITE_VRAM_ADDR(addr_tilemap);

        // write tilemap line to VDP
        j = BMP_TILE_WIDTH >> 3;

        while(j--)
        {
            *pwdata = tile_ind++;
            *pwdata = tile_ind++;
            *pwdata = tile_ind++;
            *pwdata = tile_ind++;
            *pwdata = tile_ind++;
            *pwdata = tile_ind++;
            *pwdata = tile_ind++;
            *pwdata = tile_ind++;
        }

        addr_tilemap += BMP_PLANE_WIDTH * 2;
    }
}

static void clearVRAMBuffer(u16 index)
{
    if (index) DMA_doVRamFill(BMP_FB1_ADDR, BMP_PITCH * BMP_HEIGHT, 0, 1);
    else DMA_doVRamFill(BMP_FB0_ADDR, BMP_PITCH * BMP_HEIGHT, 0, 1);
    VDP_waitDMACompletion();
}

static void flipBuffer()
{
    if (READ_IS_FB0)
    {
        bmp_buffer_read = bmp_buffer_1;
        bmp_buffer_write = bmp_buffer_0;
    }
    else
    {
        bmp_buffer_read = bmp_buffer_0;
        bmp_buffer_write = bmp_buffer_1;
    }

    // we want buffer preservation ?
    if (HAS_BUFFERCOPY)
        copyBitmapBuffer(bmp_buffer_read, bmp_buffer_write);
}

static void doFlip()
{
    // better to disable ints here
    SYS_disableInts();

    // copy tile buffer to VRAM
    if (doBlit())
    {
        // at this point copy to VRAM is done !

        // flip displayed buffer
        if (HAS_DOUBLEBUFFER)
        {
            u16 vscr;

            // switch displayed buffer
            if (READ_IS_FB0) vscr = 0;
            else vscr = (BMP_PLANE_HEIGHT * 8) / 2;

            VDP_setVerticalScroll(bmp_plan, vscr);
        }

        // get bitmap state
        u16 s = state;

        // we had a pending flip request ?
        if (s & BMP_STAT_FLIPWAITING)
        {
            // flip buffers
            flipBuffer();
            // clear only pending flag and process new flip
            s &= ~BMP_STAT_FLIPWAITING;
        }
        else
            // flip done
            s &= ~BMP_STAT_FLIPPING;

        // save back bitmap state
        state = s;
    }

    SYS_enableInts();
}

#define TRANSFER(x)                                     \
    *pldata = src[((BMP_PITCH * 0) / 4) + (x)]; \
    *pldata = src[((BMP_PITCH * 1) / 4) + (x)]; \
    *pldata = src[((BMP_PITCH * 2) / 4) + (x)]; \
    *pldata = src[((BMP_PITCH * 3) / 4) + (x)]; \
    *pldata = src[((BMP_PITCH * 4) / 4) + (x)]; \
    *pldata = src[((BMP_PITCH * 5) / 4) + (x)]; \
    *pldata = src[((BMP_PITCH * 6) / 4) + (x)]; \
    *pldata = src[((BMP_PITCH * 7) / 4) + (x)];

#define TRANSFER8(x)                \
    TRANSFER((8 * x) + 0)   \
    TRANSFER((8 * x) + 1)   \
    TRANSFER((8 * x) + 2)   \
    TRANSFER((8 * x) + 3)   \
    TRANSFER((8 * x) + 4)   \
    TRANSFER((8 * x) + 5)   \
    TRANSFER((8 * x) + 6)   \
    TRANSFER((8 * x) + 7)

static NO_INLINE u16 doBlit()
{
    static u16 pos_i;
    vu32 *plctrl;
    vu32 *pldata;
    u32 *src;
    u32 addr_tile;
    u16 i;

    VDP_setAutoInc(2);

    src = (u32 *) bmp_buffer_read;

    if (HAS_DOUBLEBUFFER && READ_IS_FB1)
        addr_tile = BMP_FB1_ADDR;
    else
        addr_tile = BMP_FB0_ADDR;

    /* point to vdp ctrl port */
    plctrl = (u32 *) VDP_CTRL_PORT;

    // previous blit not completed ?
    if (state & BMP_STAT_BLITTING)
    {
        // adjust tile address
        addr_tile += pos_i * BMP_TILE_WIDTH * 32;
        // adjust src pointer
        src += pos_i * (BMP_YPIXPERTILE * (BMP_PITCH / 4));

        // set destination address for tile
        *plctrl = VDP_WRITE_VRAM_ADDR(addr_tile);
    }
    else
    {
        // start blit
        state |= BMP_STAT_BLITTING;
        pos_i = 0;

        // set destination address for tile
        *plctrl = VDP_WRITE_VRAM_ADDR(addr_tile);
    }

    const u16 remain = BMP_TILE_HEIGHT - pos_i;

    if (IS_PAL_SYSTEM)
    {
        if (remain < PAL_TILES_BW) i = remain;
        else i = PAL_TILES_BW;
    }
    else
    {
        if (remain < NTSC_TILES_BW) i = remain;
        else i = NTSC_TILES_BW;
    }

    // save position
    pos_i += i;

    /* point to vdp data port */
    pldata = (u32 *) VDP_DATA_PORT;

    while(i--)
    {
        // send it to VRAM
        TRANSFER8(0)
        TRANSFER8(1)
        TRANSFER8(2)
        TRANSFER8(3)

        src += (8 * BMP_PITCH) / 4;
    }

    // blit not yet done
    if (pos_i < BMP_TILE_HEIGHT) return 0;

    // blit done
    state &= ~BMP_STAT_BLITTING;

    return 1;
}

static void drawLine_old(u16 x1, u16 y1, s16 dx, s16 dy, s16 step_x, s16 step_y, u8 col)
{
    u8 *dst = bmp_buffer_write + (y1 * BMP_PITCH);
    u16 x = x1;

    const u8 mu = 0xF0;
    const u8 md = 0x0F;
    const u8 cu = col & mu;
    const u8 cd = col & md;

    if (dx < dy)
    {
        s16 delta = dy >> 1;
        s16 cnt = dy + 1;

        while(cnt--)
        {
            u8 *d = dst + (x >> 1);

            // write pixel
            if (x & 1) *d = (*d & mu) | cd;
            else *d = (*d & md) | cu;

            dst += step_y;

            if ((delta -= dx) < 0)
            {
                x += step_x;
                delta += dy;
            }
        }
    }
    else
    {
        s16 delta = dx >> 1;
        s16 cnt = dx + 1;

        while(cnt--)
        {
            u8 *d = dst + (x >> 1);

            // write pixel
            if (x & 1) *d = (*d & mu) | cd;
            else *d = (*d & md) | cu;

            x += step_x;

            if ((delta -= dy) < 0)
            {
                dst += step_y;
                delta += dx;
            }
        }
    }
}