#ifdef SH7722_DEBUG_BLT
#define DIRECT_ENABLE_DEBUG
#endif


#include <config.h>
#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>

#include <sys/mman.h>
#include <fcntl.h>
#include <sys/ioctl.h>
#include <malloc.h>
#include <errno.h>

#include <asm/types.h>

#include <directfb.h>

#include <direct/debug.h>
#include <direct/mem.h>
#include <direct/memcpy.h>
#include <direct/messages.h>
#include <direct/util.h>

#include <core/coredefs.h>
#include <core/coretypes.h>

#include <core/state.h>
#include <core/gfxcard.h>
#include <core/surface.h>
#include <core/surface_buffer.h>

#include <gfx/convert.h>

#include "sh7722.h"
#include "sh7722_blt.h"


D_DEBUG_DOMAIN( SH7722_BLT, "SH7722/BLT", "Renesas SH7722 Drawing Engine" );

D_DEBUG_DOMAIN( SH7722_StartStop, "SH7722/StartStop", "Renesas SH7722 Drawing Start/Stop" );

/*
 * State validation flags.
 *
 * There's no prefix because of the macros below.
 */
enum {
     DEST         = 0x00000001,
     CLIP         = 0x00000002,
     DEST_CLIP    = 0x00000003,

     SOURCE       = 0x00000010,
     MASK         = 0x00000020,

     COLOR        = 0x00000100,

     COLOR_KEY    = 0x00001000,
     COLOR_CHANGE = 0x00002000,

     BLENDING     = 0x00010000,

     MATRIX       = 0x00100000,

     BLIT_OP      = 0x01000000,

     ALL          = 0x01113133
};

/*
 * Map pixel formats.
 */
static const int pixel_formats[DFB_NUM_PIXELFORMATS] = {
     3,   /*   DSPF_ARGB1555  =  0 */
     1,   /*   DSPF_RGB16     =  1 */
     7,   /*   DSPF_RGB24     =  2 */
     0,   /*   DSPF_RGB32     =  3 */
     0,   /*   DSPF_ARGB      =  4 */
    10,   /*   DSPF_A8        =  5 */
    -1,   /*   DSPF_YUY2      =  6 */
    -1,   /*   DSPF_RGB332    =  7 */
    -1,   /*   DSPF_UYVY      =  8 */
    -1,   /*   DSPF_I420      =  9 */
    -1,   /*   DSPF_YV12      = 10 */
    -1,   /*   DSPF_LUT8      = 11 */
    -1,   /*   DSPF_ALUT44    = 12 */
    -1,   /*   DSPF_AiRGB     = 13 */
     8,   /*   DSPF_A1        = 14 */
    -1,   /*   DSPF_NV12      = 15 */
    -1,   /*   DSPF_NV16      = 16 */
    -1,   /*   DSPF_ARGB2554  = 17 */
     4,   /*   DSPF_ARGB4444  = 18 */
    -1,   /*   DSPF_NV21      = 19 */
    -1,   /*   DSPF_AYUV      = 20 */
    -1,   /*   DSPF_A4        = 21 */
    -1,   /*   DSPF_ARGB1666  = 22 */
    -1,   /*   DSPF_ARGB6666  = 23 */
     6,   /*   DSPF_RGB18     = 24 */
    -1,   /*   DSPF_LUT2      = 25 */
     4,   /*   DSPF_RGB444    = 26 */
     3,   /*   DSPF_RGB555    = 27 */
};

/*
 * State handling macros.
 */

#define SH7722_VALIDATE(flags)          do { sdev->v_flags |=  (flags); } while (0)
#define SH7722_INVALIDATE(flags)        do { sdev->v_flags &= ~(flags); } while (0)

#define SH7722_CHECK_VALIDATE(flag)     do {                                                        \
                                             if ((sdev->v_flags & flag) != flag)                    \
                                                  sh7722_validate_##flag( sdrv, sdev, state );      \
                                        } while (0)

#define DUMP_INFO() D_DEBUG_AT( SH7722_BLT, "  -> %srunning, hw %d-%d, next %d-%d - %svalid\n",     \
                                            sdrv->gfx_shared->hw_running ? "" : "not ",             \
                                            sdrv->gfx_shared->hw_start,                             \
                                            sdrv->gfx_shared->hw_end,                               \
                                            sdrv->gfx_shared->next_start,                           \
                                            sdrv->gfx_shared->next_end,                             \
                                            sdrv->gfx_shared->next_valid ? "" : "not " );

#define AA_COEF     133

/**********************************************************************************************************************/

static bool sh7722FillRectangle        ( void *drv, void *dev, DFBRectangle *rect );
static bool sh7722FillRectangleMatrixAA( void *drv, void *dev, DFBRectangle *rect );

static bool sh7722DrawRectangle        ( void *drv, void *dev, DFBRectangle *rect );
static bool sh7722DrawRectangleMatrixAA( void *drv, void *dev, DFBRectangle *rect );

static bool sh7722DrawLine           ( void *drv, void *dev, DFBRegion *line );
static bool sh7722DrawLineMatrix     ( void *drv, void *dev, DFBRegion *line );
static bool sh7722DrawLineAA         ( void *drv, void *dev, DFBRegion *line );

/**********************************************************************************************************************/

static inline bool
check_blend_functions( const CardState *state )
{
     switch (state->src_blend) {
          case DSBF_ZERO:
          case DSBF_ONE:
          case DSBF_DESTCOLOR:
          case DSBF_INVDESTCOLOR:
          case DSBF_SRCALPHA:
          case DSBF_INVSRCALPHA:
          case DSBF_DESTALPHA:
          case DSBF_INVDESTALPHA:
               return true;

          default:
               break;
     }
     switch (state->dst_blend) {
          case DSBF_ZERO:
          case DSBF_ONE:
          case DSBF_SRCCOLOR:
          case DSBF_INVSRCCOLOR:
          case DSBF_SRCALPHA:
          case DSBF_INVSRCALPHA:
          case DSBF_DESTALPHA:
          case DSBF_INVDESTALPHA:
               return true;

          default:
               break;
     }

     return false;
}

/**********************************************************************************************************************/

static inline bool
start_hardware( SH7722DriverData *sdrv )
{
     SH772xGfxSharedArea *shared = sdrv->gfx_shared;

     D_DEBUG_AT( SH7722_BLT, "%s()\n", __FUNCTION__ );

     DUMP_INFO();

     if (shared->hw_running || !shared->next_valid || shared->next_end == shared->next_start)
          return false;

     shared->hw_running = true;
     shared->hw_start   = shared->next_start;
     shared->hw_end     = shared->next_end;

     shared->next_start = shared->next_end = (shared->hw_end + 1 + 3) & ~3;
     shared->next_valid = false;

     shared->num_words += shared->hw_end - shared->hw_start;

     shared->num_starts++;

     DUMP_INFO();

     D_ASSERT( shared->buffer[shared->hw_end] == 0xF0000000 );

     SH7722_TDG_SETREG32( sdrv, BEM_HC_DMA_ADR,   shared->buffer_phys + shared->hw_start*4 );
     SH7722_TDG_SETREG32( sdrv, BEM_HC_DMA_START, 1 );

     return true;
}

__attribute__((noinline))
static void
flush_prepared( SH7722DriverData *sdrv )
{
     SH772xGfxSharedArea *shared  = sdrv->gfx_shared;
     unsigned int         timeout = 2;

     D_DEBUG_AT( SH7722_BLT, "%s()\n", __FUNCTION__ );

     DUMP_INFO();

     D_ASSERT( sdrv->prep_num < SH772xGFX_BUFFER_WORDS );
     D_ASSERT( sdrv->prep_num <= D_ARRAY_SIZE(sdrv->prep_buf) );

     /* Something prepared? */
     while (sdrv->prep_num) {
          int next_end;

          /* Mark shared information as invalid. From this point on the interrupt handler
           * will not continue with the next block, and we'll start the hardware ourself. */
          shared->next_valid = false;

          /* Check if there's enough space at the end.
           * Wait until hardware has started next block before it gets too big. */
          if (shared->next_end + sdrv->prep_num >= SH772xGFX_BUFFER_WORDS ||
              shared->next_end - shared->next_start >= SH772xGFX_BUFFER_WORDS/4)
          {
               /* If there's no next block waiting, start at the beginning. */
               if (shared->next_start == shared->next_end)
                    shared->next_start = shared->next_end = 0;
               else {
                    D_ASSERT( shared->buffer[shared->hw_end] == 0xF0000000 );

                    /* Mark area as valid again. */
                    shared->next_valid = true;

                    /* Start in case it got idle while doing the checks. */
                    if (!start_hardware( sdrv )) {
                         /*
                          * Hardware has not been started (still running).
                          * Check for timeout. */
                         if (!timeout--) {
                              D_ERROR( "SH7722/Blt: Timeout waiting for processing!\n" );
                              direct_log_printf( NULL, "  -> %srunning, hw %d-%d, next %d-%d - %svalid\n",     \
                                                 sdrv->gfx_shared->hw_running ? "" : "not ",             \
                                                 sdrv->gfx_shared->hw_start,                             \
                                                 sdrv->gfx_shared->hw_end,                               \
                                                 sdrv->gfx_shared->next_start,                           \
                                                 sdrv->gfx_shared->next_end,                             \
                                                 sdrv->gfx_shared->next_valid ? "" : "not " );
                              D_ASSERT( shared->buffer[shared->hw_end] == 0xF0000000 );
                              sh7722EngineReset( sdrv, sdrv->dev );
                         }

                         /* Wait til next block is started. */
                         ioctl( sdrv->gfx_fd, SH772xGFX_IOCTL_WAIT_NEXT );
                    }

                    /* Start over with the checks. */
                    continue;
               }
          }

          /* We are appending in case there was already a next block. */
          next_end = shared->next_end + sdrv->prep_num;

          /* Reset the timeout counter. */
          timeout = 2;

          /* While the hardware is running... */
          while (shared->hw_running) {
               D_ASSERT( shared->buffer[shared->hw_end] == 0xF0000000 );

               /* ...make sure we don't over lap with its current buffer, otherwise wait. */
               if (shared->hw_start > next_end || shared->hw_end < shared->next_start)
                    break;

               /* Check for timeout. */
               if (!timeout--) {
                    D_ERROR( "SH7722/Blt: Timeout waiting for space!\n" );
                    direct_log_printf( NULL, "  -> %srunning, hw %d-%d, next %d-%d - %svalid\n",     \
                                       sdrv->gfx_shared->hw_running ? "" : "not ",             \
                                       sdrv->gfx_shared->hw_start,                             \
                                       sdrv->gfx_shared->hw_end,                               \
                                       sdrv->gfx_shared->next_start,                           \
                                       sdrv->gfx_shared->next_end,                             \
                                       sdrv->gfx_shared->next_valid ? "" : "not " );
                    D_ASSERT( shared->buffer[shared->hw_end] == 0xF0000000 );
                    sh7722EngineReset( sdrv, sdrv->dev );
               }

               /* Wait til next block is started. */
               ioctl( sdrv->gfx_fd, SH772xGFX_IOCTL_WAIT_NEXT );
          }

          /* Copy from local to shared buffer. */
          direct_memcpy( (void*) &shared->buffer[shared->next_end], &sdrv->prep_buf[0], sdrv->prep_num * sizeof(__u32) );

          /* Terminate the block. */
          shared->buffer[next_end] = 0xF0000000;

          /* Update next block information and mark valid. */
          shared->next_end   = next_end;
          shared->next_valid = true;

          /* Reset local counter. */
          sdrv->prep_num = 0;
     }

     /* Start in case it is idle. */
     start_hardware( sdrv );
}

static inline __u32 *
start_buffer( SH7722DriverData *sdrv,
              int               space )
{
     /* Check for space in local buffer. */
     if (sdrv->prep_num + space > SH7722GFX_MAX_PREPARE) {
          /* Flush local buffer. */
          flush_prepared( sdrv );

          D_ASSERT( sdrv->prep_num == 0 );
     }

     /* Return next write position. */
     return &sdrv->prep_buf[sdrv->prep_num];
}

static inline void
submit_buffer( SH7722DriverData *sdrv,
               int               entries )
{
     D_ASSERT( sdrv->prep_num + entries <= SH7722GFX_MAX_PREPARE );

     /* Increment next write position. */
     sdrv->prep_num += entries;
}

/**********************************************************************************************************************/

static inline void
sh7722_validate_DEST_CLIP( SH7722DriverData *sdrv,
                           SH7722DeviceData *sdev,
                           CardState        *state )
{
     __u32 *prep = start_buffer( sdrv, 10 );

     D_DEBUG_AT( SH7722_BLT, "%s( 0x%08lx [%d] - %4d,%4d-%4dx%4d )\n", __FUNCTION__,
                 state->dst.phys, state->dst.pitch, DFB_RECTANGLE_VALS_FROM_REGION( &state->clip ) );

     /* Set clip. */
     prep[0] = BEM_PE_SC0_MIN;
     prep[1] = SH7722_XY( state->clip.x1, state->clip.y1 );

     prep[2] = BEM_PE_SC0_MAX;
     prep[3] = SH7722_XY( state->clip.x2, state->clip.y2 );

     /* Only clip? */
     if (sdev->v_flags & DEST) {
          submit_buffer( sdrv, 4 );
     }
     else {
          CoreSurface       *surface = state->destination;
          CoreSurfaceBuffer *buffer  = state->dst.buffer;

          sdev->dst_phys  = state->dst.phys;
          sdev->dst_pitch = state->dst.pitch;
          sdev->dst_bpp   = DFB_BYTES_PER_PIXEL( buffer->format );
          sdev->dst_index = DFB_PIXELFORMAT_INDEX( buffer->format ) % DFB_NUM_PIXELFORMATS;

          /* Set destination. */
          prep[4] = BEM_PE_DST;
          prep[5] = pixel_formats[sdev->dst_index];

          prep[6] = BEM_PE_DST_BASE;
          prep[7] = sdev->dst_phys;

          prep[8] = BEM_PE_DST_SIZE;
          prep[9] = SH7722_XY( sdev->dst_pitch / sdev->dst_bpp, surface->config.size.h );

          submit_buffer( sdrv, 10 );
     }

     /* Set the flags. */
     SH7722_VALIDATE( DEST_CLIP );
}

static inline void
sh7722_validate_SOURCE( SH7722DriverData *sdrv,
                        SH7722DeviceData *sdev,
                        CardState        *state )
{
     CoreSurface       *surface = state->source;
     CoreSurfaceBuffer *buffer  = state->src.buffer;
     __u32             *prep    = start_buffer( sdrv, 6 );

     sdev->src_phys  = state->src.phys;
     sdev->src_pitch = state->src.pitch;
     sdev->src_bpp   = DFB_BYTES_PER_PIXEL( buffer->format );
     sdev->src_index = DFB_PIXELFORMAT_INDEX( buffer->format ) % DFB_NUM_PIXELFORMATS;

     /* Set source. */
     prep[0] = BEM_TE_SRC;
     prep[1] = pixel_formats[sdev->src_index];

     prep[2] = BEM_TE_SRC_BASE;
     prep[3] = sdev->src_phys;

     prep[4] = BEM_TE_SRC_SIZE;
     prep[5] = SH7722_XY( sdev->src_pitch / sdev->src_bpp, surface->config.size.h );

     submit_buffer( sdrv, 6 );

     /* Set the flag. */
     SH7722_VALIDATE( SOURCE );
}

__attribute__((noinline))
static void
sh7722_validate_MASK( SH7722DriverData *sdrv,
                      SH7722DeviceData *sdev,
                      CardState        *state )
{
     CoreSurface       *surface = state->source_mask;
     CoreSurfaceBuffer *buffer  = state->src_mask.buffer;
     __u32             *prep    = start_buffer( sdrv, 6 );

     sdev->mask_phys   = state->src_mask.phys;
     sdev->mask_pitch  = state->src_mask.pitch;
     sdev->mask_format = buffer->format;
     sdev->mask_index  = DFB_PIXELFORMAT_INDEX( buffer->format ) % DFB_NUM_PIXELFORMATS;
     sdev->mask_offset = state->src_mask_offset;
     sdev->mask_flags  = state->src_mask_flags;

     /* Set mask. */
     prep[0] = BEM_TE_MASK;
     prep[1] = TE_MASK_ENABLE | pixel_formats[sdev->mask_index];

     prep[2] = BEM_TE_MASK_SIZE;
     prep[3] = SH7722_XY( sdev->mask_pitch / DFB_BYTES_PER_PIXEL(sdev->mask_format), surface->config.size.h );

     prep[4] = BEM_TE_MASK_BASE;
     prep[5] = sdev->mask_phys  +  sdev->mask_pitch * sdev->mask_offset.y +
               DFB_BYTES_PER_LINE( sdev->mask_format, sdev->mask_offset.x );
     
     submit_buffer( sdrv, 6 );

     /* Set the flag. */
     SH7722_VALIDATE( MASK );
}

static inline void
sh7722_validate_COLOR( SH7722DriverData *sdrv,
                       SH7722DeviceData *sdev,
                       CardState        *state )
{
     __u32 *prep = start_buffer( sdrv, 4 );

     prep[0] = BEM_BE_COLOR1;
     prep[1] = PIXEL_ARGB( state->color.a,
                           state->color.r,
                           state->color.g,
                           state->color.b );

     prep[2] = BEM_WR_FGC;
     prep[3] = prep[1];

     submit_buffer( sdrv, 4 );

     /* Set the flag. */
     SH7722_VALIDATE( COLOR );
}

__attribute__((noinline))
static void
sh7722_validate_COLOR_KEY( SH7722DriverData *sdrv,
                           SH7722DeviceData *sdev,
                           CardState        *state )
{
     CoreSurfaceBuffer *buffer = state->src.buffer;
     __u32             *prep   = start_buffer( sdrv, 4 );

     prep[0] = BEM_PE_CKEY;
     prep[1] = CKEY_EXCLUDE_ALPHA | CKEY_EXCLUDE_UNUSED | CKEY_B_ENABLE;

     prep[2] = BEM_PE_CKEY_B;

     switch (buffer->format) {
          case DSPF_ARGB:
          case DSPF_RGB32:
               prep[3] = state->src_colorkey;
               break;

          case DSPF_RGB16:
               prep[3] = RGB16_TO_RGB32( state->src_colorkey );
               break;

          case DSPF_ARGB1555:
          case DSPF_RGB555:
               prep[3] = ARGB1555_TO_RGB32( state->src_colorkey );
               break;

          case DSPF_ARGB4444:
          case DSPF_RGB444:
               prep[3] = ARGB4444_TO_RGB32( state->src_colorkey );
               break;

          default:
               D_BUG( "unexpected pixelformat" );
     }

     submit_buffer( sdrv, 4 );

     /* Set the flag. */
     SH7722_VALIDATE( COLOR_KEY );
}

/* let compiler decide here :) */
static void
sh7722_validate_COLOR_CHANGE( SH7722DriverData *sdrv,
                              SH7722DeviceData *sdev,
                              CardState        *state )
{
     __u32 *prep = start_buffer( sdrv, 6 );

     prep[0] = BEM_PE_COLORCHANGE;
     prep[1] = COLORCHANGE_COMPARE_FIRST | COLORCHANGE_EXCLUDE_UNUSED;

     prep[2] = BEM_PE_COLORCHANGE_0;
     prep[3] = 0xffffff;

     prep[4] = BEM_PE_COLORCHANGE_1;
     prep[5] = PIXEL_ARGB( state->color.a,
                           state->color.r,
                           state->color.g,
                           state->color.b );

     submit_buffer( sdrv, 6 );

     /* Set the flag. */
     SH7722_VALIDATE( COLOR_CHANGE );
}

/*                            DSBF_UNKNOWN      = 0    */
/*   BLE_DSTF_ZERO    = 0     DSBF_ZERO         = 1    */
/*   BLE_DSTF_ONE     = 1     DSBF_ONE          = 2    */
/*   BLE_DSTF_SRC     = 2     DSBF_SRCCOLOR     = 3    */
/*   BLE_DSTF_1_SRC   = 3     DSBF_INVSRCCOLOR  = 4    */
/*   BLE_DSTF_SRC_A   = 4     DSBF_SRCALPHA     = 5    */
/*   BLE_DSTF_1_SRC_A = 5     DSBF_INVSRCALPHA  = 6    */
/*   BLE_DSTF_DST_A   = 6     DSBF_DESTALPHA    = 7    */
/*   BLE_DSTF_1_DST_A = 7     DSBF_INVDESTALPHA = 8    */
/*                            DSBF_DESTCOLOR    = 9    */
/*   Hey, matches!!? :-P      DSBF_INVDESTCOLOR = 10   */
/*                            DSBF_SRCALPHASAT  = 11   */

static inline void
sh7722_validate_BLENDING( SH7722DriverData *sdrv,
                          SH7722DeviceData *sdev,
                          CardState        *state )
{
     __u32 *prep = start_buffer( sdrv, 2 );

     sdev->ble_dstf =  (state->dst_blend - 1) & 7;
     sdev->ble_srcf = ((state->src_blend - 1) & 7) << 4;

     prep[0] = BEM_PE_FIXEDALPHA;
     prep[1] = (state->color.a << 24) | (state->color.a << 16);

     submit_buffer( sdrv, 2 );

     /* Set the flag. */
     SH7722_VALIDATE( BLENDING );
}

__attribute__((noinline))
static void
sh7722_validate_MATRIX( SH7722DriverData *sdrv,
                        SH7722DeviceData *sdev,
                        CardState        *state )
{
     __u32 *prep = start_buffer( sdrv, 12 );

     prep[0]  = BEM_BE_MATRIX_A;
     prep[1]  = state->matrix[0];
              
     prep[2]  = BEM_BE_MATRIX_B;
     prep[3]  = state->matrix[1];
              
     prep[4]  = BEM_BE_MATRIX_C;
     prep[5]  = state->matrix[2];
              
     prep[6]  = BEM_BE_MATRIX_D;
     prep[7]  = state->matrix[3];
              
     prep[8]  = BEM_BE_MATRIX_E;
     prep[9]  = state->matrix[4];

     prep[10] = BEM_BE_MATRIX_F;
     prep[11] = state->matrix[5];

     submit_buffer( sdrv, 12 );

     /* Keep for CPU transformation of lines. */
     direct_memcpy( sdev->matrix, state->matrix, sizeof(s32) * 6 );

     /* Set the flag. */
     SH7722_VALIDATE( MATRIX );
}

static inline void
sh7722_validate_BLIT_OP( SH7722DriverData *sdrv,
                         SH7722DeviceData *sdev,
                         CardState        *state )
{
     __u32 *prep = start_buffer( sdrv, 2 );

     prep[0] = BEM_PE_OPERATION;
     prep[1] = BLE_FUNC_NONE;

     if (state->blittingflags & DSBLIT_XOR)
          prep[1] |= BLE_ROP_XOR;

     if (state->blittingflags & (DSBLIT_BLEND_ALPHACHANNEL | DSBLIT_BLEND_COLORALPHA)) {
          prep[1] |= BLE_FUNC_AxB_plus_CxD | sdev->ble_srcf | sdev->ble_dstf;

          switch (state->blittingflags & (DSBLIT_BLEND_ALPHACHANNEL | DSBLIT_BLEND_COLORALPHA)) {
               case DSBLIT_BLEND_ALPHACHANNEL:
                    prep[1] |= BLE_SRCA_SOURCE_ALPHA;
                    break;

               case DSBLIT_BLEND_COLORALPHA:
                    prep[1] |= BLE_SRCA_FIXED;
                    break;
          }
     }
     else if (state->blittingflags & DSBLIT_SRC_MASK_ALPHA)
          prep[1] |= BLE_FUNC_AxB_plus_CxD | BLE_SRCA_ALPHA_CHANNEL | BLE_SRCF_SRC_A | BLE_DSTF_1_SRC_A;

     submit_buffer( sdrv, 2 );

     /* Set the flag. */
     SH7722_VALIDATE( BLIT_OP );
}

/**********************************************************************************************************************/

__attribute__((noinline))
static void
invalidate_ckey( SH7722DriverData *sdrv, SH7722DeviceData *sdev )
{
     __u32 *prep = start_buffer( sdrv, 4 );

     prep[0] = BEM_PE_CKEY;
     prep[1] = 0;

     prep[2] = BEM_PE_CKEY_B;
     prep[3] = 0;

     submit_buffer( sdrv, 4 );

     sdev->ckey_b_enabled = false;

     SH7722_INVALIDATE( COLOR_KEY );
}

__attribute__((noinline))
static void
invalidate_color_change( SH7722DriverData *sdrv, SH7722DeviceData *sdev )
{
     __u32 *prep = start_buffer( sdrv, 2 );

     prep[0] = BEM_PE_COLORCHANGE;
     prep[1] = COLORCHANGE_DISABLE;

     submit_buffer( sdrv, 2 );

     sdev->color_change_enabled = false;

     SH7722_INVALIDATE( COLOR_CHANGE );
}

__attribute__((noinline))
static void
invalidate_mask( SH7722DriverData *sdrv, SH7722DeviceData *sdev )
{
     u32 *prep = start_buffer( sdrv, 2 );

     prep[0] = BEM_TE_MASK;
     prep[1] = TE_MASK_DISABLE;

     submit_buffer( sdrv, 2 );

     sdev->mask_enabled = false;

     SH7722_INVALIDATE( MASK );
}

/**********************************************************************************************************************/

DFBResult
sh7722EngineSync( void *drv, void *dev )
{
     DFBResult            ret    = DFB_OK;
     SH7722DriverData    *sdrv   = drv;
     SH772xGfxSharedArea *shared = sdrv->gfx_shared;

     D_DEBUG_AT( SH7722_BLT, "%s()\n", __FUNCTION__ );

     DUMP_INFO();

     while (shared->hw_running && ioctl( sdrv->gfx_fd, SH772xGFX_IOCTL_WAIT_IDLE ) < 0) {
          if (errno == EINTR)
               continue;

          ret = errno2result( errno );
          D_PERROR( "SH7722/BLT: SH7722GFX_IOCTL_WAIT_IDLE failed!\n" );

          direct_log_printf( NULL, "  -> %srunning, hw %d-%d, next %d-%d - %svalid\n",     \
                             sdrv->gfx_shared->hw_running ? "" : "not ",             \
                             sdrv->gfx_shared->hw_start,                             \
                             sdrv->gfx_shared->hw_end,                               \
                             sdrv->gfx_shared->next_start,                           \
                             sdrv->gfx_shared->next_end,                             \
                             sdrv->gfx_shared->next_valid ? "" : "not " );

          break;
     }

     if (ret == DFB_OK) {
          D_ASSERT( !shared->hw_running );
          D_ASSERT( !shared->next_valid );
     }

     return ret;
}

void
sh7722EngineReset( void *drv, void *dev )
{
     SH7722DriverData *sdrv = drv;
     SH7722DeviceData *sdev = dev;
     __u32            *prep;

     D_DEBUG_AT( SH7722_BLT, "%s()\n", __FUNCTION__ );

     DUMP_INFO();

     ioctl( sdrv->gfx_fd, SH772xGFX_IOCTL_RESET );

     prep = start_buffer( sdrv, 20 );

     prep[0] = BEM_PE_OPERATION;
     prep[1] = 0x00000000;

     prep[2] = BEM_PE_COLORCHANGE;
     prep[3] = 0x00000000;

     prep[4] = BEM_PE_CKEY;
     prep[5] = 0x00000000;

     prep[6] = BEM_PE_CKEY_B;
     prep[7] = 0;

     prep[8] = BEM_PE_FIXEDALPHA;
     prep[9] = 0x80000000;

     prep[10] = BEM_TE_SRC_CNV;
     prep[11] = 0x00100010;   /* full conversion of Ad, As, Cd and Cs */

     prep[12] = BEM_TE_FILTER;
     prep[13] = 0x00000000;   /* 0 = nearest, 3 = up bilinear / down average */

     prep[14] = BEM_PE_SC;
     prep[15] = 0x00000001;   /* enable clipping */

     prep[16] = BEM_BE_ORIGIN;
     prep[17] = SH7722_XY( 0, 0 );

     prep[18] = BEM_TE_MASK_CNV;
     prep[19] = 2;

     submit_buffer( sdrv, 20 );

     sdev->ckey_b_enabled       = false;
     sdev->color_change_enabled = false;
     sdev->mask_enabled         = false;
}

void
sh7722EmitCommands( void *drv, void *dev )
{
     SH7722DriverData *sdrv = drv;

     D_DEBUG_AT( SH7722_BLT, "%s()\n", __FUNCTION__ );

     flush_prepared( sdrv );
}

void
sh7722FlushTextureCache( void *drv, void *dev )
{
     SH7722DriverData *sdrv = drv;
     __u32            *prep = start_buffer( sdrv, 4 );

     D_DEBUG_AT( SH7722_BLT, "%s()\n", __FUNCTION__ );

     DUMP_INFO();

     prep[0] = BEM_PE_CACHE;
     prep[1] = 2;

     prep[2] = BEM_TE_INVALID;
     prep[3] = 1;

     submit_buffer( sdrv, 4 );
}

/**********************************************************************************************************************/

void
sh7722CheckState( void                *drv,
                  void                *dev,
                  CardState           *state,
                  DFBAccelerationMask  accel )
{
     D_DEBUG_AT( SH7722_BLT, "%s( %p, 0x%08x )\n", __FUNCTION__, state, accel );

     /* Return if the desired function is not supported at all. */
     if (accel & ~(SH7722_SUPPORTED_DRAWINGFUNCTIONS | SH7722_SUPPORTED_BLITTINGFUNCTIONS))
          return;

     /* Return if the destination format is not supported. */
     switch (state->destination->config.format) {
          case DSPF_ARGB:
          case DSPF_RGB32:
          case DSPF_RGB16:
          case DSPF_ARGB1555:
          case DSPF_RGB555:
          case DSPF_ARGB4444:
          case DSPF_RGB444:
               break;
          default:
               return;
     }

     /* Check if drawing or blitting is requested. */
     if (DFB_DRAWING_FUNCTION( accel )) {
          /* Return if unsupported drawing flags are set. */
          if (state->drawingflags & ~SH7722_SUPPORTED_DRAWINGFLAGS)
               return;

          /* Return if blending with unsupported blend functions is requested. */
          if (state->drawingflags & DSDRAW_BLEND) {
               /* Check blend functions. */
               if (!check_blend_functions( state ))
                    return;

               /* XOR only without blending. */
               if (state->drawingflags & DSDRAW_XOR)
                    return;
          }

          /* Enable acceleration of drawing functions. */
          state->accel |= SH7722_SUPPORTED_DRAWINGFUNCTIONS;
     }
     else {
          DFBSurfaceBlittingFlags flags = state->blittingflags;

          /* Return if unsupported blitting flags are set. */
          if (flags & ~SH7722_SUPPORTED_BLITTINGFLAGS) 
               return;

          /* Return if the source format is not supported. */
          switch (state->source->config.format) {
               case DSPF_ARGB:
               case DSPF_RGB32:
               case DSPF_RGB16:
               case DSPF_ARGB1555:
               case DSPF_RGB555:
               case DSPF_ARGB4444:
               case DSPF_RGB444:
                    break;

               default:
                    return;
          }

          /* Return if blending with unsupported blend functions is requested. */
          if (flags & (DSBLIT_BLEND_ALPHACHANNEL | DSBLIT_BLEND_COLORALPHA)) {
               /* Check blend functions. */
               if (!check_blend_functions( state ))
                    return;
          }

          /* XOR only without blending etc. */
          if (flags & DSBLIT_XOR &&
              flags & ~(DSBLIT_SRC_COLORKEY | DSBLIT_ROTATE180 | DSBLIT_XOR))
               return;

          /* Return if colorizing for non-font surfaces is requested. */
          if ((flags & DSBLIT_COLORIZE) && !(state->source->type & CSTF_FONT))
               return;

          /* Return if blending with both alpha channel and value is requested. */
          if (D_FLAGS_ARE_SET( flags, DSBLIT_BLEND_ALPHACHANNEL | DSBLIT_BLEND_COLORALPHA))
               return;

          /* Mask checking. */
          if (flags & DSBLIT_SRC_MASK_ALPHA) {
               if (!state->source_mask)
                    return;
                    
               /* Return if the source mask format is not supported. */
               switch (state->source_mask->config.format) {
                    case DSPF_A1:
                    case DSPF_A8:
                         break;

                    default:
                         return;
               }
          }

          /* Enable acceleration of blitting functions. */
          state->accel |= SH7722_SUPPORTED_BLITTINGFUNCTIONS;
     }
}

/*
 * Make sure that the hardware is programmed for execution of 'accel' according to the 'state'.
 */
void
sh7722SetState( void                *drv,
                void                *dev,
                GraphicsDeviceFuncs *funcs,
                CardState           *state,
                DFBAccelerationMask  accel )
{
     SH7722DriverData       *sdrv     = drv;
     SH7722DeviceData       *sdev     = dev;
     StateModificationFlags  modified = state->mod_hw;

     D_DEBUG_AT( SH7722_BLT, "%s( %p, 0x%08x ) <- modified 0x%08x\n",
                 __FUNCTION__, state, accel, modified );
     DUMP_INFO();

     /*
      * 1) Invalidate hardware states
      *
      * Each modification to the hw independent state invalidates one or more hardware states.
      */

     /* Simply invalidate all? */
     if (modified == SMF_ALL) {
          SH7722_INVALIDATE( ALL );
     }
     else if (modified) {
          /* Invalidate destination registers. */
          if (modified & SMF_DESTINATION)
               SH7722_INVALIDATE( DEST );

          /* Invalidate clipping registers. */
          if (modified & SMF_CLIP)
               SH7722_INVALIDATE( CLIP );

          /* Invalidate source registers. */
          if (modified & SMF_SOURCE)
               SH7722_INVALIDATE( SOURCE | COLOR_KEY );
          else if (modified & SMF_SRC_COLORKEY)
               SH7722_INVALIDATE( COLOR_KEY );

          /* Invalidate mask registers. */
          if (modified & (SMF_SOURCE_MASK | SMF_SOURCE_MASK_VALS))
               SH7722_INVALIDATE( MASK );

          /* Invalidate color registers. */
          if (modified & SMF_COLOR)
               SH7722_INVALIDATE( BLENDING | COLOR | COLOR_CHANGE );
          else if (modified & (SMF_SRC_BLEND | SMF_SRC_BLEND))
               SH7722_INVALIDATE( BLENDING );

          /* Invalidate matrix registers. */
          if (modified & SMF_MATRIX)
               SH7722_INVALIDATE( MATRIX );

          /* Invalidate blitting operation. */
          if (modified & SMF_BLITTING_FLAGS)
               SH7722_INVALIDATE( BLIT_OP );
     }

     /*
      * 2) Validate hardware states
      *
      * Each function has its own set of states that need to be validated.
      */

     /* Always requiring valid destination and clip. */
     SH7722_CHECK_VALIDATE( DEST_CLIP );

     /* Use transformation matrix? */
     if (state->render_options & DSRO_MATRIX)
          SH7722_CHECK_VALIDATE( MATRIX );

     /* Depending on the function... */
     switch (accel) {
          case DFXL_FILLRECTANGLE:
          case DFXL_FILLTRIANGLE:
          case DFXL_DRAWRECTANGLE:
          case DFXL_DRAWLINE:
               /* ...require valid color. */
               SH7722_CHECK_VALIDATE( COLOR );

               /* Use blending? */
               if (state->drawingflags & DSDRAW_BLEND) {
                    /* need valid source and destination blend factors */
                    SH7722_CHECK_VALIDATE( BLENDING );
               }

               /* Clear old ckeys */
               if (sdev->ckey_b_enabled)
                    invalidate_ckey( sdrv, sdev );

               /* Clear old mask */
               if (sdev->mask_enabled)
                    invalidate_mask( sdrv, sdev );

               /* Choose function. */
               switch (accel) {
                    case DFXL_FILLRECTANGLE:
                         if (state->render_options & (DSRO_MATRIX | DSRO_ANTIALIAS))
                              funcs->FillRectangle = sh7722FillRectangleMatrixAA;
                         else
                              funcs->FillRectangle = sh7722FillRectangle;
                         break;

                    case DFXL_DRAWRECTANGLE:
                         if (state->render_options & (DSRO_MATRIX | DSRO_ANTIALIAS))
                              funcs->DrawRectangle = sh7722DrawRectangleMatrixAA;
                         else
                              funcs->DrawRectangle = sh7722DrawRectangle;
                         break;

                    case DFXL_DRAWLINE:
                         if (state->render_options & DSRO_ANTIALIAS)
                              funcs->DrawLine = sh7722DrawLineAA;
                         else if (state->render_options & DSRO_MATRIX)
                              funcs->DrawLine = sh7722DrawLineMatrix;
                         else
                              funcs->DrawLine = sh7722DrawLine;
                         break;

                    default:
                         break;
               }

               /*
                * 3) Tell which functions can be called without further validation, i.e. SetState()
                *
                * When the hw independent state is changed, this collection is reset.
                */
               state->set = SH7722_SUPPORTED_DRAWINGFUNCTIONS;
               break;

          case DFXL_BLIT:
          case DFXL_STRETCHBLIT:
               /* ...require valid source. */
               SH7722_CHECK_VALIDATE( SOURCE );

               /* Use blending? */
               if (state->blittingflags & (DSBLIT_BLEND_ALPHACHANNEL | DSBLIT_BLEND_COLORALPHA)) {
                    /* need valid source and destination blend factors */
                    SH7722_CHECK_VALIDATE( BLENDING );
               }

               /* Use color keying? */
               if (state->blittingflags & DSBLIT_SRC_COLORKEY) {
                    /* Need valid color key settings (enabling). */
                    SH7722_CHECK_VALIDATE( COLOR_KEY );

                    sdev->ckey_b_enabled = true;
               }
               /* Disable color keying? */
               else if (sdev->ckey_b_enabled)
                    invalidate_ckey( sdrv, sdev );

               /* Use color change? */
               if (state->blittingflags & DSBLIT_COLORIZE) {
                    /* Need valid color change settings (enabling). */
                    SH7722_CHECK_VALIDATE( COLOR_CHANGE );

                    sdev->color_change_enabled = true;
               }
               /* Disable color change? */
               else if (sdev->color_change_enabled)
                    invalidate_color_change( sdrv, sdev );

               /* Use mask? */
               if (state->blittingflags & DSBLIT_SRC_MASK_ALPHA) {
                    /* need valid mask */
                    SH7722_CHECK_VALIDATE( MASK );

                    sdev->mask_enabled = true;
               }
               /* Disable mask? */
               else if (sdev->mask_enabled)
                    invalidate_mask( sdrv, sdev );

               SH7722_CHECK_VALIDATE( BLIT_OP );

               /*
                * 3) Tell which functions can be called without further validation, i.e. SetState()
                *
                * When the hw independent state is changed, this collection is reset.
                */
               state->set = SH7722_SUPPORTED_BLITTINGFUNCTIONS;
               break;

          default:
               D_BUG( "unexpected drawing/blitting function" );
               break;
     }

     sdev->dflags         = state->drawingflags;
     sdev->bflags         = state->blittingflags;
     sdev->render_options = state->render_options;
     sdev->color          = state->color;

     /*
      * 4) Clear modification flags
      *
      * All flags have been evaluated in 1) and remembered for further validation.
      * If the hw independent state is not modified, this function won't get called
      * for subsequent rendering functions, unless they aren't defined by 3).
      */
     state->mod_hw = 0;
}

/**********************************************************************************************************************/

static inline void
draw_rectangle( SH7722DriverData *sdrv,
                SH7722DeviceData *sdev,
                int x1, int y1,
                int x2, int y2,
                int x3, int y3,
                int x4, int y4,
                bool antialias,
                bool full )
{
     u32  ctrl = antialias ? WR_CTRL_ANTIALIAS : 0;
     u32 *prep = start_buffer( sdrv, full ? 24 : 12 );

     if (antialias) {
          prep[0] = BEM_WR_FGC;
          prep[1] = PIXEL_ARGB( (sdev->color.a * AA_COEF) >> 8,
                                (sdev->color.r * AA_COEF) >> 8,
                                (sdev->color.g * AA_COEF) >> 8,
                                (sdev->color.b * AA_COEF) >> 8 );

          prep[2] = BEM_PE_FIXEDALPHA;
          prep[3] = (sdev->color.a * AA_COEF) << 16;
     }
     else {
          prep[0] = BEM_WR_FGC;
          prep[1] = PIXEL_ARGB( sdev->color.a,
                                sdev->color.r,
                                sdev->color.g,
                                sdev->color.b );

          prep[2] = BEM_PE_FIXEDALPHA;
          prep[3] = (sdev->color.a << 24) << (sdev->color.a << 16);
     }

     prep[4] = BEM_WR_V1;
     prep[5] = SH7722_XY( x1, y1 );

     prep[6] = BEM_WR_V2;
     prep[7] = SH7722_XY( x2, y2 );

     prep[8] = BEM_PE_OPERATION;
     prep[9] = (sdev->dflags & DSDRAW_BLEND) ? (BLE_FUNC_AxB_plus_CxD |
                                                sdev->ble_srcf |
                                                BLE_SRCA_FIXED |
                                                sdev->ble_dstf)
                                             :
                                              (antialias ? 
                                               (BLE_FUNC_AxB_plus_CxD |
                                                BLE_SRCF_ONE |
                                                BLE_SRCA_FIXED |
                                                BLE_DSTF_1_SRC_A) : BLE_FUNC_NONE
                                              );

     if (sdev->dflags & DSDRAW_XOR)
          prep[9] |= BLE_ROP_XOR;

     prep[10] = BEM_WR_CTRL;
     prep[11] = WR_CTRL_LINE | ctrl;

     if (full) {
          prep[12] = BEM_WR_V2;
          prep[13] = SH7722_XY( x3, y3 );
          prep[14] = BEM_WR_CTRL;
          prep[15] = WR_CTRL_POLYLINE | ctrl;

          prep[16] = BEM_WR_V2;
          prep[17] = SH7722_XY( x4, y4 );
          prep[18] = BEM_WR_CTRL;
          prep[19] = WR_CTRL_POLYLINE | ctrl;

          prep[20] = BEM_WR_V2;
          prep[21] = SH7722_XY( x1, y1 );
          prep[22] = BEM_WR_CTRL;
          prep[23] = WR_CTRL_POLYLINE | ctrl;

          submit_buffer( sdrv, 24 );
     }
     else {
          prep[7]   = SH7722_XY( x3, y3 );
          prep[11] |= WR_CTRL_ENDPOINT;

          submit_buffer( sdrv, 12 );
     }
}

/*
 * Render a filled rectangle using the current hardware state.
 */
static bool
sh7722FillRectangle( void *drv, void *dev, DFBRectangle *rect )
{
     SH7722DriverData *sdrv = drv;
     SH7722DeviceData *sdev = dev;
     __u32            *prep = start_buffer( sdrv, 8 );

     D_DEBUG_AT( SH7722_BLT, "%s( %d, %d - %dx%d )\n", __FUNCTION__,
                 DFB_RECTANGLE_VALS( rect ) );
     DUMP_INFO();

     prep[0] = BEM_BE_V1;
     prep[1] = SH7722_XY( rect->x, rect->y );

     prep[2] = BEM_BE_V2;
     prep[3] = SH7722_XY( rect->w, rect->h );

     prep[4] = BEM_PE_OPERATION;
     prep[5] = (sdev->dflags & DSDRAW_BLEND) ? (BLE_FUNC_AxB_plus_CxD |
                                                sdev->ble_srcf |
                                                BLE_SRCA_FIXED |
                                                sdev->ble_dstf) : BLE_FUNC_NONE;

     if (sdev->dflags & DSDRAW_XOR)
          prep[5] |= BLE_ROP_XOR;

     prep[6] = BEM_BE_CTRL;
     prep[7] = BE_CTRL_RECTANGLE | BE_CTRL_SCANMODE_LINE;

     submit_buffer( sdrv, 8 );

     return true;
}

/*
 * This version sends a quadrangle to have all four edges transformed.
 */
static bool
sh7722FillRectangleMatrixAA( void *drv, void *dev, DFBRectangle *rect )
{
     SH7722DriverData *sdrv = drv;
     SH7722DeviceData *sdev = dev;
     __u32            *prep;

     D_DEBUG_AT( SH7722_BLT, "%s( %d, %d - %dx%d )\n", __FUNCTION__,
                 DFB_RECTANGLE_VALS( rect ) );
     DUMP_INFO();


     if (sdev->render_options & DSRO_ANTIALIAS) {
          int x1 = rect->x;
          int y1 = rect->y;
          int x2 = rect->x + rect->w;
          int y2 = rect->y;
          int x3 = rect->x + rect->w;
          int y3 = rect->y + rect->h;
          int x4 = rect->x;
          int y4 = rect->y + rect->h;

          if (sdev->render_options & DSRO_MATRIX) {
               int t;
     
               t  = ((x1 * sdev->matrix[0]) +
                     (y1 * sdev->matrix[1]) + sdev->matrix[2]) >> 16;
               y1 = ((x1 * sdev->matrix[3]) +
                     (y1 * sdev->matrix[4]) + sdev->matrix[5]) >> 16;
               x1 = t;
     
               t  = ((x2 * sdev->matrix[0]) +
                     (y2 * sdev->matrix[1]) + sdev->matrix[2]) >> 16;
               y2 = ((x2 * sdev->matrix[3]) +
                     (y2 * sdev->matrix[4]) + sdev->matrix[5]) >> 16;
               x2 = t;
     
               t  = ((x3 * sdev->matrix[0]) +
                     (y3 * sdev->matrix[1]) + sdev->matrix[2]) >> 16;
               y3 = ((x3 * sdev->matrix[3]) +
                     (y3 * sdev->matrix[4]) + sdev->matrix[5]) >> 16;
               x3 = t;
     
               t  = ((x4 * sdev->matrix[0]) +
                     (y4 * sdev->matrix[1]) + sdev->matrix[2]) >> 16;
               y4 = ((x4 * sdev->matrix[3]) +
                     (y4 * sdev->matrix[4]) + sdev->matrix[5]) >> 16;
               x4 = t;
          }
     
          prep = start_buffer( sdrv, 28 );

          prep[0] = BEM_WR_FGC;
          prep[1] = PIXEL_ARGB( (sdev->color.a * AA_COEF) >> 8,
                                (sdev->color.r * AA_COEF) >> 8,
                                (sdev->color.g * AA_COEF) >> 8,
                                (sdev->color.b * AA_COEF) >> 8 );

          prep[2] = BEM_PE_FIXEDALPHA;
          prep[3] = (sdev->color.a * AA_COEF) << 16;

          prep[4] = BEM_WR_V1;
          prep[5] = SH7722_XY( x1, y1 );

          prep[6] = BEM_WR_V2;
          prep[7] = SH7722_XY( x2, y2 );

          prep[8] = BEM_PE_OPERATION;
          prep[9] = (sdev->dflags & DSDRAW_BLEND) ? (BLE_FUNC_AxB_plus_CxD |
                                                     sdev->ble_srcf |
                                                     BLE_SRCA_FIXED |
                                                     sdev->ble_dstf)
                                                  :
                                                    (BLE_FUNC_AxB_plus_CxD |
                                                     BLE_SRCF_ONE |
                                                     BLE_SRCA_FIXED |
                                                     BLE_DSTF_1_SRC_A);

          if (sdev->dflags & DSDRAW_XOR)
               prep[9] |= BLE_ROP_XOR;

          prep[10] = BEM_WR_CTRL;
          prep[11] = WR_CTRL_LINE | WR_CTRL_ANTIALIAS;

          if (rect->h > 1 && rect->w > 1) {
               prep[12] = BEM_WR_V2;
               prep[13] = SH7722_XY( x3, y3 );
               prep[14] = BEM_WR_CTRL;
               prep[15] = WR_CTRL_POLYLINE | WR_CTRL_ANTIALIAS;

               prep[16] = BEM_WR_V2;
               prep[17] = SH7722_XY( x4, y4 );
               prep[18] = BEM_WR_CTRL;
               prep[19] = WR_CTRL_POLYLINE | WR_CTRL_ANTIALIAS;

               prep[20] = BEM_WR_V2;
               prep[21] = SH7722_XY( x1, y1 );
               prep[22] = BEM_WR_CTRL;
               prep[23] = WR_CTRL_POLYLINE | WR_CTRL_ANTIALIAS;

               prep[24] = BEM_WR_FGC;
               prep[25] = PIXEL_ARGB( sdev->color.a,
                                      sdev->color.r,
                                      sdev->color.g,
                                      sdev->color.b );

               prep[26] = BEM_PE_FIXEDALPHA;
               prep[27] = (sdev->color.a << 24) << (sdev->color.a << 16);

               submit_buffer( sdrv, 28 );
          }
          else {
               prep[7]   = SH7722_XY( x3, y3 );
               prep[11] |= WR_CTRL_ENDPOINT;

               prep[12] = BEM_WR_FGC;
               prep[13] = PIXEL_ARGB( sdev->color.a,
                                     sdev->color.r,
                                     sdev->color.g,
                                     sdev->color.b );

               prep[14] = BEM_PE_FIXEDALPHA;
               prep[15] = (sdev->color.a << 24) << (sdev->color.a << 16);

               submit_buffer( sdrv, 16 );
          }
     }


     prep = start_buffer( sdrv, 12 );

     prep[0] = BEM_BE_V1;
     prep[1] = SH7722_XY( rect->x, rect->y );

     prep[2] = BEM_BE_V2;
     prep[3] = SH7722_XY( rect->x, rect->y + rect->h );

     prep[4] = BEM_BE_V3;
     prep[5] = SH7722_XY( rect->x + rect->w, rect->y );

     prep[6] = BEM_BE_V4;
     prep[7] = SH7722_XY( rect->x + rect->w, rect->y + rect->h );

     prep[8] = BEM_PE_OPERATION;
     prep[9] = (sdev->dflags & DSDRAW_BLEND) ? (BLE_FUNC_AxB_plus_CxD |
                                                sdev->ble_srcf |
                                                BLE_SRCA_FIXED |
                                                sdev->ble_dstf) : BLE_FUNC_NONE;

     if (sdev->dflags & DSDRAW_XOR)
          prep[9] |= BLE_ROP_XOR;

     prep[10] = BEM_BE_CTRL;

     if (sdev->render_options & DSRO_MATRIX)
          prep[11] = BE_CTRL_QUADRANGLE | BE_CTRL_SCANMODE_4x4 |
                     BE_CTRL_MATRIX | BE_CTRL_FIXMODE_16_16;// | BE_CTRL_ORIGIN;
     else
          prep[11] = BE_CTRL_QUADRANGLE | BE_CTRL_SCANMODE_LINE;

     submit_buffer( sdrv, 12 );

     return true;
}

/*
 * Render a filled triangle using the current hardware state.
 */
bool
sh7722FillTriangle( void *drv, void *dev, DFBTriangle *tri )
{
     SH7722DriverData *sdrv = drv;
     SH7722DeviceData *sdev = dev;
     __u32            *prep;

     D_DEBUG_AT( SH7722_BLT, "%s( %d,%d - %d,%d - %d,%d )\n", __FUNCTION__,
                 tri->x1, tri->y1, tri->x2, tri->y2, tri->x3, tri->y3 );
     DUMP_INFO();


     if (sdev->render_options & DSRO_ANTIALIAS) {
          int x1, y1;
          int x2, y2;
          int x3, y3;

          if (sdev->render_options & DSRO_MATRIX) {
               x1 = ((tri->x1 * sdev->matrix[0]) +
                     (tri->y1 * sdev->matrix[1]) + sdev->matrix[2]) >> 16;
               y1 = ((tri->x1 * sdev->matrix[3]) +
                     (tri->y1 * sdev->matrix[4]) + sdev->matrix[5]) >> 16;

               x2 = ((tri->x2 * sdev->matrix[0]) +
                     (tri->y2 * sdev->matrix[1]) + sdev->matrix[2]) >> 16;
               y2 = ((tri->x2 * sdev->matrix[3]) +
                     (tri->y2 * sdev->matrix[4]) + sdev->matrix[5]) >> 16;

               x3 = ((tri->x3 * sdev->matrix[0]) +
                     (tri->y3 * sdev->matrix[1]) + sdev->matrix[2]) >> 16;
               y3 = ((tri->x3 * sdev->matrix[3]) +
                     (tri->y3 * sdev->matrix[4]) + sdev->matrix[5]) >> 16;
          }
          else {
               x1 = tri->x1;
               y1 = tri->y1;
               x2 = tri->x2;
               y2 = tri->y2;
               x3 = tri->x3;
               y3 = tri->y3;
          }

          prep = start_buffer( sdrv, 24 );

          prep[0] = BEM_WR_FGC;
          prep[1] = PIXEL_ARGB( (sdev->color.a * AA_COEF) >> 8,
                                (sdev->color.r * AA_COEF) >> 8,
                                (sdev->color.g * AA_COEF) >> 8,
                                (sdev->color.b * AA_COEF) >> 8 );

          prep[2] = BEM_PE_FIXEDALPHA;
          prep[3] = (sdev->color.a * AA_COEF) << 16;

          prep[4] = BEM_WR_V1;
          prep[5] = SH7722_XY( x1, y1 );

          prep[6] = BEM_WR_V2;
          prep[7] = SH7722_XY( x2, y2 );

          prep[8] = BEM_PE_OPERATION;
          prep[9] = (sdev->dflags & DSDRAW_BLEND) ? (BLE_FUNC_AxB_plus_CxD |
                                                     sdev->ble_srcf |
                                                     BLE_SRCA_FIXED |
                                                     sdev->ble_dstf)
                                                  :
                                                    (BLE_FUNC_AxB_plus_CxD |
                                                     BLE_SRCF_ONE |
                                                     BLE_SRCA_FIXED |
                                                     BLE_DSTF_1_SRC_A);

          if (sdev->dflags & DSDRAW_XOR)
               prep[9] |= BLE_ROP_XOR;

          prep[10] = BEM_WR_CTRL;
          prep[11] = WR_CTRL_LINE | WR_CTRL_ANTIALIAS;

          prep[12] = BEM_WR_V2;
          prep[13] = SH7722_XY( x3, y3 );
          prep[14] = BEM_WR_CTRL;
          prep[15] = WR_CTRL_POLYLINE | WR_CTRL_ANTIALIAS;

          prep[16] = BEM_WR_V2;
          prep[17] = SH7722_XY( x1, y1 );
          prep[18] = BEM_WR_CTRL;
          prep[19] = WR_CTRL_POLYLINE | WR_CTRL_ANTIALIAS;

          prep[20] = BEM_WR_FGC;
          prep[21] = PIXEL_ARGB( sdev->color.a,
                                 sdev->color.r,
                                 sdev->color.g,
                                 sdev->color.b );

          prep[22] = BEM_PE_FIXEDALPHA;
          prep[23] = (sdev->color.a << 24) << (sdev->color.a << 16);

          submit_buffer( sdrv, 24 );
     }


     prep = start_buffer( sdrv, 12 );

     prep[0] = BEM_BE_V1;
     prep[1] = SH7722_XY( tri->x1, tri->y1 );

     prep[2] = BEM_BE_V2;
     prep[3] = SH7722_XY( tri->x2, tri->y2 );

     prep[4] = BEM_BE_V3;
     prep[5] = SH7722_XY( tri->x3, tri->y3 );

     prep[6] = BEM_BE_V4;
     prep[7] = SH7722_XY( tri->x3, tri->y3 );

     prep[8] = BEM_PE_OPERATION;
     prep[9] = (sdev->dflags & DSDRAW_BLEND) ? (BLE_FUNC_AxB_plus_CxD |
                                                sdev->ble_srcf |
                                                BLE_SRCA_FIXED |
                                                sdev->ble_dstf) : BLE_FUNC_NONE;

     if (sdev->dflags & DSDRAW_XOR)
          prep[9] |= BLE_ROP_XOR;

     prep[10] = BEM_BE_CTRL;
     prep[11] = BE_CTRL_QUADRANGLE | BE_CTRL_SCANMODE_LINE;

     if (sdev->render_options & DSRO_MATRIX)
          prep[11] |= BE_CTRL_MATRIX | BE_CTRL_FIXMODE_16_16;// | BE_CTRL_ORIGIN;

     submit_buffer( sdrv, 12 );

     return true;
}

/*
 * Render rectangle outlines using the current hardware state.
 */
static bool
sh7722DrawRectangle( void *drv, void *dev, DFBRectangle *rect )
{
     SH7722DriverData *sdrv = drv;
     SH7722DeviceData *sdev = dev;
     __u32            *prep = start_buffer( sdrv, 20 );

     int x1 = rect->x;
     int y1 = rect->y;
     int x2 = rect->x + rect->w;
     int y2 = rect->y + rect->h;

     D_DEBUG_AT( SH7722_BLT, "%s( %d, %d - %dx%d )\n", __FUNCTION__,
                 DFB_RECTANGLE_VALS( rect ) );
     DUMP_INFO();

     prep[0] = BEM_WR_V1;
     prep[1] = (y1 << 16) | x1;

     prep[2] = BEM_WR_V2;
     prep[3] = (y1 << 16) | x2;

     prep[4] = BEM_PE_OPERATION;
     prep[5] = (sdev->dflags & DSDRAW_BLEND) ? (BLE_FUNC_AxB_plus_CxD |
                                                sdev->ble_srcf |
                                                BLE_SRCA_FIXED |
                                                sdev->ble_dstf) : BLE_FUNC_NONE;

     if (sdev->dflags & DSDRAW_XOR)
          prep[5] |= BLE_ROP_XOR;

     prep[6] = BEM_WR_CTRL;
     prep[7] = WR_CTRL_LINE;

     if (rect->h > 1 && rect->w > 1) {
          prep[8]  = BEM_WR_V2;
          prep[9]  = (y2 << 16) | x2;
          prep[10] = BEM_WR_CTRL;
          prep[11] = WR_CTRL_POLYLINE;

          prep[12] = BEM_WR_V2;
          prep[13] = (y2 << 16) | x1;
          prep[14] = BEM_WR_CTRL;
          prep[15] = WR_CTRL_POLYLINE;

          prep[16] = BEM_WR_V2;
          prep[17] = (y1 << 16) | x1;
          prep[18] = BEM_WR_CTRL;
          prep[19] = WR_CTRL_POLYLINE;

          submit_buffer( sdrv, 20 );
     }
     else {
          prep[3]  = (y2 << 16) | x2;
          prep[7] |= WR_CTRL_ENDPOINT;

          submit_buffer( sdrv, 8 );
     }

     return true;
}

static bool
sh7722DrawRectangleMatrixAA( void *drv, void *dev, DFBRectangle *rect )
{
     SH7722DriverData *sdrv = drv;
     SH7722DeviceData *sdev = dev;

     int x1 = rect->x;
     int y1 = rect->y;
     int x2 = rect->x + rect->w;
     int y2 = rect->y;
     int x3 = rect->x + rect->w;
     int y3 = rect->y + rect->h;
     int x4 = rect->x;
     int y4 = rect->y + rect->h;

     D_DEBUG_AT( SH7722_BLT, "%s( %d, %d - %dx%d )\n", __FUNCTION__,
                 DFB_RECTANGLE_VALS( rect ) );
     DUMP_INFO();

     if (sdev->render_options & DSRO_MATRIX) {
          int t;

          t  = ((x1 * sdev->matrix[0]) +
                (y1 * sdev->matrix[1]) + sdev->matrix[2]) >> 16;
          y1 = ((x1 * sdev->matrix[3]) +
                (y1 * sdev->matrix[4]) + sdev->matrix[5]) >> 16;
          x1 = t;

          t  = ((x2 * sdev->matrix[0]) +
                (y2 * sdev->matrix[1]) + sdev->matrix[2]) >> 16;
          y2 = ((x2 * sdev->matrix[3]) +
                (y2 * sdev->matrix[4]) + sdev->matrix[5]) >> 16;
          x2 = t;

          t  = ((x3 * sdev->matrix[0]) +
                (y3 * sdev->matrix[1]) + sdev->matrix[2]) >> 16;
          y3 = ((x3 * sdev->matrix[3]) +
                (y3 * sdev->matrix[4]) + sdev->matrix[5]) >> 16;
          x3 = t;

          t  = ((x4 * sdev->matrix[0]) +
                (y4 * sdev->matrix[1]) + sdev->matrix[2]) >> 16;
          y4 = ((x4 * sdev->matrix[3]) +
                (y4 * sdev->matrix[4]) + sdev->matrix[5]) >> 16;
          x4 = t;
     }

     if (sdev->render_options & DSRO_ANTIALIAS)
          draw_rectangle( sdrv, sdev, x1, y1, x2, y2, x3, y3, x4, y4, true,  rect->h > 1 && rect->w > 1 );

     draw_rectangle( sdrv, sdev, x1, y1, x2, y2, x3, y3, x4, y4, false, rect->h > 1 && rect->w > 1 );

     return true;
}

/*
 * Render a line using the current hardware state.
 */
static bool
sh7722DrawLine( void *drv, void *dev, DFBRegion *line )
{
     SH7722DriverData *sdrv = drv;
     SH7722DeviceData *sdev = dev;
     __u32            *prep = start_buffer( sdrv, 8 );

     D_DEBUG_AT( SH7722_BLT, "%s( %d, %d -> %d, %d )\n", __FUNCTION__,
                 DFB_REGION_VALS( line ) );
     DUMP_INFO();

     prep[0] = BEM_WR_V1;
     prep[1] = SH7722_XY( line->x1, line->y1 );

     prep[2] = BEM_WR_V2;
     prep[3] = SH7722_XY( line->x2, line->y2 );

     prep[4] = BEM_PE_OPERATION;
     prep[5] = (sdev->dflags & DSDRAW_BLEND) ? (BLE_FUNC_AxB_plus_CxD |
                                                sdev->ble_srcf |
                                                BLE_SRCA_FIXED |
                                                sdev->ble_dstf) : BLE_FUNC_NONE;

     if (sdev->dflags & DSDRAW_XOR)
          prep[5] |= BLE_ROP_XOR;

     prep[6] = BEM_WR_CTRL;
     prep[7] = WR_CTRL_LINE | WR_CTRL_ENDPOINT;

     submit_buffer( sdrv, 8 );

     return true;
}

static bool
sh7722DrawLineMatrix( void *drv, void *dev, DFBRegion *line )
{
     SH7722DriverData *sdrv = drv;
     SH7722DeviceData *sdev = dev;
     __u32            *prep = start_buffer( sdrv, 8 );

     D_DEBUG_AT( SH7722_BLT, "%s( %d, %d -> %d, %d )\n", __FUNCTION__,
                 DFB_REGION_VALS( line ) );
     DUMP_INFO();

     int x1 = ((line->x1 * sdev->matrix[0]) +
               (line->y1 * sdev->matrix[1]) + sdev->matrix[2]) >> 16;
     int y1 = ((line->x1 * sdev->matrix[3]) +
               (line->y1 * sdev->matrix[4]) + sdev->matrix[5]) >> 16;

     int x2 = ((line->x2 * sdev->matrix[0]) +
               (line->y2 * sdev->matrix[1]) + sdev->matrix[2]) >> 16;
     int y2 = ((line->x2 * sdev->matrix[3]) +
               (line->y2 * sdev->matrix[4]) + sdev->matrix[5]) >> 16;

     prep[0] = BEM_WR_V1;
     prep[1] = SH7722_XY( x1, y1 );

     prep[2] = BEM_WR_V2;
     prep[3] = SH7722_XY( x2, y2 );

     prep[4] = BEM_PE_OPERATION;
     prep[5] = (sdev->dflags & DSDRAW_BLEND) ? (BLE_FUNC_AxB_plus_CxD |
                                                sdev->ble_srcf |
                                                BLE_SRCA_FIXED |
                                                sdev->ble_dstf) : BLE_FUNC_NONE;

     if (sdev->dflags & DSDRAW_XOR)
          prep[5] |= BLE_ROP_XOR;

     prep[6] = BEM_WR_CTRL;
     prep[7] = WR_CTRL_LINE | WR_CTRL_ENDPOINT;

     submit_buffer( sdrv, 8 );

     return true;
}

static bool
sh7722DrawLineAA( void *drv, void *dev, DFBRegion *line )
{
     SH7722DriverData *sdrv = drv;
     SH7722DeviceData *sdev = dev;
     __u32            *prep = start_buffer( sdrv, 24 );
     int               x1, y1;
     int               x2, y2;

     D_DEBUG_AT( SH7722_BLT, "%s( %d, %d -> %d, %d )\n", __FUNCTION__,
                 DFB_REGION_VALS( line ) );
     DUMP_INFO();

     if (sdev->render_options & DSRO_MATRIX) {
          x1 = ((line->x1 * sdev->matrix[0]) +
                (line->y1 * sdev->matrix[1]) + sdev->matrix[2]) >> 16;
          y1 = ((line->x1 * sdev->matrix[3]) +
                (line->y1 * sdev->matrix[4]) + sdev->matrix[5]) >> 16;

          x2 = ((line->x2 * sdev->matrix[0]) +
                (line->y2 * sdev->matrix[1]) + sdev->matrix[2]) >> 16;
          y2 = ((line->x2 * sdev->matrix[3]) +
                (line->y2 * sdev->matrix[4]) + sdev->matrix[5]) >> 16;
     }
     else {
          x1 = line->x1;
          y1 = line->y1;
          x2 = line->x2;
          y2 = line->y2;
     }

     prep[0] = BEM_WR_FGC;
     prep[1] = PIXEL_ARGB( (sdev->color.a * AA_COEF) >> 8,
                           (sdev->color.r * AA_COEF) >> 8,
                           (sdev->color.g * AA_COEF) >> 8,
                           (sdev->color.b * AA_COEF) >> 8 );

     prep[2] = BEM_PE_FIXEDALPHA;
     prep[3] = (sdev->color.a * AA_COEF) << 16;

     prep[4] = BEM_WR_V1;
     prep[5] = SH7722_XY( x1, y1 );

     prep[6] = BEM_WR_V2;
     prep[7] = SH7722_XY( x2, y2 );

     prep[8] = BEM_PE_OPERATION;
     prep[9] = (sdev->dflags & DSDRAW_BLEND) ? (BLE_FUNC_AxB_plus_CxD |
                                                sdev->ble_srcf |
                                                BLE_SRCA_FIXED |
                                                sdev->ble_dstf)
                                             :
                                               (BLE_FUNC_AxB_plus_CxD |
                                                BLE_SRCF_ONE |
                                                BLE_SRCA_FIXED |
                                                BLE_DSTF_1_SRC_A);

     if (sdev->dflags & DSDRAW_XOR)
          prep[9] |= BLE_ROP_XOR;

     prep[10] = BEM_WR_CTRL;
     prep[11] = WR_CTRL_LINE | WR_CTRL_ENDPOINT | WR_CTRL_ANTIALIAS;



     prep[12] = BEM_WR_FGC;
     prep[13] = PIXEL_ARGB( sdev->color.a,
                            sdev->color.r,
                            sdev->color.g,
                            sdev->color.b );

     prep[14] = BEM_PE_FIXEDALPHA;
     prep[15] = (sdev->color.a << 24) | (sdev->color.a << 16);

     prep[16] = BEM_WR_V1;
     prep[17] = SH7722_XY( x1, y1 );

     prep[18] = BEM_WR_V2;
     prep[19] = SH7722_XY( x2, y2 );

     prep[20] = BEM_PE_OPERATION;
     prep[21] = (sdev->dflags & DSDRAW_BLEND) ? (BLE_FUNC_AxB_plus_CxD |
                                                 sdev->ble_srcf |
                                                 BLE_SRCA_FIXED |
                                                 sdev->ble_dstf) : BLE_FUNC_NONE;

     if (sdev->dflags & DSDRAW_XOR)
          prep[21] |= BLE_ROP_XOR;

     prep[22] = BEM_WR_CTRL;
     prep[23] = WR_CTRL_LINE | WR_CTRL_ENDPOINT;


     submit_buffer( sdrv, 24 );

     return true;
}

/*
 * Common implementation for Blit() and StretchBlit().
 */
static inline bool
sh7722DoBlit( SH7722DriverData *sdrv, SH7722DeviceData *sdev,
              DFBRectangle *rect, int x, int y, int w, int h )
{
     int    num  = 8;
     __u32 *prep = start_buffer( sdrv, 12 );

     D_DEBUG_AT( SH7722_BLT, "%s( %d, %d - %dx%d  ->  %d, %d - %dx%d )\n", __FUNCTION__,
                 DFB_RECTANGLE_VALS( rect ), x, y, w, h );
     DUMP_INFO();

     prep[0] = BEM_BE_SRC_LOC;

     /* Stencil mode needs a workaround, because the hardware always adds the source location. */
     if (sdev->bflags & DSBLIT_SRC_MASK_ALPHA && sdev->mask_flags & DSMF_STENCIL)
          prep[1] = SH7722_XY( 0, 0 );
     else
          prep[1] = SH7722_XY( rect->x, rect->y );

     prep[2] = BEM_BE_SRC_SIZE;
     prep[3] = SH7722_XY( rect->w, rect->h );

     prep[4] = BEM_BE_V1;
     prep[5] = SH7722_XY( x, y );

     prep[6] = BEM_BE_V2;
     prep[7] = SH7722_XY( w, h );

     /* Stencil mode needs a workaround, because the hardware always adds the source location. */
     if (sdev->bflags & DSBLIT_SRC_MASK_ALPHA && sdev->mask_flags & DSMF_STENCIL) {
          prep[num++] = BEM_TE_SRC_BASE;
          prep[num++] = sdev->src_phys + sdev->src_pitch * rect->y + sdev->src_bpp * rect->x;

          SH7722_INVALIDATE( SOURCE );
     }

     prep[num++] = BEM_BE_CTRL;
     prep[num++] = BE_CTRL_RECTANGLE | BE_CTRL_TEXTURE | BE_CTRL_SCANMODE_LINE;

     if (sdev->bflags & DSBLIT_ROTATE180)
          prep[num-1] |= BE_FLIP_BOTH;
     else if (rect->w == w && rect->h == h)  /* No blit direction handling for StretchBlit(). */
          prep[num-1] |= BE_CTRL_BLTDIR_AUTOMATIC;

     submit_buffer( sdrv, num );

     return true;
}

/*
 * This version sends a quadrangle to have all four edges transformed.
 */
__attribute__((noinline))
static bool
sh7722DoBlitM( SH7722DriverData *sdrv, SH7722DeviceData *sdev,
               DFBRectangle *rect, int x1, int y1, int x2, int y2 )
{
     int    num  = 12;
     __u32 *prep = start_buffer( sdrv, 16 );

     D_DEBUG_AT( SH7722_BLT, "%s( %d, %d - %dx%d  ->  %d, %d - %d, %d )\n", __FUNCTION__,
                 DFB_RECTANGLE_VALS( rect ), x1, y1, x2, y2 );
     DUMP_INFO();

     prep[0]  = BEM_BE_SRC_LOC;

     /* Stencil mode needs a workaround, because the hardware always adds the source location. */
     if (sdev->bflags & DSBLIT_SRC_MASK_ALPHA && sdev->mask_flags & DSMF_STENCIL)
          prep[1] = SH7722_XY( 0, 0 );
     else
          prep[1] = SH7722_XY( rect->x, rect->y );
             
     prep[2]  = BEM_BE_SRC_SIZE;
     prep[3]  = SH7722_XY( rect->w, rect->h );
             
     prep[4]  = BEM_BE_V1;
     prep[5]  = SH7722_XY( x1, y1 );
             
     prep[6]  = BEM_BE_V2;
     prep[7]  = SH7722_XY( x1, y2 );
             
     prep[8]  = BEM_BE_V3;
     prep[9]  = SH7722_XY( x2, y1 );

     prep[10] = BEM_BE_V4;
     prep[11] = SH7722_XY( x2, y2 );

     /* Stencil mode needs a workaround, because the hardware always adds the source location. */
     if (sdev->bflags & DSBLIT_SRC_MASK_ALPHA && sdev->mask_flags & DSMF_STENCIL) {
          prep[num++] = BEM_TE_SRC_BASE;
          prep[num++] = sdev->src_phys + sdev->src_pitch * rect->y + sdev->src_bpp * rect->x;

          SH7722_INVALIDATE( SOURCE );
     }

     prep[num++] = BEM_BE_CTRL;
     prep[num++] = BE_CTRL_QUADRANGLE | BE_CTRL_TEXTURE | BE_CTRL_SCANMODE_4x4 |
                   BE_CTRL_MATRIX | BE_CTRL_FIXMODE_16_16;// | BE_CTRL_ORIGIN;

     if (sdev->bflags & DSBLIT_ROTATE180)
          prep[num-1] |= BE_FLIP_BOTH;

     submit_buffer( sdrv, num );

     return true;
}

/*
 * Blit a rectangle using the current hardware state.
 */
bool
sh7722Blit( void *drv, void *dev, DFBRectangle *rect, int x, int y )
{
     SH7722DriverData *sdrv = drv;
     SH7722DeviceData *sdev = dev;

     D_DEBUG_AT( SH7722_BLT, "%s( %d, %d - %dx%d  -> %d, %d )\n",
                 __FUNCTION__, DFB_RECTANGLE_VALS( rect ), x, y );

     if (sdev->render_options & DSRO_MATRIX)
          return sh7722DoBlitM( sdrv, sdev, rect, DFB_REGION_VALS_FROM_RECTANGLE_VALS( x, y, rect->w, rect->h ) );

     return sh7722DoBlit( sdrv, sdev, rect, x, y, rect->w, rect->h );
}

/*
 * StretchBlit a rectangle using the current hardware state.
 */
bool
sh7722StretchBlit( void *drv, void *dev, DFBRectangle *srect, DFBRectangle *drect )
{
     SH7722DriverData *sdrv = drv;
     SH7722DeviceData *sdev = dev;

     D_DEBUG_AT( SH7722_BLT, "%s( %d, %d - %dx%d  -> %d, %d - %dx%d )\n",
                 __FUNCTION__, DFB_RECTANGLE_VALS( srect ), DFB_RECTANGLE_VALS( drect ) );

     if (sdev->render_options & DSRO_MATRIX)
          return sh7722DoBlitM( sdrv, sdev, srect, DFB_REGION_VALS_FROM_RECTANGLE( drect ) );

     return sh7722DoBlit( sdrv, sdev, srect, drect->x, drect->y, drect->w, drect->h );
}

