/** \file
 * Drawing routines.
 *
 * These are Magic Lantern routines to draw into the BMP LVRAM.
 * They are not derived from DryOS routines.
 */
/*
 * Copyright (C) 2009 Trammell Hudson <hudson+ml@osresearch.net>
 * 
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation; either version 2
 * of the License, or (at your option) any later version.
 * 
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 * 
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the
 * Free Software Foundation, Inc.,
 * 51 Franklin Street, Fifth Floor,
 * Boston, MA  02110-1301, USA.
 */

#include "dryos.h"
#include "bmp.h"
#include "font.h"
#include <stdarg.h>
#include "propvalues.h"

//~ int bmp_enabled = 1;

static int bmp_idle_flag = 0;
void bmp_draw_to_idle(int value) { bmp_idle_flag = value; }

// 0 = copy BMP to idle
// 1 = copy idle to BMP
void bmp_idle_copy(int direction, int fullsize)
{
    uint8_t* real = bmp_vram_real();
    uint8_t* idle = bmp_vram_idle();
    ASSERT(real)
    ASSERT(idle)
    
    if (fullsize)
    {
        if (direction)
            memcpy(BMP_VRAM_START(real), BMP_VRAM_START(idle), BMP_VRAM_SIZE);
        else
            memcpy(BMP_VRAM_START(idle), BMP_VRAM_START(real), BMP_VRAM_SIZE);
    }
    else
    {
#ifdef CONFIG_VXWORKS
        if (direction)
        {
            for (int i = 0; i < 240; i ++)
                memcpy(real+i*BMPPITCH, idle+i*BMPPITCH, 360);
        }
        else
        {
            for (int i = 0; i < 240; i ++)
                memcpy(idle+i*BMPPITCH, real+i*BMPPITCH, 360);
        }
#else
        if (direction)
        {
            for (int i = 0; i < 480; i ++)
                memcpy(real+i*BMPPITCH, idle+i*BMPPITCH, 720);
        }
        else
        {
            for (int i = 0; i < 480; i ++)
                memcpy(idle+i*BMPPITCH, real+i*BMPPITCH, 720);
        }
#endif
    }
}

/*
void bmp_idle_clear()
{
    bzero32(BMP_VRAM_START(bmp_vram_idle()), BMP_VRAM_SIZE);
}*/

/** Returns a pointer to currently selected BMP vram (real or mirror) */
uint8_t * bmp_vram(void)
{
    #ifdef CONFIG_VXWORKS
    set_ml_palette_if_dirty();
    #endif
    uint8_t * bmp_buf = bmp_idle_flag ? bmp_vram_idle() : bmp_vram_real();
    return bmp_buf;
}


#define USE_LUT

static void
_draw_char(
    unsigned    fontspec,
    uint8_t *    bmp_vram_row,
    char        c
)
{
    uint8_t* v = bmp_vram();
    if (bmp_vram_row < v) return;

    unsigned i,j;
    const struct font * const font = fontspec_font( fontspec );

    if (bmp_vram_row >= BMP_VRAM_END(v)) return;

    uint32_t    fg_color    = fontspec_fg( fontspec ) << 24;
    uint32_t    bg_color    = fontspec_bg( fontspec ) << 24;

    // Special case -- fg=bg=0 => white on black
    if( fg_color == 0 && bg_color == 0 )
    {
        fg_color = COLOR_WHITE << 24;
        bg_color = COLOR_BLACK << 24;
    }

    const uint32_t    pitch        = BMPPITCH / 4;
    uint32_t *    front_row    = (uint32_t *) bmp_vram_row;
    
    // boundary checking, don't write past this address
    uint32_t* end = (uint32_t *)(BMP_VRAM_END(v) - font->width);

#ifndef CONFIG_VXWORKS
    //uint32_t flags = cli();
    if ((fontspec & SHADOW_MASK) == 0)
    {
        for( i=0 ; i<font->height ; i++ )
        {
            // Start this scanline
            uint32_t * row = front_row;
            if (row >= end) return;

            // move to the next scanline
            front_row += pitch;

            uint32_t pixels = font->bitmap[ c + (i << 7) ];
            uint8_t pixel;

            for( j=0 ; j<font->width/4 ; j++ )
            {
                uint32_t bmp_pixels = 0;
                for( pixel=0 ; pixel<4 ; pixel++, pixels <<=1 )
                {
                    bmp_pixels >>= 8;
                    bmp_pixels |= (pixels & 0x80000000) ? fg_color : bg_color;
                }

                *(row++) = bmp_pixels;

                // handle characters wider than 32 bits
                //~ if( j == 28/4 )
                    //~ pixels = font->bitmap[ c + ((i+128) << 7) ];
            }
        }
    }
    else // shadowed fonts
    {
        struct font * shadow =
        #ifdef CONFIG_STATIC_FONTS
            (struct font *) font;
        #else
            font == &font_large ? &font_large_shadow :
            font == &font_med ? &font_med_shadow :
            font == &font_small ? &font_small_shadow : 0;
        #endif

        fg_color >>= 24;
        bg_color >>= 24;

        for( i=0 ; i<font->height ; i++ )
        {
            // Start this scanline
            uint32_t * row = front_row;
            row = (uint32_t*)((unsigned)row & ~3); // weird artifacts otherwise
            if (row >= end) return;

            // move to the next scanline
            front_row += pitch;

            uint32_t pixels = font->bitmap[ c + (i << 7) ];
            uint32_t pixels_shadow = shadow->bitmap[ c + (i << 7) ];
            uint8_t pixel;

            for( j=0 ; j<font->width/4 ; j++ )
            {
                uint32_t bmp_pixels = *(row);
                
                for( pixel=0 ; pixel<4 ; pixel++, pixels <<=1, pixels_shadow <<=1 )
                {
                    //~ bmp_pixels >>= 8;
                    //~ bmp_pixels |= (*(row) & 0xFF000000);
                    if (pixels & 0x80000000)
                    {
                        bmp_pixels &= ~(0xFF << (pixel*8));
                        bmp_pixels |= (fg_color << (pixel*8));
                    }
                    if (pixels_shadow & 0x80000000)
                    {
                        bmp_pixels &= ~(0xFF << (pixel*8));
                        bmp_pixels |= (bg_color << (pixel*8));
                    }
                }

                *(row++) = bmp_pixels;
            }
        }
    }

#else // 5DC    
    #define FPIX(i,j) (font->bitmap[ c + ((i) << 7) ] & (1 << (31-(j))))
    //- #define BMPIX(i,j) bmp_vram_row[(i) * BMPPITCH + (j)]
    #define BMPIX(i,j,color) char* p = &bmp_vram_row[((i)/2) * BMPPITCH + (j)/2]; SET_4BIT_PIXEL(p, j, color);
    
    if (font == &font_large) // large fonts look better with line skipping
    {
        for( i = 0 ; i<font->height ; i++ )
        {
            for( j=0 ; j<font->width ; j++ )
            {
                if FPIX(i,j)
                {
                    BMPIX(i,j,fg_color>>24);
                }
                else
                {
                    BMPIX(i,j,bg_color>>24);
                }
            }
        }
    }
    else // smaller fonts look better with all foreground pixels displayed (even if they are a bit bolder than normal)
    {
        for( i = 0 ; i<font->height ; i++ )
        {
            for( j=0 ; j<font->width ; j++ )
            {
                if (!FPIX(i,j))
                {
                    BMPIX(i,j,bg_color>>24);
                }
            }
        }

        for( i = 0 ; i<font->height ; i++ )
        {
            for( j=0 ; j<font->width ; j++ )
            {
                if FPIX(i,j)
                {
                    BMPIX(i,j,fg_color>>24);
                }
            }
        }
    }

#endif
}


void
bmp_puts(
    unsigned        fontspec,
    unsigned *        x,
    unsigned *        y,
    const char *        s
)
{
    ASSERT(x)
    ASSERT(y)
    ASSERT(s)
    
    const uint32_t        pitch = BMPPITCH;
    uint8_t * vram = bmp_vram();
    if( !vram || ((uintptr_t)vram & 1) == 1 )
        return;
    const unsigned initial_x = *x;
#ifdef CONFIG_VXWORKS
    uint8_t * first_row = vram + ((*y)/2) * pitch + ((*x)/2);
#else
    uint8_t * first_row = vram + (*y) * pitch + (*x);
#endif
    uint8_t * row = first_row;

    char c;

    const struct font * const font = fontspec_font( fontspec );

    while( (c = *s++) )
    {
        if( c == '\n' )
        {
            #ifdef CONFIG_VXWORKS
            row = first_row += pitch * font->height/2;
            #else
            row = first_row += pitch * font->height;
            #endif
            (*y) += font->height;
            (*x) = initial_x;
            continue;
        }

        if( c == '\b' )
        {
            (*x) -= font->width;
            continue;
        }

        _draw_char( fontspec, row, c );
        #ifdef CONFIG_VXWORKS
        row += font->width / 2;
        #else
        row += font->width;
        #endif
        (*x) += font->width;
    }

}

void
bmp_puts_w(
    unsigned        fontspec,
    int *        x,
    int *        y,
    int max_chars_per_line,
    const char *        s
)
{
    ASSERT(x)
    ASSERT(y)
    ASSERT(s)

    const uint32_t        pitch = BMPPITCH;
    uint8_t * vram = bmp_vram();
    if( !vram || ((uintptr_t)vram & 1) == 1 )
        return;
    const int initial_x = *x;
    uint8_t * first_row = vram + (*y) * pitch + (*x);
    uint8_t * row = first_row;

    char c;

    const struct font * const font = fontspec_font( fontspec );
    int i = 0;
    while( (c = *s++) )
    {
        if( c == '\n' || i >= max_chars_per_line)
        {
            row = first_row += pitch * font->height;
            (*y) += font->height;
            (*x) = initial_x;
            i = 0;
            if (lv) msleep(1);
            if (c == '\n') continue;
        }

        _draw_char( fontspec, row, c );
        row += font->width;
        (*x) += font->width;
        i++;
    }

}


// thread safe
void
bmp_printf(
           unsigned        fontspec,
           unsigned        x,
           unsigned        y,
           const char *        fmt,
           ...
           )
{
    va_list            ap;
    
    char bmp_printf_buf[128];
    
    va_start( ap, fmt );
    vsnprintf( bmp_printf_buf, sizeof(bmp_printf_buf), fmt, ap );
    va_end( ap );
    
    bmp_puts( fontspec, &x, &y, bmp_printf_buf );
}

// for very large strings only
void
big_bmp_printf(
               unsigned        fontspec,
               unsigned        x,
               unsigned        y,
               const char *        fmt,
               ...
               )
{
    BMP_LOCK(
             va_list            ap;
             
             static char bmp_printf_buf[1024];
             
             va_start( ap, fmt );
             vsnprintf( bmp_printf_buf, sizeof(bmp_printf_buf), fmt, ap );
             va_end( ap );
             
             bmp_puts( fontspec, &x, &y, bmp_printf_buf );
             )
}

#if 0
void
con_printf(
    unsigned        fontspec,
    const char *        fmt,
    ...
)
{
    va_list            ap;
    char            buf[ 256 ];
    static int        x = 0;
    static int        y = 32;

    va_start( ap, fmt );
    vsnprintf( buf, sizeof(buf), fmt, ap );
    va_end( ap );

    const uint32_t        pitch = BMPPITCH;
    uint8_t * vram = bmp_vram();
    if( !vram )
        return;
    uint8_t * first_row = vram + y * pitch + x;
    uint8_t * row = first_row;

    char * s = buf;
    char c;
    const struct font * const font = fontspec_font( fontspec );

    while( (c = *s++) )
    {
        if( c == '\n' )
        {
            row = first_row += pitch * font->height;
            y += font->height;
            x = 0;
            bmp_fill( 0, 0, y, 720, font->height );
        } else {
            _draw_char( fontspec, row, c );
            row += font->width;
            x += font->width;
        }

        if( x > 720 )
        {
            y += font->height;
            x = 0;
            bmp_fill( 0, 0, y, 720, font->height );
        }

        if( y > 480 )
        {
            x = 0;
            y = 32;
            bmp_fill( 0, 0, y, 720, font->height );
        }
    }
}
#endif

#if 1

void
bmp_hexdump(
    unsigned        fontspec,
    unsigned        x,
    unsigned        y,
    const void *        buf,
    int            len
)
{
    if( len == 0 )
        return;

    // Round up
    len = (len + 15) & ~15;

    const uint32_t *    d = (uint32_t*) buf;

    do {
        bmp_printf(
            fontspec,
            x,
            y,
            #ifdef CONFIG_VXWORKS // low-res screen, need to use larger font
            "%08x: %08x %08x %08x %08x : %04x",
            #else
            "%08x: %08x %08x %08x %08x %08x %08x %08x %08x : %04x",
            #endif
            (unsigned) d,
            len >  0 ? MEMX(d+0) : 0,
            len >  4 ? MEMX(d+1) : 0,
            len >  8 ? MEMX(d+2) : 0,
            len > 12 ? MEMX(d+3) : 0,
            #ifndef CONFIG_VXWORKS
            len > 16 ? MEMX(d+4) : 0,
            len > 20 ? MEMX(d+5) : 0,
            len > 24 ? MEMX(d+6) : 0,
            len > 28 ? MEMX(d+7) : 0,
            #endif
            (void*)d - (void*)buf
        );
        y += fontspec_height( fontspec );
        #ifdef CONFIG_VXWORKS
        d += 4;
        len -= 16;
        #else
        d += 8;
        len -= 32;
        #endif
    } while(len > 0);
}
#endif

/** Fill a section of bitmap memory with solid color
 * Only has a four-pixel resolution in X.
 */
#ifdef CONFIG_500D // unoptimized version; drawing too fast gives ERR70
void
bmp_fill(
    uint8_t            color,
    int        x,
    int        y,
    int        w,
    int        h
)
{
    x = COERCE(x, BMP_W_MINUS, BMP_W_PLUS-1);
    y = COERCE(y, BMP_H_MINUS, BMP_H_PLUS-1);
    w = COERCE(w, 0, BMP_W_PLUS-x-1);
    h = COERCE(h, 0, BMP_H_PLUS-y-1);

    const uint32_t word = 0
        | (color << 24)
        | (color << 16)
        | (color <<  8)
        | (color <<  0);

    uint32_t* b = (uint32_t*)bmp_vram();
    
    for (int i = y; i < y+h; i++)
    {
        for (int j = x; j < x+w; j+=4)
        {
            b[BM(j,i)/4] = word;
            asm("nop");
            asm("nop");
            asm("nop");
            asm("nop");
            asm("nop");
            asm("nop");
            asm("nop");
            asm("nop");
            asm("nop");
            asm("nop");
            asm("nop");
            asm("nop");
            asm("nop");
            asm("nop");
            asm("nop");
            asm("nop");
        }
    }
}
#else // all other cameras work just fine with fast code

/* will allow 1-pixel resolution in X and also enables BMP_FILL_HALFALIGN which is 2-pixel resolution */
//#define BMP_FILL_BYTEALIGN

/** Fill a section of bitmap memory with solid color
 * Only has a four-pixel resolution in X.
 */
void
bmp_fill(
    uint8_t            color,
    int        x,
    int        y,
    int        w,
    int        h
)
{
    #ifdef CONFIG_VXWORKS
    color = D2V(color);
    #endif
    
    x = COERCE(x, BMP_W_MINUS, BMP_W_PLUS-1);
    y = COERCE(y, BMP_H_MINUS, BMP_H_PLUS-1);
    w = COERCE(w, 0, BMP_W_PLUS-x-1);
    h = COERCE(h, 0, BMP_H_PLUS-y-1);
   
    const uint16_t halfColor = ((uint16_t)color << 8) | color;
    const uint32_t wordColor = ((uint32_t)halfColor << 16) | halfColor;
    const uint64_t dwordColor = ((uint64_t)wordColor << 32) | wordColor;
   
    uint8_t* b = bmp_vram();
   
    /* pre-align the pixels to speed up fill routine below.
       will draw pixels for byte addresses (if enabled) so the code later can use a optimized dword-store operation.
       if using x positions and widths that are 8-pixel aligned, this code will not get called.
      
       __builtin_expect(exp, result) tells the compiler what we think the result is in most of the cases.
       this will improve performance by not-jumping around, but continously executing code.
       will reduce the perfomance impact of the byte-/word- aligning routines when enabled.
     */
#if defined(BMP_FILL_BYTEALIGN)
    if(unlikely(x & 1))
    {
        for (int posY = y; posY < y+h; posY++)
        {
            *((uint8_t *)&(b[BM(x,posY)])) = color;
        }
        x += 1;
        w -= 1;
    }
    if(unlikely(w & 1))
    {
        w -= 1;
        for (int posY = y; posY < y+h; posY++)
        {
            *((uint8_t *)&(b[BM(x+w,posY)])) = color;
        }
    }
#endif
#if defined(BMP_FILL_BYTEALIGN) || defined(BMP_FILL_HALFALIGN)
    if(unlikely(x & 2))
    {
        for (int posY = y; posY < y+h; posY++)
        {
            *((uint16_t *)&(b[BM(x,posY)])) = halfColor;
        }
        x += 2;
        w -= 2;
    }
    if(unlikely(w & 2))
    {
        w -= 2;
        for (int posY = y; posY < y+h; posY++)
        {
            *((uint16_t *)&(b[BM(x+w,posY)])) = halfColor;
        }
    }
#endif
    /* any 32-bit access necessary? not that complex to handle.
       STRD in the loop later allows 32-bit aligned addresses, so no special treatment needed to make the memory addresses 64 bit aligned.
       unfortunately the compiler does not generate STRDs, but STM.
      
       tell the compiler, is is unlikely that this condition is true, as many paints may start at e.g. 0 and end with e.g. 720
    */
    if(unlikely(w & 4))
    {
        /* fill a column with 32 bit writes */
        for (int posY = y; posY < y+h; posY++)
        {
            *((uint32_t *)&(b[BM(x,posY)])) = wordColor;
        }
        x += 4;
        w -= 4;
    }

    /* not needed if BMP_FILL_BYTEALIGN is set, but doesnt hurt. its just to protect from misaligned accesses */
    x &= ~3;
    w &= ~7;
   
    /* finally fill with optimized 64 bit writes.
       planned to let the compiler generate STRD that uses only 2 cpu cycles plus ADD that needs 1.
       but we only get STMIA. the generated STMIA is also fine, but that uses 4 instead of 3 cpu cycles. still not that bad.
     */
    for (int i = y; i < y+h; i++)
    {
        uint32_t buffer = (uint32_t)&(b[BM(x,i)]);
        uint32_t bufferEnd = (uint32_t)&(b[BM(x+w,i)]);
       
        while (buffer < bufferEnd)
        {
            *((uint64_t*)buffer) = dwordColor;
            buffer += 8;
        }
    }
}
#endif

/** Draw a picture of the BMP color palette. */
void
bmp_draw_palette( void )
{
    uint32_t x, y, msb, lsb;
    const uint32_t height = 30;
    const uint32_t width = 45;

    for( msb=0 ; msb<16; msb++ )
    {
        for( y=0 ; y<height; y++ )
        {
            uint8_t * const row = bmp_vram() + (y + height*msb) * BMPPITCH;

            for( lsb=0 ; lsb<16 ; lsb++ )
            {
                for( x=0 ; x<width ; x++ )
                    row[x+width*lsb] = (msb << 4) | lsb;
            }
        }
    }

    static int written;
    if( !written )
        call("dispcheck");
    written = 1;
    msleep(2000);
}

int retry_count = 0;


size_t
read_file(
    const char *        filename,
    void *            buf,
    size_t            size
)
{
    FILE * file = FIO_Open( filename, O_RDONLY | O_SYNC );
    if( file == INVALID_PTR )
        return -1;
    unsigned rc = FIO_ReadFile( file, buf, size );
    FIO_CloseFile( file );

    if( rc == size )
        return size;

    DebugMsg( DM_MAGIC, 3, "%s: size=%d rc=%d", filename, size, rc );
    return -1;
}


/** Load a BMP file into memory so that it can be drawn onscreen */
struct bmp_file_t *
bmp_load(
    const char *        filename,
    uint32_t         compression // what compression to load the file into. 0: none, 1: RLE8
)
{
    DebugMsg( DM_MAGIC, 3, "bmp_load(%s)", filename);
    unsigned size;
    if( FIO_GetFileSize( filename, &size ) != 0 )
        goto getfilesize_fail;

    DebugMsg( DM_MAGIC, 3, "File '%s' size %d bytes",
        filename,
        size
    );
    
    uint8_t * buf = alloc_dma_memory( size );
    if( !buf )
    {
        DebugMsg( DM_MAGIC, 3, "%s: alloc_dma_memory failed", filename );
        goto malloc_fail;
    }

    size_t i;
    for( i=0 ; i<size; i++ )
        buf[i] = 'A' + i;
    size_t rc = read_file( filename, buf, size );
    if( rc != size )
        goto read_fail;


    struct bmp_file_t * bmp = (struct bmp_file_t *) buf;
    if( bmp->signature != 0x4D42 )
    {
        DebugMsg( DM_MAGIC, 3, "%s: signature %04x", filename, bmp->signature );
        int i;
        for( i=0 ; i<64; i += 16 )
            DebugMsg( DM_MAGIC, 3,
                "%08x: %08x %08x %08x %08x",
                buf + i,
                ((uint32_t*)(buf + i))[0],
                ((uint32_t*)(buf + i))[1],
                ((uint32_t*)(buf + i))[2],
                ((uint32_t*)(buf + i))[3]
            );

        goto signature_fail;
    }

    // Update the offset pointer to point to the image data
    // if it is within bounds
    const unsigned image_offset = (unsigned) bmp->image;
    if( image_offset > size )
    {
        DebugMsg( DM_MAGIC, 3, "%s: size too large: %x > %x", filename, image_offset, size );
        goto offsetsize_fail;
    }

    // Since the read was into uncacheable memory, it will
    // be very slow to access.  Copy it into a cached buffer
    // and release the uncacheable space.

    if (compression==bmp->compression) {
        uint8_t * fast_buf = AllocateMemory( size + 32);
        if( !fast_buf )
            goto fail_buf_copy;
        memcpy(fast_buf, buf, size);
        bmp = (struct bmp_file_t *) fast_buf;
        bmp->image = fast_buf + image_offset;
        free_dma_memory( buf );
        return bmp;
    } else if (compression==1 && bmp->compression==0) { // convert the loaded image into RLE8
        uint32_t size_needed = sizeof(struct bmp_file_t);
        uint8_t* fast_buf;
        uint32_t x = 0;
        uint32_t y = 0;
        uint8_t* gpos;
        uint8_t count = 0;
        uint8_t color = 0;
        bmp->image = buf + image_offset;
        for (y = 0; y < bmp->height; y++) {
            uint8_t* pos = bmp->image + y*bmp->width;
            color = *pos; count = 0;
            for (x = 0; x < bmp->width; x++) {
                if (color==(*pos) && count<255) { count++; } else { color = *pos; count = 1; size_needed += 2; }
                pos++;
            }
            if (count!=0) size_needed += 2; // remaining line
            size_needed += 2; //0000 EOL
        }
        size_needed += 2; //0001 EOF
        fast_buf = AllocateMemory( size_needed );
        if( !fast_buf ) goto fail_buf_copy;
        memcpy(fast_buf, buf, sizeof(struct bmp_file_t));
        gpos = fast_buf + sizeof(struct bmp_file_t);
        for (y = 0; y < bmp->height; y++) {
            uint8_t* pos = bmp->image + y*bmp->width;
            color = *pos; count = 0;
            for (x = 0; x < bmp->width; x++) {
                if (color==(*pos) && count<255) { count++; } else { gpos[0] = count;gpos[1] = color; color = *pos; count = 1; gpos+=2;} pos++;
            }
            if (count!=0) { gpos[0] = count; gpos[1] = color; gpos+=2;} 
            gpos[0] = 0;
            gpos[1] = 0;
            gpos+=2;
        }
        gpos[0] = 0;
        gpos[1] = 1;

        bmp = (struct bmp_file_t *) fast_buf;
         bmp->compression = 1;
        bmp->image = fast_buf + sizeof(struct bmp_file_t);
        bmp->image_size = size_needed;
        free_dma_memory( buf );
        //~ bmp_printf(FONT_SMALL,0,440,"Memory needed %d",size_needed);
        return bmp;
    }

fail_buf_copy:
offsetsize_fail:
signature_fail:
read_fail:
    free_dma_memory( buf );
malloc_fail:
getfilesize_fail:
    DebugMsg( DM_MAGIC, 3, "bmp_load failed");
    return NULL;
}


uint8_t* read_entire_file(const char * filename, int* buf_size)
{
    *buf_size = 0;
    unsigned size;
    if( FIO_GetFileSize( filename, &size ) != 0 )
        goto getfilesize_fail;

    DEBUG("File '%s' size %d bytes", filename, size);

    uint8_t * buf = alloc_dma_memory( size );
    if( !buf )
    {
        DebugMsg( DM_MAGIC, 3, "%s: alloc_dma_memory failed", filename );
        goto malloc_fail;
    }
    size_t rc = read_file( filename, buf, size );
    if( rc != size )
        goto read_fail;

    *buf_size = size;

    return buf;

//~ fail_buf_copy:
read_fail:
    free_dma_memory( buf );
malloc_fail:
getfilesize_fail:
    DEBUG("failed");
    return NULL;
}


void clrscr()
{
    BMP_LOCK( bmp_fill( 0x0, BMP_W_MINUS, BMP_H_MINUS, BMP_TOTAL_WIDTH, BMP_TOTAL_HEIGHT ); )
}

#if 0
// mirror can be NULL
void bmp_draw(struct bmp_file_t * bmp, int x0, int y0, uint8_t* const mirror, int clear)
{
    if (!bmp) return;
    //~ if (!bmp_enabled) return;
    if (bmp->compression!=0) return; // bmp_draw doesn't support RLE yet

    uint8_t * const bvram = bmp_vram();
    if (!bvram) return;
    
    x0 = COERCE(x0, BMP_W_MINUS, BMP_W_PLUS - (int)bmp->width);
    y0 = COERCE(y0, BMP_H_MINUS, BMP_H_PLUS - (int)bmp->height);
    
    uint32_t x,y;
    for( y=0 ; y < bmp->height; y++ )
    {
        uint8_t * const b_row = (uint8_t*)( bvram + (y + y0) * BMPPITCH );
        uint8_t * const m_row = (uint8_t*)( mirror+ (y + y0) * BMPPITCH );
        for( x=0 ; x < bmp->width ; x++ )
        {
            if (clear)
            {
                uint8_t p = b_row[ x + x0 ];
                uint8_t pix = bmp->image[ x + bmp->width * (bmp->height - y - 1) ];
                if (pix && p == pix)
                    b_row[x + x0] = 0;
            }
            else
            {
                if (mirror)
                {
                    uint8_t p = b_row[ x + x0 ];
                    uint8_t m = m_row[ x + x0 ];
                    if (p != 0 && p != 0x14 && p != 0x3 && p != m) continue;
                }
                uint8_t pix = bmp->image[ x + bmp->width * (bmp->height - y - 1) ];
                b_row[x + x0] = pix;
            }
        }
    }
}
#endif
/*
void bmp_draw_scaled(struct bmp_file_t * bmp, int x0, int y0, int xmax, int ymax)
{
    if (!bmp) return;

    uint8_t * const bvram = bmp_vram();
    if (!bvram) return;

    int x,y; // those sweep the original bmp
    int xs,ys; // those sweep the BMP VRAM (and are scaled)
    
    #ifdef USE_LUT 
    // we better don't use AllocateMemory for LUT (Err 70)
    static int16_t lut[960];
    for (xs = x0; xs < (x0 + xmax); xs++)
    {
        lut[xs] = (xs-x0) * bmp->width/xmax;
    }
    #endif

    for( ys = y0 ; ys < (y0 + ymax); ys++ )
    {
        y = (ys-y0)*bmp->height/ymax;
        uint8_t * const b_row = bvram + ys * BMPPITCH;
        for (xs = x0; xs < (x0 + xmax); xs++)
        {
#ifdef USE_LUT
            x = lut[xs];
#else
            x = (xs-x0)*bmp->width/xmax;
#endif
            uint8_t pix = bmp->image[ x + bmp->width * (bmp->height - y - 1) ];
            b_row[ xs ] = pix;
        }
    }
}*/

// this is slow, but is good for a small number of pixels :)
uint8_t bmp_getpixel(int x, int y)
{
    ASSERT(x >= BMP_W_MINUS && x < BMP_W_PLUS)
    ASSERT(y >= BMP_H_MINUS && y < BMP_H_PLUS)

    uint8_t * const bvram = bmp_vram();
    return bvram[x + y * BMPPITCH];
}

/*uint8_t bmp_getpixel_real(int x, int y)
{
    ASSERT(x >= BMP_W_MINUS && x < BMP_W_PLUS)
    ASSERT(y >= BMP_H_MINUS && y < BMP_H_PLUS)

    uint8_t * const bvram = bmp_vram_real();
    return bvram[x + y * BMPPITCH];
}*/

void bmp_putpixel(int x, int y, uint8_t color)
{
    uint8_t * const bvram = bmp_vram();
    if (!bvram) return;
    x = COERCE(x, BMP_W_MINUS, BMP_W_PLUS-1);
    y = COERCE(y, BMP_H_MINUS, BMP_H_PLUS-1);
    
    bmp_putpixel_fast(bvram, x, y, color);
}

void bmp_draw_rect(uint8_t color, int x0, int y0, int w, int h)
{
    uint8_t * const bvram = bmp_vram();
    if (!bvram) return;
    
    draw_line(x0,   y0,   x0+w,   y0, color);
    draw_line(x0+w, y0,   x0+w, y0+h, color);
    draw_line(x0+w, y0+h,   x0, y0+h, color);
    draw_line(x0,   y0,     x0, y0+h, color);
}

int _bmp_draw_should_stop = 0;
void bmp_draw_request_stop() { _bmp_draw_should_stop = 1; }

#ifdef CONFIG_VXWORKS

/** converting dryos palette to vxworks one */
char bmp_lut[80] = { 
    0x00, 0xff, 0x99, 0x88, 0x77, 0x44, 0x22, 0x22, 0x11, 0x33, 0xDD, 0x33, 0x11, 0x33, 0x55, 0x66, 
    0x55, 0x77, 0x22, 0x77, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 
    0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x99, 0x99, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xBB,
    0xBB, 0xBB, 0xBB, 0xBB, 0xBB, 0xBB, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xDD, 0xDD, 0xDD,
    0xDD, 0xDD, 0xDD, 0xDD, 0xEE, 0xEE, 0xEE, 0xEE, 0xEE, 0xEE, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF
};

void set_ml_palette()
{
    if (!DISPLAY_IS_ON) return;
    
    int palette[16] = {
        0x00870000, // transparent
        0x0000FFFF, // 1 - red
        0x00CC00FF, // 2 - green
        0xFF0000FF, // 3 - blue
        0xFFFF00FF, // 4 - cyan
        0xFF00FFFF, // 5 - magenta
        0x00FFFFFF, // 6 - yellow
        0x0090FFFF, // 7 - orange
        0x00000080, // 8 - transparent black
        0x000000FF, // 9 - black
        0x1C1C1CFF, // A - gray 1
        0x404040FF, // B - gray 2
        0x7F7F7FFF, // C - gray 3
        0xAAAAAAFF, // D - gray 4
        0xD4D4D4FF, // E - gray 5
        0xFFFFFFFF  // F - white
    };
    
    extern int RGB_Palette[];
    extern int LCD_Palette[];
    extern int PB_Palette[];

    if (0) // convert from RGB to PB with Canon code, write result to a file
    {      // if you change RGB palette, run this first to get the PB equivalent (comment out BmpDDev semaphores first)
        NotifyBox(10000, "%x ", PB_Palette);
        SetRGBPaletteToDisplayDevice(palette); // problem: this is unsafe to call (race condition with Canon code)
        FILE* f = FIO_CreateFileEx(CARD_DRIVE"pb.log");
        for (int i = 0; i < 16; i++)
            my_fprintf(f, "0x%08x, ", PB_Palette[i*3 + 2]);
        FIO_CloseFile(f);
    }
    else // use pre-computed PB palette (just send it to digic)
    {
        int palette_pb[16] = {0x00fc0000, 0x0346de7f, 0x036dcba1, 0x031a66ea, 0x03a42280, 0x03604377, 0x03cf9a16, 0x0393b94b, 0x00000000, 0x03000000, 0x03190000, 0x033a0000, 0x03750000, 0x039c0000, 0x03c30000, 0x03eb0000};

        for (int i = 0; i < 16; i++)
        {
            EngDrvOut(0xC0F14080 + i*4, palette_pb[i]);
        }
        EngDrvOut(0xC0F14078, 1);
    }
}

void set_ml_palette_if_dirty()
{
    if (!DISPLAY_IS_ON) return;
    extern int PB_Palette[];
    if (PB_Palette[15*3+2] == 0x03eb0000) return;

    BmpDDev_take_semaphore();
    set_ml_palette();
    PB_Palette[15*3+2] = 0x03eb0000;
    BmpDDev_give_semaphore();
}

void restore_canon_palette()
{
    // unsafe
    //~ SetRGBPaletteToDisplayDevice(orig_palette);
}

/*
void guess_palette()
{
    // let's try something else: match DryOs palette to VxWorks's on the fly

    static int ref_r[80] = {254, 234, 0, 0, 163, 31, 0, 1, 234, 0, 185, 27, 200, 0, 201, 209, 232, 216, 0, 231, 232, 232, 232, 232, 232, 232, 232, 232, 232, 232, 232, 232, 232, 232, 232, 232, 232, 231, 9, 18, 27, 36, 41, 46, 50, 55, 59, 64, 69, 73, 82, 92, 101, 109, 117, 119, 124, 129, 133, 138, 142, 147, 152, 156, 161, 165, 170, 175, 179, 184, 188, 193, 198, 202, 207, 211, 216, 221, 225, 229};
    static int ref_g[80] = {254, 235, 0, 0, 56, 187, 153, 172, 0, 66, 186, 34, 0, 0, 0, 191, 0, 94, 62, 109, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 9, 18, 27, 36, 41, 46, 50, 55, 59, 64, 69, 73, 82, 92, 101, 110, 117, 119, 124, 129, 133, 138, 142, 147, 152, 156, 161, 165, 170, 175, 178, 184, 188, 192, 198, 202, 206, 210, 216, 221, 225, 230};
    static int ref_b[80] = {255, 235, 0, 0, 0, 216, 0, 1, 1, 211, 139, 126, 0, 168, 154, 0, 231, 76, 75, 0, 232, 232, 232, 232, 232, 232, 232, 232, 232, 232, 232, 232, 232, 232, 232, 232, 232, 232, 9, 18, 27, 36, 41, 46, 50, 55, 59, 64, 69, 73, 82, 92, 101, 109, 117, 119, 124, 129, 133, 138, 142, 147, 152, 156, 161, 165, 170, 174, 178, 184, 188, 193, 198, 202, 207, 211, 216, 221, 224, 229};

    extern int RGB_Palette[];
    for (int j = 1; j < 80; j++)
    {
        int r = ref_r[j];
        int g = ref_g[j];
        int b = ref_b[j];
        int dr = g-r;
        int db = g-b;

        int em = 10000;
        for (int i = 1; i < 16; i++)
        {
            int p = RGB_Palette[i];
            int R = (p >> 8) & 0xFF;
            int G = (p >> 16) & 0xFF;
            int B = (p >> 24) & 0xFF;
            int DR = G-R;
            int DB = G-B;
            
            int d = (r-R)*(r-R) + (g-G)*(g-G) + (b-B)*(b-B) + (dr-DR)*(dr-DR) + (db-DB)*(db-DB);
            if (d < em)
            {
                bmp_lut[j] = i | (i<<4);
                em = d;
            }
        }
    }
}
*/

int D2V(unsigned color) { return bmp_lut[MIN(color & 0xFF,79)]; }

#endif

void bmp_draw_scaled_ex(struct bmp_file_t * bmp, int x0, int y0, int w, int h, uint8_t* const mirror)
{
    if (!bmp) return;
    
    _bmp_draw_should_stop = 0;
    //~ if (!bmp_enabled) return;
    
    x0 = COERCE(x0, BMP_W_MINUS, BMP_W_PLUS-1);
    y0 = COERCE(y0, BMP_H_MINUS, BMP_H_PLUS-1);

    w = COERCE(w, 0, BMP_W_PLUS-x0-1);
    h = COERCE(h, 0, BMP_H_PLUS-y0-1);

    uint8_t * const bvram = bmp_vram();
    if (!bvram) return;

    int x,y; // those sweep the original bmp
    int xs,ys; // those sweep the BMP VRAM (and are scaled)
    
    if (bmp->compression == 0) {
#ifdef USE_LUT 
        // we better don't use AllocateMemory for LUT (Err 70)
        static int16_t lut[960];
        for (xs = x0; xs < (x0 + w); xs++)
        {
            lut[xs-BMP_W_MINUS] = (xs-x0) * bmp->width/w;
        }
#endif

        for( ys = y0 ; ys < (y0 + h); ys++ )
        {
            if (_bmp_draw_should_stop) return;
            y = (ys-y0)*bmp->height/h;
            #ifdef CONFIG_VXWORKS
            uint8_t * const b_row = bvram + ys/2 * BMPPITCH;
            #else
            uint8_t * const b_row = bvram + ys * BMPPITCH;
            #endif
            uint8_t * const m_row = (uint8_t*)( mirror + ys * BMPPITCH );
            for (xs = x0; xs < (x0 + w); xs++)
            {
#ifdef USE_LUT
                x = lut[xs-BMP_W_MINUS];
#else
                x = (xs-x0)*bmp->width/w;
#endif

                uint8_t pix = bmp->image[ x + bmp->width * (bmp->height - y - 1) ];
                if (mirror)
                {
                    if (pix) m_row[ xs ] = pix | 0x80;
                    uint8_t p = b_row[ xs ];
                    uint8_t m = m_row[ xs ];
                    if (p != 0 && p != 0x14 && p != 0x3 && p != m) continue;
                    if ((p == 0x14 || p == 0x3) && pix == 0) continue;
                }
                #ifdef CONFIG_VXWORKS
                char* p = &b_row[ xs/2 ]; 
                SET_4BIT_PIXEL(p, xs, pix);
                #else
                b_row[ xs ] = pix;
                #endif
            }
        }
    } else if (bmp->compression == 1) {
        uint8_t * bmp_line = bmp->image; // store the start of the line
        int bmp_y_pos = bmp->height-1; // store the line number
        for( ys = y0 + h - 1 ; ys >= y0; ys-- )
        {
            if (_bmp_draw_should_stop) return;
            y = (ys-y0)*bmp->height/h;
            int ysc = COERCE(ys, BMP_H_MINUS, BMP_H_PLUS);
            #ifdef CONFIG_VXWORKS
            uint8_t * const b_row =              bvram + ysc/2 * BMPPITCH;
            #else
            uint8_t * const b_row =              bvram + ysc * BMPPITCH;
            #endif
            uint8_t * const m_row = (uint8_t*)( mirror + ysc * BMPPITCH );
            while (y != bmp_y_pos) {
                // search for the next line
                if (bmp_line[0]!=0) { bmp_line += 2; } else
                if (bmp_line[1]==0) { bmp_line += 2; bmp_y_pos--; } else
                if (bmp_line[1]==1) return;
                if (y<0) return;
                if (bmp_line>(uint8_t*)(bmp+bmp->image_size)) return;
            }
            uint8_t* bmp_col = bmp_line; // store the actual position inside the bitmap
            int bmp_x_pos_start = 0; // store the start of the line
            int bmp_x_pos_end = bmp_col[0]; // store the end of the line
            uint8_t bmp_color = bmp_col[1]; // store the actual color to use
            for (xs = x0; xs < (x0 + w); xs++)
            {
                x = COERCE((int)((xs-x0)*bmp->width/w), BMP_W_MINUS, BMP_W_PLUS-1);
                while (x>=bmp_x_pos_end) {
                    // skip to this position
                    if (bmp_col>(uint8_t*)(bmp+bmp->image_size)) break;
                    if (bmp_col[0]==0) break;
                    bmp_col+=2;
                    if (bmp_col>(uint8_t*)(bmp+bmp->image_size)) break;
                    if (bmp_col[0]==0) break;
                    bmp_x_pos_start = bmp_x_pos_end;
                    bmp_x_pos_end = bmp_x_pos_start + bmp_col[0];
                    bmp_color = bmp_col[1];
                }
                if (mirror)
                {
                    if (bmp_color) m_row[ xs ] = bmp_color | 0x80;
                    uint8_t p = b_row[ xs ];
                    uint8_t m = m_row[ xs ];
                    if (p != 0 && p != 0x14 && p != 0x3 && p != m) continue;
                    if ((p == 0x14 || p == 0x3) && bmp_color == 0) continue;
                }
                #ifdef CONFIG_VXWORKS
                char* p = &b_row[ xs/2 ]; 
                SET_4BIT_PIXEL(p, xs, bmp_color);
                #else
                b_row[ xs ] = bmp_color;
                #endif
            }
        }

    }
}

// built-in fonts found by Pel
// http://groups.google.com/group/ml-devel/browse_thread/thread/aec4c80eef1cdd6a
// http://chdk.setepontos.com/index.php?topic=6204.0

// quick sanity test
int bfnt_ok()
{
    int* codes = (int*) BFNT_CHAR_CODES;
    int i;
    
    for (i = 0; i < 20; i++) 
        if (codes[i] != 0x20+i) return 0;

    int* off = (int*) BFNT_BITMAP_OFFSET;
    if (off[0] != 0) return 0;
    
    for (i = 1; i < 20; i++) 
        if (off[i] <= off[i-1]) return 0;
    
    return 1;
}

// are all char codes in ascending order, for binary search?
uint8_t* bfnt_find_char(int code)
{
    int n = (BFNT_BITMAP_OFFSET - BFNT_CHAR_CODES) / 4;
    int* codes = (int*) BFNT_CHAR_CODES;
    int* off = (int*) BFNT_BITMAP_OFFSET;
    
    if (code <= 'z') return (uint8_t*) (BFNT_BITMAP_DATA + off[code - 0x20]);
    
    int i;
    for (i = 0; i < n; i++)
        if (codes[i] == code)
            return (uint8_t*) (BFNT_BITMAP_DATA + off[i]);
    return 0;
}

// returns width
int bfnt_draw_char(int c, int px, int py, int fg, int bg)
{
    if (!bfnt_ok())
    {
        bmp_printf(FONT_SMALL, 0, 0, "font addr bad");
        return 0;
    }

    uint8_t * const bvram = bmp_vram();
    
    uint16_t* chardata = (uint16_t*) bfnt_find_char(c);
    if (!chardata) return 0;
    uint8_t* buff = (uint8_t*)(chardata + 5);
    int ptr = 0;
    
    int cw  = chardata[0]; // the stored bitmap width
    int ch  = chardata[1]; // the stored bitmap height
    int crw = chardata[2]; // the displayed character width
    int xo  = chardata[3]; // X offset for displaying the bitmap
    int yo  = chardata[4]; // Y offset for displaying the bitmap
    int bb    = cw / 8 + (cw % 8 == 0 ? 0 : 1); // calculate the byte number per line
    
    //~ bmp_printf(FONT_SMALL, 0, 0, "%x %d %d %d %d %d %d", chardata, cw, ch, crw, xo, yo, bb);
    
    if (crw+xo > 100) return 0;
    if (ch+yo > 50) return 0;
    
    //~ bmp_fill(bg, px, py, crw+xo+3, 40);
    
    int i,j,k;
    for (i = 0; i < ch; i++)
    {
        for (j = 0; j < bb; j++)
        {
            for (k = 0; k < 8; k++)
            {
                if (j*8 + k < cw)
                {
                    if ((buff[ptr+j] & (1 << (7-k)))) 
                        #ifdef CONFIG_VXWORKS
                        bmp_putpixel_fast(bvram, px+j*8+k+xo, py + (i+yo)*2, fg);
                        #else
                        bmp_putpixel_fast(bvram, px+j*8+k+xo, py+i+yo, fg);
                        #endif
                }
            }
        }
        ptr += bb;
    }
    return crw;
}

/*
int bfnt_draw_char_half(int c, int px, int py, int fg, int bg, int g1, int g2)
{
    if (!bfnt_ok())
    {
        bmp_printf(FONT_SMALL, 0, 0, "font addr bad");
        return 0;
    }
    
    uint16_t* chardata = bfnt_find_char(c);
    if (!chardata) return 0;
    uint8_t* buff = chardata + 5;
    int ptr = 0;
    
    unsigned int cw  = chardata[0]; // the stored bitmap width
    unsigned int ch  = chardata[1]; // the stored bitmap height
    unsigned int crw = chardata[2]; // the displayed character width
    unsigned int xo  = chardata[3]; // X offset for displaying the bitmap
    unsigned int yo  = chardata[4]; // Y offset for displaying the bitmap
    unsigned int bb    = cw / 8 + (cw % 8 == 0 ? 0 : 1); // calculate the byte number per line
    
    //~ bmp_printf(FONT_SMALL, 0, 0, "%x %d %d %d %d %d %d", chardata, cw, ch, crw, xo, yo, bb);
    
    if (cw > 100) return 0;
    if (ch > 50) return 0;
    
    static uint8_t tmp[50][25];

    int i,j,k;

    for (i = 0; i < 50; i++)
        for (j = 0; j < 25; j++)
            tmp[i][j] = 0;
    
    for (i = 0; i < ch; i++)
    {
        for (j = 0; j < bb; j++)
        {
            for (k = 0; k < 8; k++)
            {
                if (j*8 + k < cw)
                {
                    if ((buff[ptr+j] & (1 << (7-k)))) 
                        tmp[COERCE((j*8+k)>>1, 0, 49)][COERCE(i>>1, 0, 24)] ++;
                }
            }
        }
        ptr += bb;
    }

    bmp_fill(bg, px+3, py, crw/2+xo/2+3, 20);

    for (i = 0; i <= cw/2; i++)
    {
        for (j = 0; j <= ch/2; j++)
        {
            int c = COLOR_RED;
            switch (tmp[i][j])
            {
                case 0:
                case 1:
                case 2:
                case 3:
                    c = bg;
                    break;
                case 4:
                    c = fg;
                    break;
            }
            if (c != bg) bmp_putpixel(px+xo/2+i, py+yo/2+j, c);
        }
    }

    return crw>>1;
}*/

void bfnt_puts(char* s, int x, int y, int fg, int bg)
{
    while (*s)
    {
        x += bfnt_draw_char(*s, x, y, fg, bg);
        s++;
    }
}

/*
void bfnt_puts_utf8(int* s, int x, int y, int fg, int bg)
{
    while (*s)
    {
        x += bfnt_draw_char(*s, x, y, fg, bg);
        s++;
    }
}*/

#if 1
void
bfnt_test()
{
    while(1)
    {
        beep();
        canon_gui_disable_front_buffer();
        int* codes = (int*) BFNT_CHAR_CODES;
        static int c = 0;
        c = (BFNT_BITMAP_OFFSET - BFNT_CHAR_CODES) / 4 - 50;
        for (int i = 0; i < 5; i++)
        {
            for (int j = 0; j < 10; j++)
            {
                bfnt_draw_char(codes[c], j*70, i*80+20, COLOR_WHITE, COLOR_BLACK);
                bmp_printf(FONT_MED, j*70, i*80, "%x", codes[c]);
                c++;
            }
        }
        msleep(2000);
        clrscr();
    }
}
#endif

void bmp_flip(uint8_t* dst, uint8_t* src, int voffset)
{
    ASSERT(src)
    ASSERT(dst)
    if (!dst) return;
    int i,j;
    
    int H_LO = hdmi_code == 5 ? BMP_H_MINUS : 0;
    int H_HI = hdmi_code == 5 ? BMP_H_PLUS : 480;

    int W_LO = hdmi_code == 5 ? BMP_W_MINUS : 0;
    int W_HI = hdmi_code == 5 ? BMP_W_PLUS : 720;
    
    for (i = H_LO; i < H_HI; i++) // -30 ... 510
    {
        int i_mod = H_HI + H_LO - i + voffset - 1; // 510 ... -30
        while (i_mod < H_LO) i_mod += (H_HI - H_LO);
        while (i_mod >= H_HI) i_mod -= (H_HI - H_LO);
        
        for (j = W_LO; j < W_HI; j++) // -120 ... 840
        {
            dst[BM(j,i)] = src[BM(W_HI + W_LO - j, i_mod)]; // 840 ... -120
        }
    }
}

void bmp_flip_ex(uint8_t* dst, uint8_t* src, uint8_t* mirror, int voffset)
{
    ASSERT(src)
    ASSERT(dst)
    ASSERT(mirror)
    if (!dst) return;
    int i,j;
    
    int H_LO = hdmi_code == 5 ? BMP_H_MINUS : 0;
    int H_HI = hdmi_code == 5 ? BMP_H_PLUS : 480;

    int W_LO = hdmi_code == 5 ? BMP_W_MINUS : 0;
    int W_HI = hdmi_code == 5 ? BMP_W_PLUS : 720;
    
    for (i = H_LO; i < H_HI; i++) // -30 ... 510
    {
        int i_mod = H_HI + H_LO - i + voffset - 1; // 510 ... -30
        while (i_mod < H_LO) i_mod += (H_HI - H_LO);
        while (i_mod >= H_HI) i_mod -= (H_HI - H_LO);
        
        for (j = W_LO; j < W_HI; j++) // -120 ... 840
        {
            uint8_t m = mirror[BM(j,i)];
            uint8_t b = dst[BM(j,i)];
            if (m && (m == b) && !(m & 0x80)) { /* zebras here, do nothing */ }
            else dst[BM(j,i)] = src[BM(W_HI + W_LO - j, i_mod)]; // 840 ... -120
        }
    }
}

static void bmp_dim_line(void* dest, size_t n, int even)
{
    ASSERT(dest);

    int* dst = (int*) dest;
    int* end = (int*)(dest + n);
    if (even)
    {
        for( ; dst < end; dst++)
#ifdef CONFIG_VXWORKS
            *dst = (*dst & 0x0F0F0F0F) | 0x90909090;
#else
            *dst = (*dst & 0x00FF00FF) | 0x02000200;
#endif
    }
    else
    {
        for( ; dst < end; dst++)
#ifdef CONFIG_VXWORKS
            *dst = (*dst & 0xF0F0F0F0) | 0x09090909;
#else
            *dst = (*dst & 0xFF00FF00) | 0x00020002;
#endif
    }
}

// this is only used in menu, so only cover the 720x480 part
void bmp_dim()
{
    uint32_t* b = (uint32_t *)bmp_vram();
    ASSERT(b);
    if (!b) return;
    int i;
    //int j;
#ifdef CONFIG_VXWORKS
    for (i = 0; i < 480; i+=2)
    {
        bmp_dim_line(&b[BM(0,i)/4], 360, (i/2)%2);
    }
#else
    for (i = 0; i < 480; i ++)
    {
        bmp_dim_line(&b[BM(0,i)/4], 720, i%2);
    }
#endif
}

void bmp_make_semitransparent()
{
    uint8_t* b = (uint8_t *)bmp_vram();
    ASSERT(b);
    if (!b) return;
    int i,j;
    for (i = BMP_H_MINUS; i < BMP_H_PLUS; i ++)
    {
        for (j = BMP_W_MINUS; j < BMP_W_PLUS; j ++)
        {
            if (b[BM(j,i)] == COLOR_BLACK || b[BM(j,i)] == 40)
                b[BM(j,i)] = COLOR_BG;
        }
    }
}

void * bmp_lock = 0;

void bmp_init(void* unused)
{
    bmp_lock = CreateRecursiveLock(0);
    ASSERT(bmp_lock)
    bvram_mirror_init();
    update_vram_params();
}

INIT_FUNC(__FILE__, bmp_init);