From 27d1e03d7bdf8fcfe7292c06e40bc3e2fca9158e Mon Sep 17 00:00:00 2001
From: Denis Oliver Kropp <dok@directfb.org>
Date: Tue, 19 Oct 2010 15:56:15 +0200
Subject: pluggit

---
 src/classes.cpp | 4047 +++++++++++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 4047 insertions(+)
 create mode 100644 src/classes.cpp

(limited to 'src/classes.cpp')

diff --git a/src/classes.cpp b/src/classes.cpp
new file mode 100644
index 0000000..a0ecb67
--- /dev/null
+++ b/src/classes.cpp
@@ -0,0 +1,4047 @@
+# 1 "classes.h"
+#define DIRECT_ENABLE_DEBUG
+
+
+#include <iostream>
+#include <vector>
+
+using namespace std;
+
+
+/*
+ * ++DFB
+ */
+#include <++dfb.h>
+
+
+
+/*
+ * Direct
+ */
+extern "C" {
+#include <stdarg.h>
+
+#include <direct/clock.h>
+#include <direct/debug.h>
+#include <direct/memcpy.h>
+#include <direct/messages.h>
+#include <direct/thread.h>
+#include <direct/util.h>
+
+#include <gfx/convert.h>
+}
+
+
+/*
+ * Win32
+ */
+#ifdef __WIN32__
+#define CreateWindow CreateWindowWin32
+#include <windows.h>
+#include <wingdi.h>
+#include <winuser.h>
+#include "videodriver.h"
+#undef CreateWindow
+
+#else
+
+/*
+ * X11
+ */
+extern "C" {
+#include <X11/Xlib.h>    /* fundamentals X datas structures */
+#include <X11/Xutil.h>   /* datas definitions for various functions */
+#include <X11/keysym.h>  /* for a perfect use of keyboard events */
+#include <X11/Xatom.h>
+#include <X11/cursorfont.h>
+
+#include <X11/extensions/XShm.h>
+#include <X11/extensions/Xdamage.h>
+#include <sys/ipc.h>
+#include <sys/shm.h>
+}
+
+#endif
+
+class Exception;
+class OutOfMemoryException;
+class Clock;
+class FPS;
+class Options;
+class Random;
+class Updates;
+class Runnable;
+class Thread;
+class Scaler;
+class View;
+class Source;
+class SourceWin32;
+class Main;
+# 1 "Exception.cxx"
+# 1 "<built-in>"
+# 1 "<command-line>"
+# 1 "Exception.cxx"
+namespace PluggIt {
+
+class Exception
+{
+     private: string m_message;
+
+
+     public: Exception( string message ) {
+          m_message = message;
+     }
+
+     public: Exception( const char *format, ... ) D_FORMAT_PRINTF(2) {
+          va_list args;
+          int len;
+          char buf[200];
+          char *ptr = buf;
+
+          va_start( args, format );
+          len = vsnprintf( buf, sizeof(buf), format, args );
+          va_end( args );
+
+          if (len < 0)
+               abort();
+
+          if (len >= (int)sizeof(buf)) {
+               ptr = (char*) malloc( len+1 );
+               if (!ptr)
+                    abort();
+
+               va_start( args, format );
+               len = vsnprintf( ptr, len+1, format, args );
+               va_end( args );
+
+               if (len < 0) {
+                    free( ptr );
+                    abort();
+               }
+          }
+
+          m_message = string( ptr );
+
+          if (ptr != buf)
+               free( ptr );
+     }
+
+     public: string getMessage() {
+          return m_message;
+     }
+
+
+     friend std::ostream &operator << (std::ostream &stream, Exception *ex) {
+          stream << ex->getMessage();
+
+          return stream;
+     }
+};
+
+}
+# 1 "OutOfMemoryException.cxx"
+# 1 "<built-in>"
+# 1 "<command-line>"
+# 1 "OutOfMemoryException.cxx"
+namespace PluggIt {
+
+class OutOfMemoryException :public Exception
+{
+     public: OutOfMemoryException() : Exception( "Out of memory!" ) {
+     }
+};
+
+}
+# 1 "Clock.cxx"
+# 1 "<built-in>"
+# 1 "<command-line>"
+# 1 "Clock.cxx"
+namespace PluggIt {
+
+class Clock
+{
+     private: long long base;
+     private: char str[20];
+
+     public: Clock() {
+          Reset();
+     }
+
+     public: void Reset() {
+          base = direct_clock_get_micros();
+     }
+
+     public: float GetTime() {
+          return (direct_clock_get_micros() - base) / 1000000.0f;
+     }
+
+     public: const char *GetString() {
+          float time = GetTime();
+          int seconds = (int) time;
+          int minutes = seconds / 60;
+
+          snprintf( str, sizeof(str), "%02d:%02d", minutes, seconds );
+
+          return str;
+     }
+};
+
+}
+# 1 "FPS.cxx"
+# 1 "<built-in>"
+# 1 "<command-line>"
+# 1 "FPS.cxx"
+namespace PluggIt {
+
+class FPS
+{
+     private: int frames;
+     private: char str[20];
+
+     private: Clock clock;
+
+
+     public: FPS() {
+          Reset();
+     }
+
+     public: void Reset() {
+          frames = 0;
+          str[0] = 0;
+
+          clock.Reset();
+     }
+
+     public: void Count( float interval ) {
+          float time = clock.GetTime();
+
+          frames++;
+
+          if (time >= interval) {
+               float fps = frames / time;
+
+               snprintf( str, sizeof(str), "%.1f", fps );
+
+               frames = 0;
+               clock.Reset();
+          }
+     }
+
+     public: const char *GetFPS() {
+          return str;
+     }
+};
+
+}
+# 1 "Options.cxx"
+# 1 "<built-in>"
+# 1 "<command-line>"
+# 1 "Options.cxx"
+namespace PluggIt {
+
+static const DirectFBPixelFormatNames(m_formats);
+
+class Options
+{
+     class Option {
+          friend class Options;
+
+          protected: const char *m_short_name;
+          protected: const char *m_long_name;
+          protected: const char *m_arg_name;
+          protected: const char *m_arg_desc;
+          protected: bool m_need_arg;
+
+          public: Option( const char *short_name,
+                         const char *long_name,
+                         const char *arg_name,
+                         const char *arg_desc )
+          {
+               m_short_name = short_name;
+               m_long_name = long_name;
+               m_arg_name = arg_name;
+               m_arg_desc = arg_desc;
+               m_need_arg = true;
+          }
+
+          public: virtual bool Parse( const char *arg ) = 0;
+     };
+
+     public: class OptionBool :public Option {
+          private: bool &m_value;
+
+          public: OptionBool( const char *short_name,
+                             const char *long_name,
+                             const char *arg_name,
+                             const char *arg_desc,
+                             bool &value ) : Option( short_name, long_name, arg_name, arg_desc ), m_value( value )
+          {
+               m_need_arg = false;
+          }
+
+          public: virtual bool Parse( const char *arg ) {
+               m_value = true;
+
+               return true;
+          }
+     };
+
+     public: class OptionLong :public Option {
+          private: long &m_value;
+          private: int m_base;
+
+          public: OptionLong( const char *short_name,
+                             const char *long_name,
+                             const char *arg_name,
+                             const char *arg_desc,
+                             long &value,
+                             int base = 10 ) : Option( short_name, long_name, arg_name, arg_desc ), m_value( value )
+          {
+               m_base = base;
+          }
+
+          public: virtual bool Parse( const char *arg ) {
+               long ret;
+               char *end;
+
+               ret = strtol( arg, &end, m_base );
+
+               if (*end) {
+                    D_ERROR( "Option/Long: Invalid argument to '%s' or '%s'!\n", m_short_name, m_long_name );
+                    return false;
+               }
+
+               m_value = ret;
+
+               return true;
+          }
+     };
+
+     public: class OptionULong :public Option {
+          private: unsigned long &m_value;
+          private: int m_base;
+
+          public: OptionULong( const char *short_name,
+                              const char *long_name,
+                              const char *arg_name,
+                              const char *arg_desc,
+                              unsigned long &value,
+                              int base = 10 ) : Option( short_name, long_name, arg_name, arg_desc ), m_value( value )
+          {
+               m_base = base;
+          }
+
+          public: virtual bool Parse( const char *arg ) {
+               unsigned long ret;
+               char *end;
+
+               ret = strtoul( arg, &end, m_base );
+
+               if (*end) {
+                    D_ERROR( "Option/ULong: Invalid argument to '%s' or '%s'!\n", m_short_name, m_long_name );
+                    return false;
+               }
+
+               m_value = ret;
+
+               return true;
+          }
+     };
+
+     public: class OptionFormat :public Option {
+          private: DFBSurfacePixelFormat &m_value;
+
+          public: OptionFormat( const char *short_name,
+                               const char *long_name,
+                               const char *arg_name,
+                               const char *arg_desc,
+                               DFBSurfacePixelFormat &value ) : Option( short_name, long_name, arg_name, arg_desc ), m_value( value )
+          {
+          }
+
+          public: virtual bool Parse( const char *arg ) {
+               unsigned int i;
+
+               for (i=0; i<D_ARRAY_SIZE(m_formats); i++) {
+                    if (!strcasecmp( m_formats[i].name, arg )) {
+                         m_value = m_formats[i].format;
+
+                         return true;
+                    }
+               }
+
+               D_ERROR( "Option/Format: Unknown format '%s' passed to '%s' or '%s'!\n", arg, m_short_name, m_long_name );
+
+               return false;
+          }
+     };
+
+     public: class OptionString :public Option {
+          private: std::string &m_value;
+
+          public: OptionString( const char *short_name,
+                               const char *long_name,
+                               const char *arg_name,
+                               const char *arg_desc,
+                               std::string &value ) : Option( short_name, long_name, arg_name, arg_desc ), m_value( value )
+          {
+          }
+
+          public: virtual bool Parse( const char *arg ) {
+               m_value = arg;
+               return true;
+          }
+     };
+
+     public: class OptionPoint :public Option {
+          private: DFBPoint &m_value;
+
+          public: OptionPoint( const char *short_name,
+                              const char *long_name,
+                              const char *arg_name,
+                              const char *arg_desc,
+                              DFBPoint &value ) : Option( short_name, long_name, arg_name, arg_desc ), m_value( value )
+          {
+          }
+
+          public: virtual bool Parse( const char *arg ) {
+               if (sscanf( arg, "%d,%d", &m_value.x, &m_value.y ) != 2) {
+                    D_ERROR( "Option/Point: Invalid argument to '%s' or '%s'!\n", m_short_name, m_long_name );
+                    return false;
+               }
+
+               return true;
+          }
+     };
+
+     public: class OptionDimension :public Option {
+          private: DFBDimension &m_value;
+
+          public: OptionDimension( const char *short_name,
+                                  const char *long_name,
+                                  const char *arg_name,
+                                  const char *arg_desc,
+                                  DFBDimension &value ) : Option( short_name, long_name, arg_name, arg_desc ), m_value( value )
+          {
+          }
+
+          public: virtual bool Parse( const char *arg ) {
+               if (sscanf( arg, "%dx%d", &m_value.w, &m_value.h ) != 2) {
+                    D_ERROR( "Option/Dimension: Invalid argument to '%s' or '%s'!\n", m_short_name, m_long_name );
+                    return false;
+               }
+
+               return true;
+          }
+     };
+
+
+
+     private: vector<Option*> m_options;
+
+     public: void addOption( Option *option ) {
+          m_options.push_back( option );
+     }
+
+     public: bool parseCommandLine( int argc, char *argv[] ) {
+          int n;
+
+          for (n = 1; n < argc; n++) {
+               bool ok = false;
+               const char *arg = argv[n];
+
+               if (strcmp (arg, "-h") == 0 || strcmp (arg, "--help") == 0) {
+                    printUsage (argv[0]);
+                    return false;
+               }
+
+               if (strcmp (arg, "-v") == 0 || strcmp (arg, "--version") == 0) {
+
+                    return false;
+               }
+
+               vector<Option*>::iterator itr = m_options.begin();
+
+               for (; itr != m_options.end(); itr++) {
+                    Option *option = *itr;
+
+                    if (!strcmp (arg, option->m_short_name) || !strcmp (arg, option->m_long_name)) {
+                         if (option->m_need_arg && ++n == argc) {
+                              printUsage (argv[0]);
+                              return false;
+                         }
+
+                         if (!option->Parse( argv[n] ))
+                              return false;
+
+                         ok = true;
+
+                         break;
+                    }
+               }
+
+               if (!ok) {
+                    printUsage (argv[0]);
+                    return false;
+               }
+          }
+
+          return true;
+     }
+
+     public: void printUsage( const char *prg_name ) {
+
+          fprintf (stderr, "Usage: %s [options]\n\n", prg_name);
+          fprintf (stderr, "Options:\n");
+          fprintf (stderr, "   -h   --help                             Show this help message\n");
+          fprintf (stderr, "   -v   --version                          Print version information\n");
+
+
+          vector<Option*>::const_iterator itr = m_options.begin();
+
+          for (; itr != m_options.end(); itr++) {
+               const Option *option = *itr;
+
+               fprintf( stderr, "   %-3s  %-16s   %-12s    %s\n",
+                        option->m_short_name, option->m_long_name, option->m_arg_name, option->m_arg_desc );
+          }
+
+          fprintf( stderr, "\n" );
+     }
+};
+
+}
+# 1 "Random.cxx"
+# 1 "<built-in>"
+# 1 "<command-line>"
+# 1 "Random.cxx"
+namespace PluggIt {
+
+class Random
+{
+     public: static float nextFloat( float min, float max ) {
+          return min + rand() * (max - min) / (float) RAND_MAX;
+     }
+};
+
+}
+# 1 "Updates.cxx"
+# 1 "<built-in>"
+# 1 "<command-line>"
+# 1 "Updates.cxx"
+namespace PluggIt {
+
+class Updates
+{
+     private: DFBUpdates m_updates;
+     private: DFBRegion *m_regions;
+
+     public: Updates( unsigned int max_regions = 8 ) {
+          m_regions = (DFBRegion*) D_CALLOC( max_regions ?: 1, sizeof(DFBRegion) );
+
+          dfb_updates_init( &m_updates, m_regions, max_regions );
+     }
+
+     virtual ~Updates() {
+          dfb_updates_deinit( &m_updates );
+
+          D_FREE( m_regions );
+     }
+
+
+     public: void addRegion( const DFBRegion &region ) {
+          dfb_updates_add( &m_updates, &region );
+     }
+
+     public: DFBRegion bounding() const {
+          return m_updates.bounding;
+     }
+
+     public: void get_rectangles( DFBRectangle *ret_rects, int *ret_num ) {
+          dfb_updates_get_rectangles( &m_updates, ret_rects, ret_num );
+     }
+
+     public: unsigned int num_regions() const {
+          return m_updates.num_regions;
+     }
+
+     public: void reset() {
+          dfb_updates_reset( &m_updates );
+     }
+
+
+     public: void GetRectangles( vector<DFBRectangle_C> &rects ) {
+          D_MAGIC_ASSERT( &m_updates, DFBUpdates );
+          D_ASSERT( m_updates.regions != NULL );
+          D_ASSERT( m_updates.num_regions >= 0 );
+          D_ASSERT( m_updates.num_regions <= m_updates.max_regions );
+
+          switch (m_updates.num_regions) {
+               case 0:
+                    break;
+
+               default: {
+                    int n, d, total, bounding;
+
+                    dfb_updates_stat( &m_updates, &total, &bounding );
+
+                    n = m_updates.max_regions - m_updates.num_regions + 1;
+                    d = n + 1;
+
+
+                    if (total < bounding * n / d) {
+                         for (n=0; n<m_updates.num_regions; n++)
+                              rects.push_back( DFBRectangle( m_updates.regions[n] ) );
+
+                         break;
+                    }
+               }
+
+
+               case 1:
+                    rects.push_back( DFBRectangle( m_updates.bounding ) );
+                    break;
+          }
+     }
+};
+
+}
+# 1 "Runnable.cxx"
+# 1 "<built-in>"
+# 1 "<command-line>"
+# 1 "Runnable.cxx"
+namespace PluggIt {
+
+class Runnable
+{
+     public: virtual void run() = 0;
+};
+
+}
+# 1 "Thread.cxx"
+# 1 "<built-in>"
+# 1 "<command-line>"
+# 1 "Thread.cxx"
+namespace PluggIt {
+
+class Thread
+{
+     private: Runnable *m_target;
+     private: string m_name;
+
+     private: DirectThread *m_thread;
+     private: volatile bool m_interrupted;
+
+
+     public: Thread( Runnable *target, string name = "" ) {
+          m_target = target;
+          m_name = name;
+
+          m_thread = NULL;
+          m_interrupted = false;
+     }
+
+     virtual ~Thread() {
+          if (m_thread)
+               direct_thread_destroy( m_thread );
+     }
+
+     public: bool start() {
+          if (m_thread)
+               return false;
+
+          m_thread = direct_thread_create( DTT_DEFAULT, main, m_target, m_name.c_str() );
+
+          return m_thread != NULL;
+     }
+
+     public: bool interrupt() {
+          if (!m_thread)
+               return false;
+
+          m_interrupted = true;
+
+          return true;
+     }
+
+     public: bool isInterrupted() {
+          return m_interrupted;
+     }
+
+     public: bool join() {
+          if (!m_thread)
+               return false;
+
+          direct_thread_join( m_thread );
+          direct_thread_destroy( m_thread );
+
+          m_thread = NULL;
+          m_interrupted = false;
+
+          return true;
+     }
+
+
+     private: static void *main( DirectThread *thread, void *arg ) {
+          Runnable *target = (Runnable*) arg;
+
+          target->run();
+
+          return NULL;
+     }
+};
+
+}
+# 1 "Scaler.cxx"
+# 1 "<built-in>"
+# 1 "<command-line>"
+# 1 "Scaler.cxx"
+namespace PluggIt {
+
+D_DEBUG_DOMAIN( PluggIt_Scaler, "PluggIt/Scaler", "PluggIt Scaler" );
+
+
+typedef struct {
+     DFBRegion clip;
+     const void *colors;
+     unsigned long protect;
+     unsigned long key;
+} StretchCtx;
+
+typedef void (*StretchHVx)( void *dst,
+                            int dpitch,
+                            const void *src,
+                            int spitch,
+                            int width,
+                            int height,
+                            int dst_width,
+                            int dst_height,
+                            const StretchCtx *ctx );
+# 47 "Scaler.cxx"
+# 1 "stretch_up_down_16.h" 1
+# 20 "stretch_up_down_16.h"
+# 1 "stretch_hvx_N.h" 1
+# 9 "stretch_hvx_N.h"
+static void stretch_hvx_RGB16_up____DSPF_RGB16
+# 1 "stretch_hvx_16.h" 1
+# 35 "stretch_hvx_16.h"
+                                ( void *dst,
+                                  int dpitch,
+                                  const void *src,
+                                  int spitch,
+                                  int width,
+                                  int height,
+                                  int dst_width,
+                                  int dst_height,
+                                  const StretchCtx *ctx )
+{
+     long x, y, r = 0;
+     long head = ((((unsigned long) dst) & 2) >> 1) ^ (ctx->clip.x1 & 1);
+     long cw = ctx->clip.x2 - ctx->clip.x1 + 1;
+     long ch = ctx->clip.y2 - ctx->clip.y1 + 1;
+     long tail = (cw - head) & 1;
+     long w2 = (cw - head) / 2;
+     long hfraq = ((long)(width - 1) << 18) / (long)(dst_width);
+     long vfraq = ((long)(height - 1) << 18) / (long)(dst_height);
+     long dp4 = dpitch / 4;
+     long point0 = 0 + ctx->clip.x1 * hfraq;
+     long point = point0;
+     long line = 0 + ctx->clip.y1 * vfraq;
+     long ratios[cw];
+     u32 *dst32;
+
+
+
+
+
+
+     u32 _lbT[w2+8];
+     u32 _lbB[w2+8];
+
+     u32 *lbX;
+     u32 *lbT = (u32*)((((unsigned long)(&_lbT[0])) + 31) & ~31);
+     u32 *lbB = (u32*)((((unsigned long)(&_lbB[0])) + 31) & ~31);
+
+     long lineT = -2000;
+
+     for (x=0; x<cw; x++) {
+          ratios[x] = ( ((point) & 0x3ffff) >> (18-6) );
+
+          point += hfraq;
+     }
+
+     do {} while (0);
+
+
+     dst = (void*)((char*) dst + ctx->clip.x1 * 2 + ctx->clip.y1 * dpitch);
+
+     dst32 = (u32*) dst;
+
+     if (head) {
+          u32 dpT, dpB, L, R;
+
+          u16 *dst16 = (u16*) dst;
+
+          point = point0;
+
+          for (y=0; y<ch; y++) {
+               long X = ( ((line) & 0x3ffff) >> (18-5) );
+
+               const u16 *srcT = (const u16 *)((char*) src + spitch * ( (((line)) >> 18) ));
+               const u16 *srcB = (const u16 *)((char*) src + spitch * ( (((line)) >> 18) + 1 ));
+
+
+
+
+               long pl = ( (((point)) >> 18) );
+               do {} while (0);
+
+               D_ASSERT( pl >= 0 );
+               D_ASSERT( pl < width-1 );
+               L = (srcT[pl]);
+               R = (srcT[pl+1]);
+
+               dpT = (((((R & 0xf81f)-(L & 0xf81f))*ratios[r] + ((L & 0xf81f)<<6)) & (0xf81f<<6)) +
+                      ((((R & 0x07e0)-(L & 0x07e0))*ratios[r] + ((L & 0x07e0)<<6)) & (0x07e0<<6))) >> 6;
+
+               L = (srcB[pl]);
+               R = (srcB[pl+1]);
+
+               dpB = (((((R & 0xf81f)-(L & 0xf81f))*ratios[r] + ((L & 0xf81f)<<6)) & (0xf81f<<6)) +
+                      ((((R & 0x07e0)-(L & 0x07e0))*ratios[r] + ((L & 0x07e0)<<6)) & (0x07e0<<6))) >> 6;
+# 138 "stretch_hvx_16.h"
+               dst16[0] = ((((((dpB & 0xf81f) - (dpT & 0xf81f))*X) >> 5) + (dpT & 0xf81f)) & 0xf81f) +
+                          ((((((dpB>>5) & (0x07e0>>5)) - ((dpT>>5) & (0x07e0>>5)))*X) + (dpT & 0x07e0)) & 0x07e0);
+
+
+               dst16 += dpitch / 2;
+               line += vfraq;
+          }
+
+
+          point0 += hfraq;
+          dst32 = (u32*)((char*) dst + 2);
+
+
+          line = 0 + ctx->clip.y1 * vfraq;
+     }
+
+
+
+
+     for (y=0; y<ch; y++) {
+          long X;
+          long nlT = ( (((line)) >> 18) );
+
+          D_ASSERT( nlT >= 0 );
+          D_ASSERT( nlT < height-1 );
+
+
+
+
+          if (nlT != lineT) {
+               u32 L, R, dpT, dpB;
+               const u16 *srcT = (const u16 *)((char*) src + spitch * nlT);
+               const u16 *srcB = (const u16 *)((char*) src + spitch * (nlT + 1));
+               long diff = nlT - lineT;
+
+               if (diff > 1) {
+
+
+
+                    for (x=0, r=head, point=point0; x<w2; x++) {
+
+
+
+                         long pl = ( (((point)) >> 18) );
+                         do {} while (0);
+
+                         D_ASSERT( pl >= 0 );
+                         D_ASSERT( pl < width-1 );
+                         L = (srcT[pl]);
+                         R = (srcT[pl+1]);
+
+                         dpT = (((((R & 0xf81f)-(L & 0xf81f))*ratios[r] + ((L & 0xf81f)<<6)) & (0xf81f<<6)) +
+                                ((((R & 0x07e0)-(L & 0x07e0))*ratios[r] + ((L & 0x07e0)<<6)) & (0x07e0<<6)))
+
+
+
+                              >> 6;
+
+
+                         L = (srcB[pl]);
+                         R = (srcB[pl+1]);
+
+                         dpB = (((((R & 0xf81f)-(L & 0xf81f))*ratios[r] + ((L & 0xf81f)<<6)) & (0xf81f<<6)) +
+                                ((((R & 0x07e0)-(L & 0x07e0))*ratios[r] + ((L & 0x07e0)<<6)) & (0x07e0<<6)))
+
+
+
+                              >> 6;
+
+
+                         point += hfraq;
+                         r++;
+
+
+                         pl = ( (((point)) >> 18) );
+                         do {} while (0);
+
+                         D_ASSERT( pl >= 0 );
+                         D_ASSERT( pl < width-1 );
+
+                         L = (srcT[pl]);
+                         R = (srcT[pl+1]);
+
+                         dpT |= (((((R & 0xf81f)-(L & 0xf81f))*ratios[r] + ((L & 0xf81f)<<6)) & (0xf81f<<6)) +
+                                 ((((R & 0x07e0)-(L & 0x07e0))*ratios[r] + ((L & 0x07e0)<<6)) & (0x07e0<<6)))
+
+
+
+                              << (16-6);
+
+
+                         L = (srcB[pl]);
+                         R = (srcB[pl+1]);
+
+                         dpB |= (((((R & 0xf81f)-(L & 0xf81f))*ratios[r] + ((L & 0xf81f)<<6)) & (0xf81f<<6)) +
+                                 ((((R & 0x07e0)-(L & 0x07e0))*ratios[r] + ((L & 0x07e0)<<6)) & (0x07e0<<6)))
+
+
+
+                              << (16-6);
+
+
+                         point += hfraq;
+                         r++;
+
+
+                         lbT[x] = dpT;
+                         lbB[x] = dpB;
+                    }
+               }
+               else {
+
+                    lbX = lbT;
+                    lbT = lbB;
+                    lbB = lbX;
+
+
+
+
+                    for (x=0, r=head, point=point0; x<w2; x++) {
+
+
+
+                         long pl = ( (((point)) >> 18) );
+                         do {} while (0);
+
+                         D_ASSERT( pl >= 0 );
+                         D_ASSERT( pl < width-1 );
+                         L = (srcB[pl]);
+                         R = (srcB[pl+1]);
+
+                         dpB = (((((R & 0xf81f)-(L & 0xf81f))*ratios[r] + ((L & 0xf81f)<<6)) & (0xf81f<<6)) +
+                                ((((R & 0x07e0)-(L & 0x07e0))*ratios[r] + ((L & 0x07e0)<<6)) & (0x07e0<<6)))
+
+
+
+                              >> 6;
+
+
+                         point += hfraq;
+                         r++;
+
+
+                         pl = ( (((point)) >> 18) );
+                         do {} while (0);
+
+                         D_ASSERT( pl >= 0 );
+                         D_ASSERT( pl < width-1 );
+
+                         L = (srcB[pl]);
+                         R = (srcB[pl+1]);
+
+                         dpB |= (((((R & 0xf81f)-(L & 0xf81f))*ratios[r] + ((L & 0xf81f)<<6)) & (0xf81f<<6)) +
+                                 ((((R & 0x07e0)-(L & 0x07e0))*ratios[r] + ((L & 0x07e0)<<6)) & (0x07e0<<6)))
+
+
+
+                              << (16-6);
+
+
+                         point += hfraq;
+                         r++;
+
+
+                         lbB[x] = dpB;
+                    }
+               }
+
+               lineT = nlT;
+          }
+
+
+
+
+          X = ( ((line) & 0x3ffff) >> (18-5) );
+
+          for (x=0; x<w2; x++) {
+# 371 "stretch_hvx_16.h"
+               dst32[x] = ((((((lbB[x] & ((0x07e0<<16) | 0xf81f)) - (lbT[x] & ((0x07e0<<16) | 0xf81f)))*X) >> 5) + (lbT[x] & ((0x07e0<<16) | 0xf81f))) & ((0x07e0<<16) | 0xf81f)) +
+                          ((((((lbB[x]>>5) & (((0xf81f<<16) | 0x07e0)>>5)) - ((lbT[x]>>5) & (((0xf81f<<16) | 0x07e0)>>5)))*X) + (lbT[x] & ((0xf81f<<16) | 0x07e0))) & ((0xf81f<<16) | 0x07e0));
+
+
+          }
+
+          dst32 += dp4;
+          line += vfraq;
+     }
+
+     if (tail) {
+          u32 dpT, dpB, L, R;
+
+          u16 *dst16 = (u16*)((char*) dst + cw * 2 - 2);
+
+
+          line = 0 + ctx->clip.y1 * vfraq;
+
+          for (y=0; y<ch; y++) {
+               long X = ( ((line) & 0x3ffff) >> (18-5) );
+
+               const u16 *srcT = (const u16 *)((char*) src + spitch * ( (((line)) >> 18) ));
+               const u16 *srcB = (const u16 *)((char*) src + spitch * ( (((line)) >> 18) + 1 ));
+
+
+
+
+               long pl = ( (((point)) >> 18) );
+               do {} while (0);
+
+               D_ASSERT( pl >= 0 );
+               D_ASSERT( pl < width-1 );
+               L = (srcT[pl]);
+               R = (srcT[pl+1]);
+
+               dpT = (((((R & 0xf81f)-(L & 0xf81f))*ratios[r] + ((L & 0xf81f)<<6)) & (0xf81f<<6)) +
+                      ((((R & 0x07e0)-(L & 0x07e0))*ratios[r] + ((L & 0x07e0)<<6)) & (0x07e0<<6))) >> 6;
+
+               L = (srcB[pl]);
+               R = (srcB[pl+1]);
+
+               dpB = (((((R & 0xf81f)-(L & 0xf81f))*ratios[r] + ((L & 0xf81f)<<6)) & (0xf81f<<6)) +
+                      ((((R & 0x07e0)-(L & 0x07e0))*ratios[r] + ((L & 0x07e0)<<6)) & (0x07e0<<6))) >> 6;
+# 434 "stretch_hvx_16.h"
+               dst16[0] = ((((((dpB & 0xf81f) - (dpT & 0xf81f))*X) >> 5) + (dpT & 0xf81f)) & 0xf81f) +
+                          ((((((dpB>>5) & (0x07e0>>5)) - ((dpT>>5) & (0x07e0>>5)))*X) + (dpT & 0x07e0)) & 0x07e0);
+
+
+               dst16 += dpitch / 2;
+               line += vfraq;
+          }
+     }
+}
+# 11 "stretch_hvx_N.h" 2
+# 20 "stretch_hvx_N.h"
+static void stretch_hvx_RGB16_up____DSPF_RGB32
+# 1 "stretch_hvx_16.h" 1
+# 35 "stretch_hvx_16.h"
+                                ( void *dst,
+                                  int dpitch,
+                                  const void *src,
+                                  int spitch,
+                                  int width,
+                                  int height,
+                                  int dst_width,
+                                  int dst_height,
+                                  const StretchCtx *ctx )
+{
+     long x, y, r = 0;
+     long head = ((((unsigned long) dst) & 2) >> 1) ^ (ctx->clip.x1 & 1);
+     long cw = ctx->clip.x2 - ctx->clip.x1 + 1;
+     long ch = ctx->clip.y2 - ctx->clip.y1 + 1;
+     long tail = (cw - head) & 1;
+     long w2 = (cw - head) / 2;
+     long hfraq = ((long)(width - 1) << 18) / (long)(dst_width);
+     long vfraq = ((long)(height - 1) << 18) / (long)(dst_height);
+     long dp4 = dpitch / 4;
+     long point0 = 0 + ctx->clip.x1 * hfraq;
+     long point = point0;
+     long line = 0 + ctx->clip.y1 * vfraq;
+     long ratios[cw];
+     u32 *dst32;
+
+
+
+
+
+
+     u32 _lbT[w2+8];
+     u32 _lbB[w2+8];
+
+     u32 *lbX;
+     u32 *lbT = (u32*)((((unsigned long)(&_lbT[0])) + 31) & ~31);
+     u32 *lbB = (u32*)((((unsigned long)(&_lbB[0])) + 31) & ~31);
+
+     long lineT = -2000;
+
+     for (x=0; x<cw; x++) {
+          ratios[x] = ( ((point) & 0x3ffff) >> (18-6) );
+
+          point += hfraq;
+     }
+
+     do {} while (0);
+
+
+     dst = (void*)((char*) dst + ctx->clip.x1 * 2 + ctx->clip.y1 * dpitch);
+
+     dst32 = (u32*) dst;
+
+     if (head) {
+          u32 dpT, dpB, L, R;
+
+          u16 *dst16 = (u16*) dst;
+
+          point = point0;
+
+          for (y=0; y<ch; y++) {
+               long X = ( ((line) & 0x3ffff) >> (18-5) );
+
+               const u32 *srcT = (const u32 *)((char*) src + spitch * ( (((line)) >> 18) ));
+               const u32 *srcB = (const u32 *)((char*) src + spitch * ( (((line)) >> 18) + 1 ));
+
+
+
+
+               long pl = ( (((point)) >> 18) );
+               do {} while (0);
+
+               D_ASSERT( pl >= 0 );
+               D_ASSERT( pl < width-1 );
+               L = ( (((((srcT[pl]) & 0xff0000) >> 16)&0xF8) << 8) | (((((srcT[pl]) & 0x00ff00) >> 8)&0xFC) << 3) | (((((srcT[pl]) & 0x0000ff))&0xF8) >> 3) );
+               R = ( (((((srcT[pl+1]) & 0xff0000) >> 16)&0xF8) << 8) | (((((srcT[pl+1]) & 0x00ff00) >> 8)&0xFC) << 3) | (((((srcT[pl+1]) & 0x0000ff))&0xF8) >> 3) );
+
+               dpT = (((((R & 0xf81f)-(L & 0xf81f))*ratios[r] + ((L & 0xf81f)<<6)) & (0xf81f<<6)) +
+                      ((((R & 0x07e0)-(L & 0x07e0))*ratios[r] + ((L & 0x07e0)<<6)) & (0x07e0<<6))) >> 6;
+
+               L = ( (((((srcB[pl]) & 0xff0000) >> 16)&0xF8) << 8) | (((((srcB[pl]) & 0x00ff00) >> 8)&0xFC) << 3) | (((((srcB[pl]) & 0x0000ff))&0xF8) >> 3) );
+               R = ( (((((srcB[pl+1]) & 0xff0000) >> 16)&0xF8) << 8) | (((((srcB[pl+1]) & 0x00ff00) >> 8)&0xFC) << 3) | (((((srcB[pl+1]) & 0x0000ff))&0xF8) >> 3) );
+
+               dpB = (((((R & 0xf81f)-(L & 0xf81f))*ratios[r] + ((L & 0xf81f)<<6)) & (0xf81f<<6)) +
+                      ((((R & 0x07e0)-(L & 0x07e0))*ratios[r] + ((L & 0x07e0)<<6)) & (0x07e0<<6))) >> 6;
+# 138 "stretch_hvx_16.h"
+               dst16[0] = ((((((dpB & 0xf81f) - (dpT & 0xf81f))*X) >> 5) + (dpT & 0xf81f)) & 0xf81f) +
+                          ((((((dpB>>5) & (0x07e0>>5)) - ((dpT>>5) & (0x07e0>>5)))*X) + (dpT & 0x07e0)) & 0x07e0);
+
+
+               dst16 += dpitch / 2;
+               line += vfraq;
+          }
+
+
+          point0 += hfraq;
+          dst32 = (u32*)((char*) dst + 2);
+
+
+          line = 0 + ctx->clip.y1 * vfraq;
+     }
+
+
+
+
+     for (y=0; y<ch; y++) {
+          long X;
+          long nlT = ( (((line)) >> 18) );
+
+          D_ASSERT( nlT >= 0 );
+          D_ASSERT( nlT < height-1 );
+
+
+
+
+          if (nlT != lineT) {
+               u32 L, R, dpT, dpB;
+               const u32 *srcT = (const u32 *)((char*) src + spitch * nlT);
+               const u32 *srcB = (const u32 *)((char*) src + spitch * (nlT + 1));
+               long diff = nlT - lineT;
+
+               if (diff > 1) {
+
+
+
+                    for (x=0, r=head, point=point0; x<w2; x++) {
+
+
+
+                         long pl = ( (((point)) >> 18) );
+                         do {} while (0);
+
+                         D_ASSERT( pl >= 0 );
+                         D_ASSERT( pl < width-1 );
+                         L = ( (((((srcT[pl]) & 0xff0000) >> 16)&0xF8) << 8) | (((((srcT[pl]) & 0x00ff00) >> 8)&0xFC) << 3) | (((((srcT[pl]) & 0x0000ff))&0xF8) >> 3) );
+                         R = ( (((((srcT[pl+1]) & 0xff0000) >> 16)&0xF8) << 8) | (((((srcT[pl+1]) & 0x00ff00) >> 8)&0xFC) << 3) | (((((srcT[pl+1]) & 0x0000ff))&0xF8) >> 3) );
+
+                         dpT = (((((R & 0xf81f)-(L & 0xf81f))*ratios[r] + ((L & 0xf81f)<<6)) & (0xf81f<<6)) +
+                                ((((R & 0x07e0)-(L & 0x07e0))*ratios[r] + ((L & 0x07e0)<<6)) & (0x07e0<<6)))
+
+
+
+                              >> 6;
+
+
+                         L = ( (((((srcB[pl]) & 0xff0000) >> 16)&0xF8) << 8) | (((((srcB[pl]) & 0x00ff00) >> 8)&0xFC) << 3) | (((((srcB[pl]) & 0x0000ff))&0xF8) >> 3) );
+                         R = ( (((((srcB[pl+1]) & 0xff0000) >> 16)&0xF8) << 8) | (((((srcB[pl+1]) & 0x00ff00) >> 8)&0xFC) << 3) | (((((srcB[pl+1]) & 0x0000ff))&0xF8) >> 3) );
+
+                         dpB = (((((R & 0xf81f)-(L & 0xf81f))*ratios[r] + ((L & 0xf81f)<<6)) & (0xf81f<<6)) +
+                                ((((R & 0x07e0)-(L & 0x07e0))*ratios[r] + ((L & 0x07e0)<<6)) & (0x07e0<<6)))
+
+
+
+                              >> 6;
+
+
+                         point += hfraq;
+                         r++;
+
+
+                         pl = ( (((point)) >> 18) );
+                         do {} while (0);
+
+                         D_ASSERT( pl >= 0 );
+                         D_ASSERT( pl < width-1 );
+
+                         L = ( (((((srcT[pl]) & 0xff0000) >> 16)&0xF8) << 8) | (((((srcT[pl]) & 0x00ff00) >> 8)&0xFC) << 3) | (((((srcT[pl]) & 0x0000ff))&0xF8) >> 3) );
+                         R = ( (((((srcT[pl+1]) & 0xff0000) >> 16)&0xF8) << 8) | (((((srcT[pl+1]) & 0x00ff00) >> 8)&0xFC) << 3) | (((((srcT[pl+1]) & 0x0000ff))&0xF8) >> 3) );
+
+                         dpT |= (((((R & 0xf81f)-(L & 0xf81f))*ratios[r] + ((L & 0xf81f)<<6)) & (0xf81f<<6)) +
+                                 ((((R & 0x07e0)-(L & 0x07e0))*ratios[r] + ((L & 0x07e0)<<6)) & (0x07e0<<6)))
+
+
+
+                              << (16-6);
+
+
+                         L = ( (((((srcB[pl]) & 0xff0000) >> 16)&0xF8) << 8) | (((((srcB[pl]) & 0x00ff00) >> 8)&0xFC) << 3) | (((((srcB[pl]) & 0x0000ff))&0xF8) >> 3) );
+                         R = ( (((((srcB[pl+1]) & 0xff0000) >> 16)&0xF8) << 8) | (((((srcB[pl+1]) & 0x00ff00) >> 8)&0xFC) << 3) | (((((srcB[pl+1]) & 0x0000ff))&0xF8) >> 3) );
+
+                         dpB |= (((((R & 0xf81f)-(L & 0xf81f))*ratios[r] + ((L & 0xf81f)<<6)) & (0xf81f<<6)) +
+                                 ((((R & 0x07e0)-(L & 0x07e0))*ratios[r] + ((L & 0x07e0)<<6)) & (0x07e0<<6)))
+
+
+
+                              << (16-6);
+
+
+                         point += hfraq;
+                         r++;
+
+
+                         lbT[x] = dpT;
+                         lbB[x] = dpB;
+                    }
+               }
+               else {
+
+                    lbX = lbT;
+                    lbT = lbB;
+                    lbB = lbX;
+
+
+
+
+                    for (x=0, r=head, point=point0; x<w2; x++) {
+
+
+
+                         long pl = ( (((point)) >> 18) );
+                         do {} while (0);
+
+                         D_ASSERT( pl >= 0 );
+                         D_ASSERT( pl < width-1 );
+                         L = ( (((((srcB[pl]) & 0xff0000) >> 16)&0xF8) << 8) | (((((srcB[pl]) & 0x00ff00) >> 8)&0xFC) << 3) | (((((srcB[pl]) & 0x0000ff))&0xF8) >> 3) );
+                         R = ( (((((srcB[pl+1]) & 0xff0000) >> 16)&0xF8) << 8) | (((((srcB[pl+1]) & 0x00ff00) >> 8)&0xFC) << 3) | (((((srcB[pl+1]) & 0x0000ff))&0xF8) >> 3) );
+
+                         dpB = (((((R & 0xf81f)-(L & 0xf81f))*ratios[r] + ((L & 0xf81f)<<6)) & (0xf81f<<6)) +
+                                ((((R & 0x07e0)-(L & 0x07e0))*ratios[r] + ((L & 0x07e0)<<6)) & (0x07e0<<6)))
+
+
+
+                              >> 6;
+
+
+                         point += hfraq;
+                         r++;
+
+
+                         pl = ( (((point)) >> 18) );
+                         do {} while (0);
+
+                         D_ASSERT( pl >= 0 );
+                         D_ASSERT( pl < width-1 );
+
+                         L = ( (((((srcB[pl]) & 0xff0000) >> 16)&0xF8) << 8) | (((((srcB[pl]) & 0x00ff00) >> 8)&0xFC) << 3) | (((((srcB[pl]) & 0x0000ff))&0xF8) >> 3) );
+                         R = ( (((((srcB[pl+1]) & 0xff0000) >> 16)&0xF8) << 8) | (((((srcB[pl+1]) & 0x00ff00) >> 8)&0xFC) << 3) | (((((srcB[pl+1]) & 0x0000ff))&0xF8) >> 3) );
+
+                         dpB |= (((((R & 0xf81f)-(L & 0xf81f))*ratios[r] + ((L & 0xf81f)<<6)) & (0xf81f<<6)) +
+                                 ((((R & 0x07e0)-(L & 0x07e0))*ratios[r] + ((L & 0x07e0)<<6)) & (0x07e0<<6)))
+
+
+
+                              << (16-6);
+
+
+                         point += hfraq;
+                         r++;
+
+
+                         lbB[x] = dpB;
+                    }
+               }
+
+               lineT = nlT;
+          }
+
+
+
+
+          X = ( ((line) & 0x3ffff) >> (18-5) );
+
+          for (x=0; x<w2; x++) {
+# 371 "stretch_hvx_16.h"
+               dst32[x] = ((((((lbB[x] & ((0x07e0<<16) | 0xf81f)) - (lbT[x] & ((0x07e0<<16) | 0xf81f)))*X) >> 5) + (lbT[x] & ((0x07e0<<16) | 0xf81f))) & ((0x07e0<<16) | 0xf81f)) +
+                          ((((((lbB[x]>>5) & (((0xf81f<<16) | 0x07e0)>>5)) - ((lbT[x]>>5) & (((0xf81f<<16) | 0x07e0)>>5)))*X) + (lbT[x] & ((0xf81f<<16) | 0x07e0))) & ((0xf81f<<16) | 0x07e0));
+
+
+          }
+
+          dst32 += dp4;
+          line += vfraq;
+     }
+
+     if (tail) {
+          u32 dpT, dpB, L, R;
+
+          u16 *dst16 = (u16*)((char*) dst + cw * 2 - 2);
+
+
+          line = 0 + ctx->clip.y1 * vfraq;
+
+          for (y=0; y<ch; y++) {
+               long X = ( ((line) & 0x3ffff) >> (18-5) );
+
+               const u32 *srcT = (const u32 *)((char*) src + spitch * ( (((line)) >> 18) ));
+               const u32 *srcB = (const u32 *)((char*) src + spitch * ( (((line)) >> 18) + 1 ));
+
+
+
+
+               long pl = ( (((point)) >> 18) );
+               do {} while (0);
+
+               D_ASSERT( pl >= 0 );
+               D_ASSERT( pl < width-1 );
+               L = ( (((((srcT[pl]) & 0xff0000) >> 16)&0xF8) << 8) | (((((srcT[pl]) & 0x00ff00) >> 8)&0xFC) << 3) | (((((srcT[pl]) & 0x0000ff))&0xF8) >> 3) );
+               R = ( (((((srcT[pl+1]) & 0xff0000) >> 16)&0xF8) << 8) | (((((srcT[pl+1]) & 0x00ff00) >> 8)&0xFC) << 3) | (((((srcT[pl+1]) & 0x0000ff))&0xF8) >> 3) );
+
+               dpT = (((((R & 0xf81f)-(L & 0xf81f))*ratios[r] + ((L & 0xf81f)<<6)) & (0xf81f<<6)) +
+                      ((((R & 0x07e0)-(L & 0x07e0))*ratios[r] + ((L & 0x07e0)<<6)) & (0x07e0<<6))) >> 6;
+
+               L = ( (((((srcB[pl]) & 0xff0000) >> 16)&0xF8) << 8) | (((((srcB[pl]) & 0x00ff00) >> 8)&0xFC) << 3) | (((((srcB[pl]) & 0x0000ff))&0xF8) >> 3) );
+               R = ( (((((srcB[pl+1]) & 0xff0000) >> 16)&0xF8) << 8) | (((((srcB[pl+1]) & 0x00ff00) >> 8)&0xFC) << 3) | (((((srcB[pl+1]) & 0x0000ff))&0xF8) >> 3) );
+
+               dpB = (((((R & 0xf81f)-(L & 0xf81f))*ratios[r] + ((L & 0xf81f)<<6)) & (0xf81f<<6)) +
+                      ((((R & 0x07e0)-(L & 0x07e0))*ratios[r] + ((L & 0x07e0)<<6)) & (0x07e0<<6))) >> 6;
+# 434 "stretch_hvx_16.h"
+               dst16[0] = ((((((dpB & 0xf81f) - (dpT & 0xf81f))*X) >> 5) + (dpT & 0xf81f)) & 0xf81f) +
+                          ((((((dpB>>5) & (0x07e0>>5)) - ((dpT>>5) & (0x07e0>>5)))*X) + (dpT & 0x07e0)) & 0x07e0);
+
+
+               dst16 += dpitch / 2;
+               line += vfraq;
+          }
+     }
+}
+# 22 "stretch_hvx_N.h" 2
+# 21 "stretch_up_down_16.h" 2
+# 49 "stretch_up_down_16.h"
+# 1 "stretch_hvx_N.h" 1
+# 9 "stretch_hvx_N.h"
+static void stretch_hvx_RGB16_down____DSPF_RGB16
+# 1 "stretch_hvx_16.h" 1
+# 35 "stretch_hvx_16.h"
+                                ( void *dst,
+                                  int dpitch,
+                                  const void *src,
+                                  int spitch,
+                                  int width,
+                                  int height,
+                                  int dst_width,
+                                  int dst_height,
+                                  const StretchCtx *ctx )
+{
+     long x, y, r = 0;
+     long head = ((((unsigned long) dst) & 2) >> 1) ^ (ctx->clip.x1 & 1);
+     long cw = ctx->clip.x2 - ctx->clip.x1 + 1;
+     long ch = ctx->clip.y2 - ctx->clip.y1 + 1;
+     long tail = (cw - head) & 1;
+     long w2 = (cw - head) / 2;
+     long hfraq = ((long)(width - 0) << 18) / (long)(dst_width);
+     long vfraq = ((long)(height - 0) << 18) / (long)(dst_height);
+     long dp4 = dpitch / 4;
+     long point0 = hfraq + ctx->clip.x1 * hfraq;
+     long point = point0;
+     long line = vfraq + ctx->clip.y1 * vfraq;
+     long ratios[cw];
+     u32 *dst32;
+
+
+
+
+
+
+     u32 _lbT[w2+8];
+     u32 _lbB[w2+8];
+
+     u32 *lbX;
+     u32 *lbT = (u32*)((((unsigned long)(&_lbT[0])) + 31) & ~31);
+     u32 *lbB = (u32*)((((unsigned long)(&_lbB[0])) + 31) & ~31);
+
+     long lineT = -2000;
+
+     for (x=0; x<cw; x++) {
+          ratios[x] = ( (((((point)) & 0x3ffff) ? : 0x40000) << 6) / (hfraq) );
+
+          point += hfraq;
+     }
+
+     do {} while (0);
+
+
+     dst = (void*)((char*) dst + ctx->clip.x1 * 2 + ctx->clip.y1 * dpitch);
+
+     dst32 = (u32*) dst;
+
+     if (head) {
+          u32 dpT, dpB, L, R;
+
+          u16 *dst16 = (u16*) dst;
+
+          point = point0;
+
+          for (y=0; y<ch; y++) {
+               long X = ( (((((line)) & 0x3ffff) ? : 0x40000) << 5) / (vfraq) );
+
+               const u16 *srcT = (const u16 *)((char*) src + spitch * ( (((line)-1) >> 18) - 1 ));
+               const u16 *srcB = (const u16 *)((char*) src + spitch * ( (((line)-1) >> 18) ));
+
+
+
+
+               long pl = ( (((point)-1) >> 18) - 1 );
+               do {} while (0);
+
+               D_ASSERT( pl >= 0 );
+               D_ASSERT( pl < width-1 );
+               L = (srcT[pl]);
+               R = (srcT[pl+1]);
+
+               dpT = (((((R & 0xf81f)-(L & 0xf81f))*ratios[r] + ((L & 0xf81f)<<6)) & (0xf81f<<6)) +
+                      ((((R & 0x07e0)-(L & 0x07e0))*ratios[r] + ((L & 0x07e0)<<6)) & (0x07e0<<6))) >> 6;
+
+               L = (srcB[pl]);
+               R = (srcB[pl+1]);
+
+               dpB = (((((R & 0xf81f)-(L & 0xf81f))*ratios[r] + ((L & 0xf81f)<<6)) & (0xf81f<<6)) +
+                      ((((R & 0x07e0)-(L & 0x07e0))*ratios[r] + ((L & 0x07e0)<<6)) & (0x07e0<<6))) >> 6;
+# 138 "stretch_hvx_16.h"
+               dst16[0] = ((((((dpB & 0xf81f) - (dpT & 0xf81f))*X) >> 5) + (dpT & 0xf81f)) & 0xf81f) +
+                          ((((((dpB>>5) & (0x07e0>>5)) - ((dpT>>5) & (0x07e0>>5)))*X) + (dpT & 0x07e0)) & 0x07e0);
+
+
+               dst16 += dpitch / 2;
+               line += vfraq;
+          }
+
+
+          point0 += hfraq;
+          dst32 = (u32*)((char*) dst + 2);
+
+
+          line = vfraq + ctx->clip.y1 * vfraq;
+     }
+
+
+
+
+     for (y=0; y<ch; y++) {
+          long X;
+          long nlT = ( (((line)-1) >> 18) - 1 );
+
+          D_ASSERT( nlT >= 0 );
+          D_ASSERT( nlT < height-1 );
+
+
+
+
+          if (nlT != lineT) {
+               u32 L, R, dpT, dpB;
+               const u16 *srcT = (const u16 *)((char*) src + spitch * nlT);
+               const u16 *srcB = (const u16 *)((char*) src + spitch * (nlT + 1));
+               long diff = nlT - lineT;
+
+               if (diff > 1) {
+
+
+
+                    for (x=0, r=head, point=point0; x<w2; x++) {
+
+
+
+                         long pl = ( (((point)-1) >> 18) - 1 );
+                         do {} while (0);
+
+                         D_ASSERT( pl >= 0 );
+                         D_ASSERT( pl < width-1 );
+                         L = (srcT[pl]);
+                         R = (srcT[pl+1]);
+
+                         dpT = (((((R & 0xf81f)-(L & 0xf81f))*ratios[r] + ((L & 0xf81f)<<6)) & (0xf81f<<6)) +
+                                ((((R & 0x07e0)-(L & 0x07e0))*ratios[r] + ((L & 0x07e0)<<6)) & (0x07e0<<6)))
+
+
+
+                              >> 6;
+
+
+                         L = (srcB[pl]);
+                         R = (srcB[pl+1]);
+
+                         dpB = (((((R & 0xf81f)-(L & 0xf81f))*ratios[r] + ((L & 0xf81f)<<6)) & (0xf81f<<6)) +
+                                ((((R & 0x07e0)-(L & 0x07e0))*ratios[r] + ((L & 0x07e0)<<6)) & (0x07e0<<6)))
+
+
+
+                              >> 6;
+
+
+                         point += hfraq;
+                         r++;
+
+
+                         pl = ( (((point)-1) >> 18) - 1 );
+                         do {} while (0);
+
+                         D_ASSERT( pl >= 0 );
+                         D_ASSERT( pl < width-1 );
+
+                         L = (srcT[pl]);
+                         R = (srcT[pl+1]);
+
+                         dpT |= (((((R & 0xf81f)-(L & 0xf81f))*ratios[r] + ((L & 0xf81f)<<6)) & (0xf81f<<6)) +
+                                 ((((R & 0x07e0)-(L & 0x07e0))*ratios[r] + ((L & 0x07e0)<<6)) & (0x07e0<<6)))
+
+
+
+                              << (16-6);
+
+
+                         L = (srcB[pl]);
+                         R = (srcB[pl+1]);
+
+                         dpB |= (((((R & 0xf81f)-(L & 0xf81f))*ratios[r] + ((L & 0xf81f)<<6)) & (0xf81f<<6)) +
+                                 ((((R & 0x07e0)-(L & 0x07e0))*ratios[r] + ((L & 0x07e0)<<6)) & (0x07e0<<6)))
+
+
+
+                              << (16-6);
+
+
+                         point += hfraq;
+                         r++;
+
+
+                         lbT[x] = dpT;
+                         lbB[x] = dpB;
+                    }
+               }
+               else {
+
+                    lbX = lbT;
+                    lbT = lbB;
+                    lbB = lbX;
+
+
+
+
+                    for (x=0, r=head, point=point0; x<w2; x++) {
+
+
+
+                         long pl = ( (((point)-1) >> 18) - 1 );
+                         do {} while (0);
+
+                         D_ASSERT( pl >= 0 );
+                         D_ASSERT( pl < width-1 );
+                         L = (srcB[pl]);
+                         R = (srcB[pl+1]);
+
+                         dpB = (((((R & 0xf81f)-(L & 0xf81f))*ratios[r] + ((L & 0xf81f)<<6)) & (0xf81f<<6)) +
+                                ((((R & 0x07e0)-(L & 0x07e0))*ratios[r] + ((L & 0x07e0)<<6)) & (0x07e0<<6)))
+
+
+
+                              >> 6;
+
+
+                         point += hfraq;
+                         r++;
+
+
+                         pl = ( (((point)-1) >> 18) - 1 );
+                         do {} while (0);
+
+                         D_ASSERT( pl >= 0 );
+                         D_ASSERT( pl < width-1 );
+
+                         L = (srcB[pl]);
+                         R = (srcB[pl+1]);
+
+                         dpB |= (((((R & 0xf81f)-(L & 0xf81f))*ratios[r] + ((L & 0xf81f)<<6)) & (0xf81f<<6)) +
+                                 ((((R & 0x07e0)-(L & 0x07e0))*ratios[r] + ((L & 0x07e0)<<6)) & (0x07e0<<6)))
+
+
+
+                              << (16-6);
+
+
+                         point += hfraq;
+                         r++;
+
+
+                         lbB[x] = dpB;
+                    }
+               }
+
+               lineT = nlT;
+          }
+
+
+
+
+          X = ( (((((line)) & 0x3ffff) ? : 0x40000) << 5) / (vfraq) );
+
+          for (x=0; x<w2; x++) {
+# 371 "stretch_hvx_16.h"
+               dst32[x] = ((((((lbB[x] & ((0x07e0<<16) | 0xf81f)) - (lbT[x] & ((0x07e0<<16) | 0xf81f)))*X) >> 5) + (lbT[x] & ((0x07e0<<16) | 0xf81f))) & ((0x07e0<<16) | 0xf81f)) +
+                          ((((((lbB[x]>>5) & (((0xf81f<<16) | 0x07e0)>>5)) - ((lbT[x]>>5) & (((0xf81f<<16) | 0x07e0)>>5)))*X) + (lbT[x] & ((0xf81f<<16) | 0x07e0))) & ((0xf81f<<16) | 0x07e0));
+
+
+          }
+
+          dst32 += dp4;
+          line += vfraq;
+     }
+
+     if (tail) {
+          u32 dpT, dpB, L, R;
+
+          u16 *dst16 = (u16*)((char*) dst + cw * 2 - 2);
+
+
+          line = vfraq + ctx->clip.y1 * vfraq;
+
+          for (y=0; y<ch; y++) {
+               long X = ( (((((line)) & 0x3ffff) ? : 0x40000) << 5) / (vfraq) );
+
+               const u16 *srcT = (const u16 *)((char*) src + spitch * ( (((line)-1) >> 18) - 1 ));
+               const u16 *srcB = (const u16 *)((char*) src + spitch * ( (((line)-1) >> 18) ));
+
+
+
+
+               long pl = ( (((point)-1) >> 18) - 1 );
+               do {} while (0);
+
+               D_ASSERT( pl >= 0 );
+               D_ASSERT( pl < width-1 );
+               L = (srcT[pl]);
+               R = (srcT[pl+1]);
+
+               dpT = (((((R & 0xf81f)-(L & 0xf81f))*ratios[r] + ((L & 0xf81f)<<6)) & (0xf81f<<6)) +
+                      ((((R & 0x07e0)-(L & 0x07e0))*ratios[r] + ((L & 0x07e0)<<6)) & (0x07e0<<6))) >> 6;
+
+               L = (srcB[pl]);
+               R = (srcB[pl+1]);
+
+               dpB = (((((R & 0xf81f)-(L & 0xf81f))*ratios[r] + ((L & 0xf81f)<<6)) & (0xf81f<<6)) +
+                      ((((R & 0x07e0)-(L & 0x07e0))*ratios[r] + ((L & 0x07e0)<<6)) & (0x07e0<<6))) >> 6;
+# 434 "stretch_hvx_16.h"
+               dst16[0] = ((((((dpB & 0xf81f) - (dpT & 0xf81f))*X) >> 5) + (dpT & 0xf81f)) & 0xf81f) +
+                          ((((((dpB>>5) & (0x07e0>>5)) - ((dpT>>5) & (0x07e0>>5)))*X) + (dpT & 0x07e0)) & 0x07e0);
+
+
+               dst16 += dpitch / 2;
+               line += vfraq;
+          }
+     }
+}
+# 11 "stretch_hvx_N.h" 2
+# 20 "stretch_hvx_N.h"
+static void stretch_hvx_RGB16_down____DSPF_RGB32
+# 1 "stretch_hvx_16.h" 1
+# 35 "stretch_hvx_16.h"
+                                ( void *dst,
+                                  int dpitch,
+                                  const void *src,
+                                  int spitch,
+                                  int width,
+                                  int height,
+                                  int dst_width,
+                                  int dst_height,
+                                  const StretchCtx *ctx )
+{
+     long x, y, r = 0;
+     long head = ((((unsigned long) dst) & 2) >> 1) ^ (ctx->clip.x1 & 1);
+     long cw = ctx->clip.x2 - ctx->clip.x1 + 1;
+     long ch = ctx->clip.y2 - ctx->clip.y1 + 1;
+     long tail = (cw - head) & 1;
+     long w2 = (cw - head) / 2;
+     long hfraq = ((long)(width - 0) << 18) / (long)(dst_width);
+     long vfraq = ((long)(height - 0) << 18) / (long)(dst_height);
+     long dp4 = dpitch / 4;
+     long point0 = hfraq + ctx->clip.x1 * hfraq;
+     long point = point0;
+     long line = vfraq + ctx->clip.y1 * vfraq;
+     long ratios[cw];
+     u32 *dst32;
+
+
+
+
+
+
+     u32 _lbT[w2+8];
+     u32 _lbB[w2+8];
+
+     u32 *lbX;
+     u32 *lbT = (u32*)((((unsigned long)(&_lbT[0])) + 31) & ~31);
+     u32 *lbB = (u32*)((((unsigned long)(&_lbB[0])) + 31) & ~31);
+
+     long lineT = -2000;
+
+     for (x=0; x<cw; x++) {
+          ratios[x] = ( (((((point)) & 0x3ffff) ? : 0x40000) << 6) / (hfraq) );
+
+          point += hfraq;
+     }
+
+     do {} while (0);
+
+
+     dst = (void*)((char*) dst + ctx->clip.x1 * 2 + ctx->clip.y1 * dpitch);
+
+     dst32 = (u32*) dst;
+
+     if (head) {
+          u32 dpT, dpB, L, R;
+
+          u16 *dst16 = (u16*) dst;
+
+          point = point0;
+
+          for (y=0; y<ch; y++) {
+               long X = ( (((((line)) & 0x3ffff) ? : 0x40000) << 5) / (vfraq) );
+
+               const u32 *srcT = (const u32 *)((char*) src + spitch * ( (((line)-1) >> 18) - 1 ));
+               const u32 *srcB = (const u32 *)((char*) src + spitch * ( (((line)-1) >> 18) ));
+
+
+
+
+               long pl = ( (((point)-1) >> 18) - 1 );
+               do {} while (0);
+
+               D_ASSERT( pl >= 0 );
+               D_ASSERT( pl < width-1 );
+               L = ( (((((srcT[pl]) & 0xff0000) >> 16)&0xF8) << 8) | (((((srcT[pl]) & 0x00ff00) >> 8)&0xFC) << 3) | (((((srcT[pl]) & 0x0000ff))&0xF8) >> 3) );
+               R = ( (((((srcT[pl+1]) & 0xff0000) >> 16)&0xF8) << 8) | (((((srcT[pl+1]) & 0x00ff00) >> 8)&0xFC) << 3) | (((((srcT[pl+1]) & 0x0000ff))&0xF8) >> 3) );
+
+               dpT = (((((R & 0xf81f)-(L & 0xf81f))*ratios[r] + ((L & 0xf81f)<<6)) & (0xf81f<<6)) +
+                      ((((R & 0x07e0)-(L & 0x07e0))*ratios[r] + ((L & 0x07e0)<<6)) & (0x07e0<<6))) >> 6;
+
+               L = ( (((((srcB[pl]) & 0xff0000) >> 16)&0xF8) << 8) | (((((srcB[pl]) & 0x00ff00) >> 8)&0xFC) << 3) | (((((srcB[pl]) & 0x0000ff))&0xF8) >> 3) );
+               R = ( (((((srcB[pl+1]) & 0xff0000) >> 16)&0xF8) << 8) | (((((srcB[pl+1]) & 0x00ff00) >> 8)&0xFC) << 3) | (((((srcB[pl+1]) & 0x0000ff))&0xF8) >> 3) );
+
+               dpB = (((((R & 0xf81f)-(L & 0xf81f))*ratios[r] + ((L & 0xf81f)<<6)) & (0xf81f<<6)) +
+                      ((((R & 0x07e0)-(L & 0x07e0))*ratios[r] + ((L & 0x07e0)<<6)) & (0x07e0<<6))) >> 6;
+# 138 "stretch_hvx_16.h"
+               dst16[0] = ((((((dpB & 0xf81f) - (dpT & 0xf81f))*X) >> 5) + (dpT & 0xf81f)) & 0xf81f) +
+                          ((((((dpB>>5) & (0x07e0>>5)) - ((dpT>>5) & (0x07e0>>5)))*X) + (dpT & 0x07e0)) & 0x07e0);
+
+
+               dst16 += dpitch / 2;
+               line += vfraq;
+          }
+
+
+          point0 += hfraq;
+          dst32 = (u32*)((char*) dst + 2);
+
+
+          line = vfraq + ctx->clip.y1 * vfraq;
+     }
+
+
+
+
+     for (y=0; y<ch; y++) {
+          long X;
+          long nlT = ( (((line)-1) >> 18) - 1 );
+
+          D_ASSERT( nlT >= 0 );
+          D_ASSERT( nlT < height-1 );
+
+
+
+
+          if (nlT != lineT) {
+               u32 L, R, dpT, dpB;
+               const u32 *srcT = (const u32 *)((char*) src + spitch * nlT);
+               const u32 *srcB = (const u32 *)((char*) src + spitch * (nlT + 1));
+               long diff = nlT - lineT;
+
+               if (diff > 1) {
+
+
+
+                    for (x=0, r=head, point=point0; x<w2; x++) {
+
+
+
+                         long pl = ( (((point)-1) >> 18) - 1 );
+                         do {} while (0);
+
+                         D_ASSERT( pl >= 0 );
+                         D_ASSERT( pl < width-1 );
+                         L = ( (((((srcT[pl]) & 0xff0000) >> 16)&0xF8) << 8) | (((((srcT[pl]) & 0x00ff00) >> 8)&0xFC) << 3) | (((((srcT[pl]) & 0x0000ff))&0xF8) >> 3) );
+                         R = ( (((((srcT[pl+1]) & 0xff0000) >> 16)&0xF8) << 8) | (((((srcT[pl+1]) & 0x00ff00) >> 8)&0xFC) << 3) | (((((srcT[pl+1]) & 0x0000ff))&0xF8) >> 3) );
+
+                         dpT = (((((R & 0xf81f)-(L & 0xf81f))*ratios[r] + ((L & 0xf81f)<<6)) & (0xf81f<<6)) +
+                                ((((R & 0x07e0)-(L & 0x07e0))*ratios[r] + ((L & 0x07e0)<<6)) & (0x07e0<<6)))
+
+
+
+                              >> 6;
+
+
+                         L = ( (((((srcB[pl]) & 0xff0000) >> 16)&0xF8) << 8) | (((((srcB[pl]) & 0x00ff00) >> 8)&0xFC) << 3) | (((((srcB[pl]) & 0x0000ff))&0xF8) >> 3) );
+                         R = ( (((((srcB[pl+1]) & 0xff0000) >> 16)&0xF8) << 8) | (((((srcB[pl+1]) & 0x00ff00) >> 8)&0xFC) << 3) | (((((srcB[pl+1]) & 0x0000ff))&0xF8) >> 3) );
+
+                         dpB = (((((R & 0xf81f)-(L & 0xf81f))*ratios[r] + ((L & 0xf81f)<<6)) & (0xf81f<<6)) +
+                                ((((R & 0x07e0)-(L & 0x07e0))*ratios[r] + ((L & 0x07e0)<<6)) & (0x07e0<<6)))
+
+
+
+                              >> 6;
+
+
+                         point += hfraq;
+                         r++;
+
+
+                         pl = ( (((point)-1) >> 18) - 1 );
+                         do {} while (0);
+
+                         D_ASSERT( pl >= 0 );
+                         D_ASSERT( pl < width-1 );
+
+                         L = ( (((((srcT[pl]) & 0xff0000) >> 16)&0xF8) << 8) | (((((srcT[pl]) & 0x00ff00) >> 8)&0xFC) << 3) | (((((srcT[pl]) & 0x0000ff))&0xF8) >> 3) );
+                         R = ( (((((srcT[pl+1]) & 0xff0000) >> 16)&0xF8) << 8) | (((((srcT[pl+1]) & 0x00ff00) >> 8)&0xFC) << 3) | (((((srcT[pl+1]) & 0x0000ff))&0xF8) >> 3) );
+
+                         dpT |= (((((R & 0xf81f)-(L & 0xf81f))*ratios[r] + ((L & 0xf81f)<<6)) & (0xf81f<<6)) +
+                                 ((((R & 0x07e0)-(L & 0x07e0))*ratios[r] + ((L & 0x07e0)<<6)) & (0x07e0<<6)))
+
+
+
+                              << (16-6);
+
+
+                         L = ( (((((srcB[pl]) & 0xff0000) >> 16)&0xF8) << 8) | (((((srcB[pl]) & 0x00ff00) >> 8)&0xFC) << 3) | (((((srcB[pl]) & 0x0000ff))&0xF8) >> 3) );
+                         R = ( (((((srcB[pl+1]) & 0xff0000) >> 16)&0xF8) << 8) | (((((srcB[pl+1]) & 0x00ff00) >> 8)&0xFC) << 3) | (((((srcB[pl+1]) & 0x0000ff))&0xF8) >> 3) );
+
+                         dpB |= (((((R & 0xf81f)-(L & 0xf81f))*ratios[r] + ((L & 0xf81f)<<6)) & (0xf81f<<6)) +
+                                 ((((R & 0x07e0)-(L & 0x07e0))*ratios[r] + ((L & 0x07e0)<<6)) & (0x07e0<<6)))
+
+
+
+                              << (16-6);
+
+
+                         point += hfraq;
+                         r++;
+
+
+                         lbT[x] = dpT;
+                         lbB[x] = dpB;
+                    }
+               }
+               else {
+
+                    lbX = lbT;
+                    lbT = lbB;
+                    lbB = lbX;
+
+
+
+
+                    for (x=0, r=head, point=point0; x<w2; x++) {
+
+
+
+                         long pl = ( (((point)-1) >> 18) - 1 );
+                         do {} while (0);
+
+                         D_ASSERT( pl >= 0 );
+                         D_ASSERT( pl < width-1 );
+                         L = ( (((((srcB[pl]) & 0xff0000) >> 16)&0xF8) << 8) | (((((srcB[pl]) & 0x00ff00) >> 8)&0xFC) << 3) | (((((srcB[pl]) & 0x0000ff))&0xF8) >> 3) );
+                         R = ( (((((srcB[pl+1]) & 0xff0000) >> 16)&0xF8) << 8) | (((((srcB[pl+1]) & 0x00ff00) >> 8)&0xFC) << 3) | (((((srcB[pl+1]) & 0x0000ff))&0xF8) >> 3) );
+
+                         dpB = (((((R & 0xf81f)-(L & 0xf81f))*ratios[r] + ((L & 0xf81f)<<6)) & (0xf81f<<6)) +
+                                ((((R & 0x07e0)-(L & 0x07e0))*ratios[r] + ((L & 0x07e0)<<6)) & (0x07e0<<6)))
+
+
+
+                              >> 6;
+
+
+                         point += hfraq;
+                         r++;
+
+
+                         pl = ( (((point)-1) >> 18) - 1 );
+                         do {} while (0);
+
+                         D_ASSERT( pl >= 0 );
+                         D_ASSERT( pl < width-1 );
+
+                         L = ( (((((srcB[pl]) & 0xff0000) >> 16)&0xF8) << 8) | (((((srcB[pl]) & 0x00ff00) >> 8)&0xFC) << 3) | (((((srcB[pl]) & 0x0000ff))&0xF8) >> 3) );
+                         R = ( (((((srcB[pl+1]) & 0xff0000) >> 16)&0xF8) << 8) | (((((srcB[pl+1]) & 0x00ff00) >> 8)&0xFC) << 3) | (((((srcB[pl+1]) & 0x0000ff))&0xF8) >> 3) );
+
+                         dpB |= (((((R & 0xf81f)-(L & 0xf81f))*ratios[r] + ((L & 0xf81f)<<6)) & (0xf81f<<6)) +
+                                 ((((R & 0x07e0)-(L & 0x07e0))*ratios[r] + ((L & 0x07e0)<<6)) & (0x07e0<<6)))
+
+
+
+                              << (16-6);
+
+
+                         point += hfraq;
+                         r++;
+
+
+                         lbB[x] = dpB;
+                    }
+               }
+
+               lineT = nlT;
+          }
+
+
+
+
+          X = ( (((((line)) & 0x3ffff) ? : 0x40000) << 5) / (vfraq) );
+
+          for (x=0; x<w2; x++) {
+# 371 "stretch_hvx_16.h"
+               dst32[x] = ((((((lbB[x] & ((0x07e0<<16) | 0xf81f)) - (lbT[x] & ((0x07e0<<16) | 0xf81f)))*X) >> 5) + (lbT[x] & ((0x07e0<<16) | 0xf81f))) & ((0x07e0<<16) | 0xf81f)) +
+                          ((((((lbB[x]>>5) & (((0xf81f<<16) | 0x07e0)>>5)) - ((lbT[x]>>5) & (((0xf81f<<16) | 0x07e0)>>5)))*X) + (lbT[x] & ((0xf81f<<16) | 0x07e0))) & ((0xf81f<<16) | 0x07e0));
+
+
+          }
+
+          dst32 += dp4;
+          line += vfraq;
+     }
+
+     if (tail) {
+          u32 dpT, dpB, L, R;
+
+          u16 *dst16 = (u16*)((char*) dst + cw * 2 - 2);
+
+
+          line = vfraq + ctx->clip.y1 * vfraq;
+
+          for (y=0; y<ch; y++) {
+               long X = ( (((((line)) & 0x3ffff) ? : 0x40000) << 5) / (vfraq) );
+
+               const u32 *srcT = (const u32 *)((char*) src + spitch * ( (((line)-1) >> 18) - 1 ));
+               const u32 *srcB = (const u32 *)((char*) src + spitch * ( (((line)-1) >> 18) ));
+
+
+
+
+               long pl = ( (((point)-1) >> 18) - 1 );
+               do {} while (0);
+
+               D_ASSERT( pl >= 0 );
+               D_ASSERT( pl < width-1 );
+               L = ( (((((srcT[pl]) & 0xff0000) >> 16)&0xF8) << 8) | (((((srcT[pl]) & 0x00ff00) >> 8)&0xFC) << 3) | (((((srcT[pl]) & 0x0000ff))&0xF8) >> 3) );
+               R = ( (((((srcT[pl+1]) & 0xff0000) >> 16)&0xF8) << 8) | (((((srcT[pl+1]) & 0x00ff00) >> 8)&0xFC) << 3) | (((((srcT[pl+1]) & 0x0000ff))&0xF8) >> 3) );
+
+               dpT = (((((R & 0xf81f)-(L & 0xf81f))*ratios[r] + ((L & 0xf81f)<<6)) & (0xf81f<<6)) +
+                      ((((R & 0x07e0)-(L & 0x07e0))*ratios[r] + ((L & 0x07e0)<<6)) & (0x07e0<<6))) >> 6;
+
+               L = ( (((((srcB[pl]) & 0xff0000) >> 16)&0xF8) << 8) | (((((srcB[pl]) & 0x00ff00) >> 8)&0xFC) << 3) | (((((srcB[pl]) & 0x0000ff))&0xF8) >> 3) );
+               R = ( (((((srcB[pl+1]) & 0xff0000) >> 16)&0xF8) << 8) | (((((srcB[pl+1]) & 0x00ff00) >> 8)&0xFC) << 3) | (((((srcB[pl+1]) & 0x0000ff))&0xF8) >> 3) );
+
+               dpB = (((((R & 0xf81f)-(L & 0xf81f))*ratios[r] + ((L & 0xf81f)<<6)) & (0xf81f<<6)) +
+                      ((((R & 0x07e0)-(L & 0x07e0))*ratios[r] + ((L & 0x07e0)<<6)) & (0x07e0<<6))) >> 6;
+# 434 "stretch_hvx_16.h"
+               dst16[0] = ((((((dpB & 0xf81f) - (dpT & 0xf81f))*X) >> 5) + (dpT & 0xf81f)) & 0xf81f) +
+                          ((((((dpB>>5) & (0x07e0>>5)) - ((dpT>>5) & (0x07e0>>5)))*X) + (dpT & 0x07e0)) & 0x07e0);
+
+
+               dst16 += dpitch / 2;
+               line += vfraq;
+          }
+     }
+}
+# 22 "stretch_hvx_N.h" 2
+# 50 "stretch_up_down_16.h" 2
+# 48 "Scaler.cxx" 2
+# 73 "Scaler.cxx"
+# 1 "stretch_up_down_32.h" 1
+# 20 "stretch_up_down_32.h"
+# 1 "stretch_hvx_N.h" 1
+# 9 "stretch_hvx_N.h"
+static void stretch_hvx_ARGB_up____DSPF_ARGB
+# 1 "stretch_hvx_32.h" 1
+# 11 "stretch_hvx_32.h"
+                                ( void *dst,
+                                  int dpitch,
+                                  const void *src,
+                                  int spitch,
+                                  int width,
+                                  int height,
+                                  int dst_width,
+                                  int dst_height,
+                                  const StretchCtx *ctx )
+{
+     long x, y = 0;
+     long cw = ctx->clip.x2 - ctx->clip.x1 + 1;
+     long ch = ctx->clip.y2 - ctx->clip.y1 + 1;
+     long hfraq = ((long)(width - 1) << 18) / (long)(dst_width);
+     long vfraq = ((long)(height - 1) << 18) / (long)(dst_height);
+     long dp4 = dpitch / 4;
+     long point0 = 0 + ctx->clip.x1 * hfraq;
+     long point = point0;
+     long line = 0 + ctx->clip.y1 * vfraq;
+     long ratios[cw];
+     u32 *dst32;
+
+
+
+
+
+     u32 _lbT[cw+8];
+     u32 _lbB[cw+8];
+
+     u32 *lbX;
+     u32 *lbT = (u32*)((((unsigned long)(&_lbT[0])) + 31) & ~31);
+     u32 *lbB = (u32*)((((unsigned long)(&_lbB[0])) + 31) & ~31);
+
+     long lineT = -2000;
+
+     for (x=0; x<cw; x++) {
+          ratios[x] = ( ((point) & 0x3ffff) >> (18-8) );
+
+          point += hfraq;
+     }
+
+     do {} while (0);
+
+     dst = (void*)((char*) dst + ctx->clip.x1 * 4 + ctx->clip.y1 * dpitch);
+
+     dst32 = (u32*) dst;
+
+
+
+
+     for (y=0; y<ch; y++) {
+          long X;
+          long nlT = ( (((line)) >> 18) );
+
+          D_ASSERT( nlT >= 0 );
+          D_ASSERT( nlT < height-1 );
+
+
+
+
+          if (nlT != lineT) {
+               u32 L, R;
+               const u32 *srcT = (const u32 *)((const char*) src + spitch * nlT);
+               const u32 *srcB = (const u32 *)((const char*) src + spitch * (nlT + 1));
+               long diff = nlT - lineT;
+
+               if (diff > 1) {
+
+
+
+                    for (x=0, point=point0; x<cw; x++, point += hfraq) {
+                         long pl = ( (((point)) >> 18) );
+                         do {} while (0);
+
+                         D_ASSERT( pl >= 0 );
+                         D_ASSERT( pl < width-1 );
+
+                         L = (srcT[pl]);
+                         R = (srcT[pl+1]);
+
+                         lbT[x]= ((((((R & 0x00ff00ff) - (L & 0x00ff00ff))*ratios[x]) >> 8) + (L & 0x00ff00ff)) & 0x00ff00ff) +
+                                 ((((((R>>8) & 0x00ff00ff) - ((L>>8) & 0x00ff00ff))*ratios[x]) + (L & 0xff00ff00)) & 0xff00ff00);
+
+                         L = (srcB[pl]);
+                         R = (srcB[pl+1]);
+
+                         lbB[x] = ((((((R & 0x00ff00ff) - (L & 0x00ff00ff))*ratios[x]) >> 8) + (L & 0x00ff00ff)) & 0x00ff00ff) +
+                                  ((((((R>>8) & 0x00ff00ff) - ((L>>8) & 0x00ff00ff))*ratios[x]) + (L & 0xff00ff00)) & 0xff00ff00);
+                    }
+               }
+               else {
+
+                    lbX = lbT;
+                    lbT = lbB;
+                    lbB = lbX;
+
+
+
+
+                    for (x=0, point=point0; x<cw; x++, point += hfraq) {
+                         long pl = ( (((point)) >> 18) );
+                         do {} while (0);
+
+                         D_ASSERT( pl >= 0 );
+                         D_ASSERT( pl < width-1 );
+
+                         L = (srcB[pl]);
+                         R = (srcB[pl+1]);
+
+                         lbB[x] = ((((((R & 0x00ff00ff) - (L & 0x00ff00ff))*ratios[x]) >> 8) + (L & 0x00ff00ff)) & 0x00ff00ff) +
+                                  ((((((R>>8) & 0x00ff00ff) - ((L>>8) & 0x00ff00ff))*ratios[x]) + (L & 0xff00ff00)) & 0xff00ff00);
+                    }
+               }
+
+               lineT = nlT;
+          }
+
+
+
+
+          X = ( ((line) & 0x3ffff) >> (18-8) );
+
+          for (x=0; x<cw; x++) {
+# 149 "stretch_hvx_32.h"
+               dst32[x] = ((((((lbB[x] & 0x00ff00ff) - (lbT[x] & 0x00ff00ff))*X) >> 8) + (lbT[x] & 0x00ff00ff)) & 0x00ff00ff) +
+                          ((((((lbB[x]>>8) & 0x00ff00ff) - ((lbT[x]>>8) & 0x00ff00ff))*X) + (lbT[x] & 0xff00ff00)) & 0xff00ff00);
+
+          }
+
+          dst32 += dp4;
+          line += vfraq;
+     }
+}
+# 11 "stretch_hvx_N.h" 2
+# 33 "stretch_hvx_N.h"
+static void stretch_hvx_ARGB_up____DSPF_RGB32
+# 1 "stretch_hvx_32.h" 1
+# 11 "stretch_hvx_32.h"
+                                ( void *dst,
+                                  int dpitch,
+                                  const void *src,
+                                  int spitch,
+                                  int width,
+                                  int height,
+                                  int dst_width,
+                                  int dst_height,
+                                  const StretchCtx *ctx )
+{
+     long x, y = 0;
+     long cw = ctx->clip.x2 - ctx->clip.x1 + 1;
+     long ch = ctx->clip.y2 - ctx->clip.y1 + 1;
+     long hfraq = ((long)(width - 1) << 18) / (long)(dst_width);
+     long vfraq = ((long)(height - 1) << 18) / (long)(dst_height);
+     long dp4 = dpitch / 4;
+     long point0 = 0 + ctx->clip.x1 * hfraq;
+     long point = point0;
+     long line = 0 + ctx->clip.y1 * vfraq;
+     long ratios[cw];
+     u32 *dst32;
+
+
+
+
+
+     u32 _lbT[cw+8];
+     u32 _lbB[cw+8];
+
+     u32 *lbX;
+     u32 *lbT = (u32*)((((unsigned long)(&_lbT[0])) + 31) & ~31);
+     u32 *lbB = (u32*)((((unsigned long)(&_lbB[0])) + 31) & ~31);
+
+     long lineT = -2000;
+
+     for (x=0; x<cw; x++) {
+          ratios[x] = ( ((point) & 0x3ffff) >> (18-8) );
+
+          point += hfraq;
+     }
+
+     do {} while (0);
+
+     dst = (void*)((char*) dst + ctx->clip.x1 * 4 + ctx->clip.y1 * dpitch);
+
+     dst32 = (u32*) dst;
+
+
+
+
+     for (y=0; y<ch; y++) {
+          long X;
+          long nlT = ( (((line)) >> 18) );
+
+          D_ASSERT( nlT >= 0 );
+          D_ASSERT( nlT < height-1 );
+
+
+
+
+          if (nlT != lineT) {
+               u32 L, R;
+               const u32 *srcT = (const u32 *)((const char*) src + spitch * nlT);
+               const u32 *srcB = (const u32 *)((const char*) src + spitch * (nlT + 1));
+               long diff = nlT - lineT;
+
+               if (diff > 1) {
+
+
+
+                    for (x=0, point=point0; x<cw; x++, point += hfraq) {
+                         long pl = ( (((point)) >> 18) );
+                         do {} while (0);
+
+                         D_ASSERT( pl >= 0 );
+                         D_ASSERT( pl < width-1 );
+
+                         L = ((srcT[pl]) | 0xff000000);
+                         R = ((srcT[pl+1]) | 0xff000000);
+
+                         lbT[x]= ((((((R & 0x00ff00ff) - (L & 0x00ff00ff))*ratios[x]) >> 8) + (L & 0x00ff00ff)) & 0x00ff00ff) +
+                                 ((((((R>>8) & 0x00ff00ff) - ((L>>8) & 0x00ff00ff))*ratios[x]) + (L & 0xff00ff00)) & 0xff00ff00);
+
+                         L = ((srcB[pl]) | 0xff000000);
+                         R = ((srcB[pl+1]) | 0xff000000);
+
+                         lbB[x] = ((((((R & 0x00ff00ff) - (L & 0x00ff00ff))*ratios[x]) >> 8) + (L & 0x00ff00ff)) & 0x00ff00ff) +
+                                  ((((((R>>8) & 0x00ff00ff) - ((L>>8) & 0x00ff00ff))*ratios[x]) + (L & 0xff00ff00)) & 0xff00ff00);
+                    }
+               }
+               else {
+
+                    lbX = lbT;
+                    lbT = lbB;
+                    lbB = lbX;
+
+
+
+
+                    for (x=0, point=point0; x<cw; x++, point += hfraq) {
+                         long pl = ( (((point)) >> 18) );
+                         do {} while (0);
+
+                         D_ASSERT( pl >= 0 );
+                         D_ASSERT( pl < width-1 );
+
+                         L = ((srcB[pl]) | 0xff000000);
+                         R = ((srcB[pl+1]) | 0xff000000);
+
+                         lbB[x] = ((((((R & 0x00ff00ff) - (L & 0x00ff00ff))*ratios[x]) >> 8) + (L & 0x00ff00ff)) & 0x00ff00ff) +
+                                  ((((((R>>8) & 0x00ff00ff) - ((L>>8) & 0x00ff00ff))*ratios[x]) + (L & 0xff00ff00)) & 0xff00ff00);
+                    }
+               }
+
+               lineT = nlT;
+          }
+
+
+
+
+          X = ( ((line) & 0x3ffff) >> (18-8) );
+
+          for (x=0; x<cw; x++) {
+# 149 "stretch_hvx_32.h"
+               dst32[x] = ((((((lbB[x] & 0x00ff00ff) - (lbT[x] & 0x00ff00ff))*X) >> 8) + (lbT[x] & 0x00ff00ff)) & 0x00ff00ff) +
+                          ((((((lbB[x]>>8) & 0x00ff00ff) - ((lbT[x]>>8) & 0x00ff00ff))*X) + (lbT[x] & 0xff00ff00)) & 0xff00ff00);
+
+          }
+
+          dst32 += dp4;
+          line += vfraq;
+     }
+}
+# 35 "stretch_hvx_N.h" 2
+# 21 "stretch_up_down_32.h" 2
+# 49 "stretch_up_down_32.h"
+# 1 "stretch_hvx_N.h" 1
+# 9 "stretch_hvx_N.h"
+static void stretch_hvx_ARGB_down____DSPF_ARGB
+# 1 "stretch_hvx_32.h" 1
+# 11 "stretch_hvx_32.h"
+                                ( void *dst,
+                                  int dpitch,
+                                  const void *src,
+                                  int spitch,
+                                  int width,
+                                  int height,
+                                  int dst_width,
+                                  int dst_height,
+                                  const StretchCtx *ctx )
+{
+     long x, y = 0;
+     long cw = ctx->clip.x2 - ctx->clip.x1 + 1;
+     long ch = ctx->clip.y2 - ctx->clip.y1 + 1;
+     long hfraq = ((long)(width - 0) << 18) / (long)(dst_width);
+     long vfraq = ((long)(height - 0) << 18) / (long)(dst_height);
+     long dp4 = dpitch / 4;
+     long point0 = hfraq + ctx->clip.x1 * hfraq;
+     long point = point0;
+     long line = vfraq + ctx->clip.y1 * vfraq;
+     long ratios[cw];
+     u32 *dst32;
+
+
+
+
+
+     u32 _lbT[cw+8];
+     u32 _lbB[cw+8];
+
+     u32 *lbX;
+     u32 *lbT = (u32*)((((unsigned long)(&_lbT[0])) + 31) & ~31);
+     u32 *lbB = (u32*)((((unsigned long)(&_lbB[0])) + 31) & ~31);
+
+     long lineT = -2000;
+
+     for (x=0; x<cw; x++) {
+          ratios[x] = ( (((((point)) & 0x3ffff) ? : 0x40000) << 8) / (hfraq) );
+
+          point += hfraq;
+     }
+
+     do {} while (0);
+
+     dst = (void*)((char*) dst + ctx->clip.x1 * 4 + ctx->clip.y1 * dpitch);
+
+     dst32 = (u32*) dst;
+
+
+
+
+     for (y=0; y<ch; y++) {
+          long X;
+          long nlT = ( (((line)-1) >> 18) - 1 );
+
+          D_ASSERT( nlT >= 0 );
+          D_ASSERT( nlT < height-1 );
+
+
+
+
+          if (nlT != lineT) {
+               u32 L, R;
+               const u32 *srcT = (const u32 *)((const char*) src + spitch * nlT);
+               const u32 *srcB = (const u32 *)((const char*) src + spitch * (nlT + 1));
+               long diff = nlT - lineT;
+
+               if (diff > 1) {
+
+
+
+                    for (x=0, point=point0; x<cw; x++, point += hfraq) {
+                         long pl = ( (((point)-1) >> 18) - 1 );
+                         do {} while (0);
+
+                         D_ASSERT( pl >= 0 );
+                         D_ASSERT( pl < width-1 );
+
+                         L = (srcT[pl]);
+                         R = (srcT[pl+1]);
+
+                         lbT[x]= ((((((R & 0x00ff00ff) - (L & 0x00ff00ff))*ratios[x]) >> 8) + (L & 0x00ff00ff)) & 0x00ff00ff) +
+                                 ((((((R>>8) & 0x00ff00ff) - ((L>>8) & 0x00ff00ff))*ratios[x]) + (L & 0xff00ff00)) & 0xff00ff00);
+
+                         L = (srcB[pl]);
+                         R = (srcB[pl+1]);
+
+                         lbB[x] = ((((((R & 0x00ff00ff) - (L & 0x00ff00ff))*ratios[x]) >> 8) + (L & 0x00ff00ff)) & 0x00ff00ff) +
+                                  ((((((R>>8) & 0x00ff00ff) - ((L>>8) & 0x00ff00ff))*ratios[x]) + (L & 0xff00ff00)) & 0xff00ff00);
+                    }
+               }
+               else {
+
+                    lbX = lbT;
+                    lbT = lbB;
+                    lbB = lbX;
+
+
+
+
+                    for (x=0, point=point0; x<cw; x++, point += hfraq) {
+                         long pl = ( (((point)-1) >> 18) - 1 );
+                         do {} while (0);
+
+                         D_ASSERT( pl >= 0 );
+                         D_ASSERT( pl < width-1 );
+
+                         L = (srcB[pl]);
+                         R = (srcB[pl+1]);
+
+                         lbB[x] = ((((((R & 0x00ff00ff) - (L & 0x00ff00ff))*ratios[x]) >> 8) + (L & 0x00ff00ff)) & 0x00ff00ff) +
+                                  ((((((R>>8) & 0x00ff00ff) - ((L>>8) & 0x00ff00ff))*ratios[x]) + (L & 0xff00ff00)) & 0xff00ff00);
+                    }
+               }
+
+               lineT = nlT;
+          }
+
+
+
+
+          X = ( (((((line)) & 0x3ffff) ? : 0x40000) << 8) / (vfraq) );
+
+          for (x=0; x<cw; x++) {
+# 149 "stretch_hvx_32.h"
+               dst32[x] = ((((((lbB[x] & 0x00ff00ff) - (lbT[x] & 0x00ff00ff))*X) >> 8) + (lbT[x] & 0x00ff00ff)) & 0x00ff00ff) +
+                          ((((((lbB[x]>>8) & 0x00ff00ff) - ((lbT[x]>>8) & 0x00ff00ff))*X) + (lbT[x] & 0xff00ff00)) & 0xff00ff00);
+
+          }
+
+          dst32 += dp4;
+          line += vfraq;
+     }
+}
+# 11 "stretch_hvx_N.h" 2
+# 33 "stretch_hvx_N.h"
+static void stretch_hvx_ARGB_down____DSPF_RGB32
+# 1 "stretch_hvx_32.h" 1
+# 11 "stretch_hvx_32.h"
+                                ( void *dst,
+                                  int dpitch,
+                                  const void *src,
+                                  int spitch,
+                                  int width,
+                                  int height,
+                                  int dst_width,
+                                  int dst_height,
+                                  const StretchCtx *ctx )
+{
+     long x, y = 0;
+     long cw = ctx->clip.x2 - ctx->clip.x1 + 1;
+     long ch = ctx->clip.y2 - ctx->clip.y1 + 1;
+     long hfraq = ((long)(width - 0) << 18) / (long)(dst_width);
+     long vfraq = ((long)(height - 0) << 18) / (long)(dst_height);
+     long dp4 = dpitch / 4;
+     long point0 = hfraq + ctx->clip.x1 * hfraq;
+     long point = point0;
+     long line = vfraq + ctx->clip.y1 * vfraq;
+     long ratios[cw];
+     u32 *dst32;
+
+
+
+
+
+     u32 _lbT[cw+8];
+     u32 _lbB[cw+8];
+
+     u32 *lbX;
+     u32 *lbT = (u32*)((((unsigned long)(&_lbT[0])) + 31) & ~31);
+     u32 *lbB = (u32*)((((unsigned long)(&_lbB[0])) + 31) & ~31);
+
+     long lineT = -2000;
+
+     for (x=0; x<cw; x++) {
+          ratios[x] = ( (((((point)) & 0x3ffff) ? : 0x40000) << 8) / (hfraq) );
+
+          point += hfraq;
+     }
+
+     do {} while (0);
+
+     dst = (void*)((char*) dst + ctx->clip.x1 * 4 + ctx->clip.y1 * dpitch);
+
+     dst32 = (u32*) dst;
+
+
+
+
+     for (y=0; y<ch; y++) {
+          long X;
+          long nlT = ( (((line)-1) >> 18) - 1 );
+
+          D_ASSERT( nlT >= 0 );
+          D_ASSERT( nlT < height-1 );
+
+
+
+
+          if (nlT != lineT) {
+               u32 L, R;
+               const u32 *srcT = (const u32 *)((const char*) src + spitch * nlT);
+               const u32 *srcB = (const u32 *)((const char*) src + spitch * (nlT + 1));
+               long diff = nlT - lineT;
+
+               if (diff > 1) {
+
+
+
+                    for (x=0, point=point0; x<cw; x++, point += hfraq) {
+                         long pl = ( (((point)-1) >> 18) - 1 );
+                         do {} while (0);
+
+                         D_ASSERT( pl >= 0 );
+                         D_ASSERT( pl < width-1 );
+
+                         L = ((srcT[pl]) | 0xff000000);
+                         R = ((srcT[pl+1]) | 0xff000000);
+
+                         lbT[x]= ((((((R & 0x00ff00ff) - (L & 0x00ff00ff))*ratios[x]) >> 8) + (L & 0x00ff00ff)) & 0x00ff00ff) +
+                                 ((((((R>>8) & 0x00ff00ff) - ((L>>8) & 0x00ff00ff))*ratios[x]) + (L & 0xff00ff00)) & 0xff00ff00);
+
+                         L = ((srcB[pl]) | 0xff000000);
+                         R = ((srcB[pl+1]) | 0xff000000);
+
+                         lbB[x] = ((((((R & 0x00ff00ff) - (L & 0x00ff00ff))*ratios[x]) >> 8) + (L & 0x00ff00ff)) & 0x00ff00ff) +
+                                  ((((((R>>8) & 0x00ff00ff) - ((L>>8) & 0x00ff00ff))*ratios[x]) + (L & 0xff00ff00)) & 0xff00ff00);
+                    }
+               }
+               else {
+
+                    lbX = lbT;
+                    lbT = lbB;
+                    lbB = lbX;
+
+
+
+
+                    for (x=0, point=point0; x<cw; x++, point += hfraq) {
+                         long pl = ( (((point)-1) >> 18) - 1 );
+                         do {} while (0);
+
+                         D_ASSERT( pl >= 0 );
+                         D_ASSERT( pl < width-1 );
+
+                         L = ((srcB[pl]) | 0xff000000);
+                         R = ((srcB[pl+1]) | 0xff000000);
+
+                         lbB[x] = ((((((R & 0x00ff00ff) - (L & 0x00ff00ff))*ratios[x]) >> 8) + (L & 0x00ff00ff)) & 0x00ff00ff) +
+                                  ((((((R>>8) & 0x00ff00ff) - ((L>>8) & 0x00ff00ff))*ratios[x]) + (L & 0xff00ff00)) & 0xff00ff00);
+                    }
+               }
+
+               lineT = nlT;
+          }
+
+
+
+
+          X = ( (((((line)) & 0x3ffff) ? : 0x40000) << 8) / (vfraq) );
+
+          for (x=0; x<cw; x++) {
+# 149 "stretch_hvx_32.h"
+               dst32[x] = ((((((lbB[x] & 0x00ff00ff) - (lbT[x] & 0x00ff00ff))*X) >> 8) + (lbT[x] & 0x00ff00ff)) & 0x00ff00ff) +
+                          ((((((lbB[x]>>8) & 0x00ff00ff) - ((lbT[x]>>8) & 0x00ff00ff))*X) + (lbT[x] & 0xff00ff00)) & 0xff00ff00);
+
+          }
+
+          dst32 += dp4;
+          line += vfraq;
+     }
+}
+# 35 "stretch_hvx_N.h" 2
+# 50 "stretch_up_down_32.h" 2
+# 74 "Scaler.cxx" 2
+# 99 "Scaler.cxx"
+# 1 "stretch_up_down_32.h" 1
+# 20 "stretch_up_down_32.h"
+# 1 "stretch_hvx_N.h" 1
+# 9 "stretch_hvx_N.h"
+static void stretch_hvx_RGB32_up____DSPF_RGB32
+# 1 "stretch_hvx_32.h" 1
+# 11 "stretch_hvx_32.h"
+                                ( void *dst,
+                                  int dpitch,
+                                  const void *src,
+                                  int spitch,
+                                  int width,
+                                  int height,
+                                  int dst_width,
+                                  int dst_height,
+                                  const StretchCtx *ctx )
+{
+     long x, y = 0;
+     long cw = ctx->clip.x2 - ctx->clip.x1 + 1;
+     long ch = ctx->clip.y2 - ctx->clip.y1 + 1;
+     long hfraq = ((long)(width - 1) << 18) / (long)(dst_width);
+     long vfraq = ((long)(height - 1) << 18) / (long)(dst_height);
+     long dp4 = dpitch / 4;
+     long point0 = 0 + ctx->clip.x1 * hfraq;
+     long point = point0;
+     long line = 0 + ctx->clip.y1 * vfraq;
+     long ratios[cw];
+     u32 *dst32;
+
+
+
+
+
+     u32 _lbT[cw+8];
+     u32 _lbB[cw+8];
+
+     u32 *lbX;
+     u32 *lbT = (u32*)((((unsigned long)(&_lbT[0])) + 31) & ~31);
+     u32 *lbB = (u32*)((((unsigned long)(&_lbB[0])) + 31) & ~31);
+
+     long lineT = -2000;
+
+     for (x=0; x<cw; x++) {
+          ratios[x] = ( ((point) & 0x3ffff) >> (18-8) );
+
+          point += hfraq;
+     }
+
+     do {} while (0);
+
+     dst = (void*)((char*) dst + ctx->clip.x1 * 4 + ctx->clip.y1 * dpitch);
+
+     dst32 = (u32*) dst;
+
+
+
+
+     for (y=0; y<ch; y++) {
+          long X;
+          long nlT = ( (((line)) >> 18) );
+
+          D_ASSERT( nlT >= 0 );
+          D_ASSERT( nlT < height-1 );
+
+
+
+
+          if (nlT != lineT) {
+               u32 L, R;
+               const u32 *srcT = (const u32 *)((const char*) src + spitch * nlT);
+               const u32 *srcB = (const u32 *)((const char*) src + spitch * (nlT + 1));
+               long diff = nlT - lineT;
+
+               if (diff > 1) {
+
+
+
+                    for (x=0, point=point0; x<cw; x++, point += hfraq) {
+                         long pl = ( (((point)) >> 18) );
+                         do {} while (0);
+
+                         D_ASSERT( pl >= 0 );
+                         D_ASSERT( pl < width-1 );
+
+                         L = (srcT[pl]);
+                         R = (srcT[pl+1]);
+
+                         lbT[x]= ((((((R & 0x00ff00ff) - (L & 0x00ff00ff))*ratios[x]) >> 8) + (L & 0x00ff00ff)) & 0x00ff00ff) +
+                                 ((((((R>>8) & 0x00ff00ff) - ((L>>8) & 0x00ff00ff))*ratios[x]) + (L & 0x0000ff00)) & 0x0000ff00);
+
+                         L = (srcB[pl]);
+                         R = (srcB[pl+1]);
+
+                         lbB[x] = ((((((R & 0x00ff00ff) - (L & 0x00ff00ff))*ratios[x]) >> 8) + (L & 0x00ff00ff)) & 0x00ff00ff) +
+                                  ((((((R>>8) & 0x00ff00ff) - ((L>>8) & 0x00ff00ff))*ratios[x]) + (L & 0x0000ff00)) & 0x0000ff00);
+                    }
+               }
+               else {
+
+                    lbX = lbT;
+                    lbT = lbB;
+                    lbB = lbX;
+
+
+
+
+                    for (x=0, point=point0; x<cw; x++, point += hfraq) {
+                         long pl = ( (((point)) >> 18) );
+                         do {} while (0);
+
+                         D_ASSERT( pl >= 0 );
+                         D_ASSERT( pl < width-1 );
+
+                         L = (srcB[pl]);
+                         R = (srcB[pl+1]);
+
+                         lbB[x] = ((((((R & 0x00ff00ff) - (L & 0x00ff00ff))*ratios[x]) >> 8) + (L & 0x00ff00ff)) & 0x00ff00ff) +
+                                  ((((((R>>8) & 0x00ff00ff) - ((L>>8) & 0x00ff00ff))*ratios[x]) + (L & 0x0000ff00)) & 0x0000ff00);
+                    }
+               }
+
+               lineT = nlT;
+          }
+
+
+
+
+          X = ( ((line) & 0x3ffff) >> (18-8) );
+
+          for (x=0; x<cw; x++) {
+# 149 "stretch_hvx_32.h"
+               dst32[x] = ((((((lbB[x] & 0x00ff00ff) - (lbT[x] & 0x00ff00ff))*X) >> 8) + (lbT[x] & 0x00ff00ff)) & 0x00ff00ff) +
+                          ((((((lbB[x]>>8) & 0x00ff00ff) - ((lbT[x]>>8) & 0x00ff00ff))*X) + (lbT[x] & 0x0000ff00)) & 0x0000ff00);
+
+          }
+
+          dst32 += dp4;
+          line += vfraq;
+     }
+}
+# 11 "stretch_hvx_N.h" 2
+# 21 "stretch_up_down_32.h" 2
+# 49 "stretch_up_down_32.h"
+# 1 "stretch_hvx_N.h" 1
+# 9 "stretch_hvx_N.h"
+static void stretch_hvx_RGB32_down____DSPF_RGB32
+# 1 "stretch_hvx_32.h" 1
+# 11 "stretch_hvx_32.h"
+                                ( void *dst,
+                                  int dpitch,
+                                  const void *src,
+                                  int spitch,
+                                  int width,
+                                  int height,
+                                  int dst_width,
+                                  int dst_height,
+                                  const StretchCtx *ctx )
+{
+     long x, y = 0;
+     long cw = ctx->clip.x2 - ctx->clip.x1 + 1;
+     long ch = ctx->clip.y2 - ctx->clip.y1 + 1;
+     long hfraq = ((long)(width - 0) << 18) / (long)(dst_width);
+     long vfraq = ((long)(height - 0) << 18) / (long)(dst_height);
+     long dp4 = dpitch / 4;
+     long point0 = hfraq + ctx->clip.x1 * hfraq;
+     long point = point0;
+     long line = vfraq + ctx->clip.y1 * vfraq;
+     long ratios[cw];
+     u32 *dst32;
+
+
+
+
+
+     u32 _lbT[cw+8];
+     u32 _lbB[cw+8];
+
+     u32 *lbX;
+     u32 *lbT = (u32*)((((unsigned long)(&_lbT[0])) + 31) & ~31);
+     u32 *lbB = (u32*)((((unsigned long)(&_lbB[0])) + 31) & ~31);
+
+     long lineT = -2000;
+
+     for (x=0; x<cw; x++) {
+          ratios[x] = ( (((((point)) & 0x3ffff) ? : 0x40000) << 8) / (hfraq) );
+
+          point += hfraq;
+     }
+
+     do {} while (0);
+
+     dst = (void*)((char*) dst + ctx->clip.x1 * 4 + ctx->clip.y1 * dpitch);
+
+     dst32 = (u32*) dst;
+
+
+
+
+     for (y=0; y<ch; y++) {
+          long X;
+          long nlT = ( (((line)-1) >> 18) - 1 );
+
+          D_ASSERT( nlT >= 0 );
+          D_ASSERT( nlT < height-1 );
+
+
+
+
+          if (nlT != lineT) {
+               u32 L, R;
+               const u32 *srcT = (const u32 *)((const char*) src + spitch * nlT);
+               const u32 *srcB = (const u32 *)((const char*) src + spitch * (nlT + 1));
+               long diff = nlT - lineT;
+
+               if (diff > 1) {
+
+
+
+                    for (x=0, point=point0; x<cw; x++, point += hfraq) {
+                         long pl = ( (((point)-1) >> 18) - 1 );
+                         do {} while (0);
+
+                         D_ASSERT( pl >= 0 );
+                         D_ASSERT( pl < width-1 );
+
+                         L = (srcT[pl]);
+                         R = (srcT[pl+1]);
+
+                         lbT[x]= ((((((R & 0x00ff00ff) - (L & 0x00ff00ff))*ratios[x]) >> 8) + (L & 0x00ff00ff)) & 0x00ff00ff) +
+                                 ((((((R>>8) & 0x00ff00ff) - ((L>>8) & 0x00ff00ff))*ratios[x]) + (L & 0x0000ff00)) & 0x0000ff00);
+
+                         L = (srcB[pl]);
+                         R = (srcB[pl+1]);
+
+                         lbB[x] = ((((((R & 0x00ff00ff) - (L & 0x00ff00ff))*ratios[x]) >> 8) + (L & 0x00ff00ff)) & 0x00ff00ff) +
+                                  ((((((R>>8) & 0x00ff00ff) - ((L>>8) & 0x00ff00ff))*ratios[x]) + (L & 0x0000ff00)) & 0x0000ff00);
+                    }
+               }
+               else {
+
+                    lbX = lbT;
+                    lbT = lbB;
+                    lbB = lbX;
+
+
+
+
+                    for (x=0, point=point0; x<cw; x++, point += hfraq) {
+                         long pl = ( (((point)-1) >> 18) - 1 );
+                         do {} while (0);
+
+                         D_ASSERT( pl >= 0 );
+                         D_ASSERT( pl < width-1 );
+
+                         L = (srcB[pl]);
+                         R = (srcB[pl+1]);
+
+                         lbB[x] = ((((((R & 0x00ff00ff) - (L & 0x00ff00ff))*ratios[x]) >> 8) + (L & 0x00ff00ff)) & 0x00ff00ff) +
+                                  ((((((R>>8) & 0x00ff00ff) - ((L>>8) & 0x00ff00ff))*ratios[x]) + (L & 0x0000ff00)) & 0x0000ff00);
+                    }
+               }
+
+               lineT = nlT;
+          }
+
+
+
+
+          X = ( (((((line)) & 0x3ffff) ? : 0x40000) << 8) / (vfraq) );
+
+          for (x=0; x<cw; x++) {
+# 149 "stretch_hvx_32.h"
+               dst32[x] = ((((((lbB[x] & 0x00ff00ff) - (lbT[x] & 0x00ff00ff))*X) >> 8) + (lbT[x] & 0x00ff00ff)) & 0x00ff00ff) +
+                          ((((((lbB[x]>>8) & 0x00ff00ff) - ((lbT[x]>>8) & 0x00ff00ff))*X) + (lbT[x] & 0x0000ff00)) & 0x0000ff00);
+
+          }
+
+          dst32 += dp4;
+          line += vfraq;
+     }
+}
+# 11 "stretch_hvx_N.h" 2
+# 50 "stretch_up_down_32.h" 2
+# 100 "Scaler.cxx" 2
+# 112 "Scaler.cxx"
+class Scaler
+{
+
+     public: Scaler() {
+     }
+
+     public: void scale( DFBSurfacePixelFormat format,
+                        void *dst,
+                        int dpitch,
+                        const void *src,
+                        int spitch,
+                        int width,
+                        int height,
+                        int dst_width,
+                        int dst_height,
+                        const DFBRegion &clip )
+     {
+          D_DEBUG_AT( PluggIt_Scaler, "%s( %s, %p [%d], %p [%d], %dx%d -> %dx%d, clip %4d,%4d-%4dx%4d )\n",
+                      __FUNCTION__, dfb_pixelformat_name( format ), dst, dpitch, src, spitch, width, height,
+                      dst_width, dst_height, DFB_RECTANGLE_VALS_FROM_REGION( &clip ) );
+
+
+          StretchCtx ctx;
+
+          ctx.clip = clip;
+
+          switch (format) {
+               case DSPF_RGB16:
+                    if (width <= dst_width || height <= dst_height)
+                         stretch_hvx_RGB16_up____DSPF_RGB32( dst, dpitch, src, spitch, width, height, dst_width, dst_height, &ctx );
+                    else
+                         stretch_hvx_RGB16_down____DSPF_RGB32( dst, dpitch, src, spitch, width, height, dst_width, dst_height, &ctx );
+                    break;
+
+               case DSPF_RGB32:
+                    if (width <= dst_width || height <= dst_height)
+                         stretch_hvx_RGB32_up____DSPF_RGB32( dst, dpitch, src, spitch, width, height, dst_width, dst_height, &ctx );
+                    else
+                         stretch_hvx_RGB32_down____DSPF_RGB32( dst, dpitch, src, spitch, width, height, dst_width, dst_height, &ctx );
+                    break;
+
+               case DSPF_ARGB:
+                    if (width <= dst_width || height <= dst_height)
+                         stretch_hvx_ARGB_up____DSPF_RGB32( dst, dpitch, src, spitch, width, height, dst_width, dst_height, &ctx );
+                    else
+                         stretch_hvx_ARGB_down____DSPF_RGB32( dst, dpitch, src, spitch, width, height, dst_width, dst_height, &ctx );
+                    break;
+
+               default:
+                    D_UNIMPLEMENTED();
+                    break;
+          }
+     }
+};
+
+
+
+}
+# 1 "View.cxx"
+# 1 "<built-in>"
+# 1 "<command-line>"
+# 1 "View.cxx"
+namespace PluggIt {
+
+class View
+{
+     public: virtual void config( DFBDimension &size ) = 0;
+
+     public: virtual void update( const vector<DFBRectangle_C> &rects,
+                                 void *ptr,
+                                 int pitch ) = 0;
+};
+
+}
+# 1 "Source.cxx"
+# 1 "<built-in>"
+# 1 "<command-line>"
+# 1 "Source.cxx"
+namespace PluggIt {
+
+class Source
+{
+     protected: class Config {
+          protected: Config() {}
+     };
+
+
+     protected: View *m_view;
+     protected: const Config &m_config;
+
+     public: Source( View *view, const Config &config ) : m_config(config) {
+          m_view = view;
+     }
+
+
+     public: virtual int MainLoop() = 0;
+};
+
+}
+# 1 "SourceWin32.cxx"
+# 1 "<built-in>"
+# 1 "<command-line>"
+# 1 "SourceWin32.cxx"
+namespace PluggIt {
+
+D_DEBUG_DOMAIN( PluggIt_SourceWin32, "PluggIt/SourceWin32", "PluggIt Source Win32" );
+
+
+# 1 "ScreenHooks.h" 1
+# 28 "ScreenHooks.h"
+extern "C"
+{
+  __attribute__((dllexport)) bool setHook(HWND targedWinHwnd);
+  __attribute__((dllexport)) bool unsetHook();
+}
+# 7 "SourceWin32.cxx" 2
+
+const UINT specIpcCode = RegisterWindowMessage("HOOK.MESSAGE.CODE");
+
+
+class SourceWin32 :public Source, Runnable
+{
+     private: HINSTANCE m_hInstance;
+
+     private: HWND m_root;
+     private: HWND m_window;
+
+     private: DFBPoint m_position;
+     private: DFBDimension m_size;
+
+     private: HBITMAP m_bitmap;
+     private: void *m_pixels;
+     private: int m_pitch;
+
+     private: HBITMAP m_bitmap2;
+     private: void *m_pixels2;
+     private: int m_pitch2;
+
+     private: HDC m_window_dc;
+     private: HDC m_bitmap_dc;
+     private: HDC m_bitmap_dc2;
+
+     private: Thread *m_thread;
+
+     private: Updates m_updates;
+
+     private: VIDEODRIVER m_driver;
+     private: bool m_using_driver;
+
+     private: pthread_mutex_t m_lock;
+     private: pthread_cond_t m_cond;
+
+
+     public: class Config :public Source::Config {
+          friend class SourceWin32;
+
+          public: typedef enum {
+               WINDOW_SELECTION_NONE,
+               WINDOW_SELECTION_TITLE,
+               WINDOW_SELECTION_INTERACTIVE
+          } WindowSelection;
+
+          private: WindowSelection m_selection;
+          private: std::string m_title;
+          private: bool m_updating;
+          private: bool m_use_driver;
+
+
+          public: Config( WindowSelection selection,
+                         const std::string &title = std::string(),
+                         bool updating = false, bool use_driver = true )
+          {
+               m_selection = selection;
+               m_title = title;
+               m_updating = updating;
+               m_use_driver = use_driver;
+          }
+     };
+
+
+     public: SourceWin32( View *view, const Config &config ) : Source( view, config ), m_updates(16) {
+          D_DEBUG_AT( PluggIt_SourceWin32, "%s( %p )\n", __FUNCTION__, view );
+
+          m_hInstance = GetModuleHandle( NULL );
+
+          D_DEBUG_AT( PluggIt_SourceWin32, "  -> hInstance %p\n", m_hInstance );
+
+
+          m_root = GetDesktopWindow();
+
+          switch (config.m_selection) {
+               case Config::WINDOW_SELECTION_NONE:
+                    m_window = m_root;
+                    break;
+
+               case Config::WINDOW_SELECTION_TITLE:
+                    m_window = findWindow( config.m_title );
+                    if (m_window == 0)
+                         throw new Exception( "Could not find window with title containing '%s'\n", config.m_title.c_str() );
+                    break;
+
+               case Config::WINDOW_SELECTION_INTERACTIVE:
+                    pickWindow();
+                    if (m_window == 0)
+                         throw new Exception( "Could not interactively pick a window\n" );
+                    break;
+
+               default:
+                    throw new Exception( "Invalid window selection method\n" );
+          }
+
+
+          RECT rect;
+
+          GetClientRect( m_window, &rect );
+
+          m_position.x = rect.left;
+          m_position.y = rect.top;
+
+          m_size.w = rect.right - rect.left;
+          m_size.h = rect.bottom - rect.top;
+
+          queueUpdate( 0, 0, m_size.w - 1, m_size.h - 1 );
+
+
+          std::string t = getWindowTitle( m_window );
+
+          D_INFO( "Source/Win32: Window %d,%d-%ux%u, name '%s'\n",
+                  m_position.x, m_position.y, m_size.w, m_size.h, t.c_str() );
+
+          if (config.m_use_driver)
+               m_driver.VIDEODRIVER_start( m_position.x, m_position.y, m_size.w, m_size.h );
+
+          m_using_driver = m_driver.mypchangebuf != NULL;
+
+          m_view->config( m_size );
+
+
+          m_window_dc = GetDC( m_window );
+          m_bitmap_dc = CreateCompatibleDC( m_window_dc );
+          m_bitmap_dc2 = CreateCompatibleDC( m_window_dc );
+
+
+          BITMAPINFO bitmap_info = {{
+               biSize: sizeof(BITMAPINFOHEADER),
+               biWidth: m_size.w,
+               biHeight: m_size.h,
+               biPlanes: 1,
+               biBitCount: 32,
+               biCompression: BI_RGB,
+               biSizeImage: 0,
+               biXPelsPerMeter: 0,
+               biYPelsPerMeter: 0,
+               biClrUsed: 0,
+               biClrImportant: 0,
+          }};
+
+          m_bitmap = CreateDIBSection( m_window_dc, &bitmap_info, DIB_RGB_COLORS, &m_pixels, NULL, 0 );
+          m_bitmap2 = CreateDIBSection( m_window_dc, &bitmap_info, DIB_RGB_COLORS, &m_pixels2, NULL, 0 );
+
+
+          BITMAP bitmap;
+
+          GetObject( m_bitmap, sizeof(BITMAP), &bitmap );
+
+          m_pitch = bitmap.bmWidthBytes;
+
+          GetObject( m_bitmap2, sizeof(BITMAP), &bitmap );
+
+          m_pitch2 = bitmap.bmWidthBytes;
+
+
+          SelectObject( m_bitmap_dc, m_bitmap );
+          SelectObject( m_bitmap_dc2, m_bitmap2 );
+
+
+          pthread_mutex_init( &m_lock, NULL );
+          pthread_cond_init( &m_cond, NULL );
+
+
+          if (!m_using_driver) {
+               HWND w;
+
+               WNDCLASSEX wndClass;
+
+               ZeroMemory( &wndClass, sizeof(wndClass) );
+
+               wndClass.cbSize = sizeof(wndClass);
+               wndClass.style = CS_HREDRAW | CS_VREDRAW;
+               wndClass.lpfnWndProc = MsgWndProc;
+               wndClass.cbClsExtra = 0;
+               wndClass.cbWndExtra = 0;
+               wndClass.hInstance = GetModuleHandle(NULL);
+               wndClass.hIcon = NULL;
+               wndClass.hIconSm = NULL;
+               wndClass.hCursor = LoadCursor( NULL, IDC_UPARROW );
+               wndClass.hbrBackground = (HBRUSH) GetStockObject( NULL_BRUSH );
+               wndClass.lpszMenuName = NULL;
+               wndClass.lpszClassName = "MsgWindow";
+
+               if (!RegisterClassEx( &wndClass ))
+                    throw new Exception( "RegisterClassEx() failed!" );
+
+
+               w = CreateWindowEx( 0,
+                                   "MsgWindow",
+                                   "MsgWindow",
+                                   WS_POPUP,
+                                   CW_USEDEFAULT,
+                                   CW_USEDEFAULT,
+                                   1,
+                                   1,
+                                   NULL,
+                                   NULL,
+                                   GetModuleHandle(NULL),
+                                   this );
+
+               if (!setHook( w ))
+                    throw new Exception( "Failed to set hooks!" );
+          }
+
+
+
+          m_thread = new Thread( this, "SourceWin32" );
+
+          m_thread->start();
+     }
+
+     virtual ~SourceWin32() {
+          m_thread->interrupt();
+          m_thread->join();
+          delete m_thread;
+
+          pthread_mutex_destroy( &m_lock );
+          pthread_cond_destroy( &m_cond );
+
+          DeleteDC( m_window_dc );
+          DeleteDC( m_bitmap_dc );
+          DeleteDC( m_bitmap_dc2 );
+
+          DeleteObject( m_bitmap );
+          DeleteObject( m_bitmap2 );
+     }
+
+     private: void addRect( const RECT &rect ) {
+          if (rect.left >= rect.right)
+               return;
+
+          if (rect.top >= rect.bottom)
+               return;
+
+          DFBRegion region( rect.left,
+                            rect.top,
+                            rect.right - 1,
+                            rect.bottom - 1 );
+
+          m_updates.addRegion( region );
+     }
+
+     private: void run() {
+          if (m_using_driver) {
+               D_ASSERT( m_driver.mypchangebuf != NULL );
+
+               unsigned int counter = m_driver.mypchangebuf->counter;
+               unsigned int i;
+
+               long long last_time = direct_clock_get_abs_millis();
+
+               D_DEBUG_AT( PluggIt_SourceWin32, "%s()\n", __FUNCTION__ );
+
+               while (!m_thread->isInterrupted()) {
+                    if (m_driver.mypchangebuf->counter < 1 ||
+                        m_driver.mypchangebuf->counter >= MAXCHANGES_BUF ||
+                        counter == m_driver.mypchangebuf->counter)
+                         usleep( 10000 );
+
+                    if (counter != m_driver.mypchangebuf->counter) {
+                         D_DEBUG_AT( PluggIt_SourceWin32, "  -> counter: %d -> %d\n", counter, m_driver.mypchangebuf->counter );
+
+                         if (counter < m_driver.mypchangebuf->counter) {
+                              for (i=counter+1; i<=m_driver.mypchangebuf->counter; i++) {
+                                   addRect( m_driver.mypchangebuf->pointrect[i].rect );
+                              }
+                         }
+                         else if (counter > m_driver.mypchangebuf->counter) {
+                              for (i=counter+1; i<MAXCHANGES_BUF; i++) {
+                                   addRect( m_driver.mypchangebuf->pointrect[i].rect );
+                              }
+                              for (i=1; i<=m_driver.mypchangebuf->counter; i++) {
+                                   addRect( m_driver.mypchangebuf->pointrect[i].rect );
+                              }
+                         }
+
+                         counter = m_driver.mypchangebuf->counter;
+                    }
+
+                    if (direct_clock_get_abs_millis() - last_time > 2000) {
+                         DFBRegion region( 0,
+                                           0,
+                                           m_size.w - 1,
+                                           m_size.h - 1 );
+
+                         m_updates.addRegion( region );
+
+                         last_time = direct_clock_get_abs_millis();
+                    }
+
+                    if (m_updates.num_regions() > 0) {
+                         vector<DFBRectangle_C> rects;
+
+                         m_updates.GetRectangles( rects );
+
+
+                         const DFBRegion &bounding = m_updates.bounding();
+
+                         D_DEBUG_AT( PluggIt_SourceWin32, "  -> %4d,%4d-%4dx%4d (%d regions, %d rectangles)\n",
+                                     DFB_RECTANGLE_VALS_FROM_REGION( &bounding ), m_updates.num_regions(), rects.size() );
+
+                         m_updates.reset();
+
+                         flushUpdates( rects );
+                    }
+               }
+          }
+          else {
+               D_DEBUG_AT( PluggIt_SourceWin32, "%s()\n", __FUNCTION__ );
+
+               long long last_time = direct_clock_get_abs_millis();
+
+               while (!m_thread->isInterrupted()) {
+                    if (((const Config&)m_config).m_updating) {
+                         usleep( 100000 );
+
+                         queueUpdate( 0, 0, m_size.w - 1, m_size.h - 1 );
+
+                         pthread_mutex_lock( &m_lock );
+                    }
+                    else {
+                         pthread_mutex_lock( &m_lock );
+
+                         if (m_updates.num_regions() == 0)
+                              usleep( 10000 );
+
+                    }
+
+                    if (direct_clock_get_abs_millis() - last_time > 2000) {
+                         DFBRegion region( 0,
+                                           0,
+                                           m_size.w - 1,
+                                           m_size.h - 1 );
+
+                         m_updates.addRegion( region );
+
+                         last_time = direct_clock_get_abs_millis();
+                    }
+
+
+                    vector<DFBRectangle_C> rects;
+
+                    if (m_updates.num_regions() > 0) {
+                         m_updates.GetRectangles( rects );
+
+
+                         const DFBRegion &bounding = m_updates.bounding();
+
+                         D_DEBUG_AT( PluggIt_SourceWin32, "  -> %4d,%4d-%4dx%4d (%d regions, %d rectangles)\n",
+                                     DFB_RECTANGLE_VALS_FROM_REGION( &bounding ), m_updates.num_regions(), rects.size() );
+
+                         m_updates.reset();
+                    }
+
+                    pthread_mutex_unlock( &m_lock );
+
+                    if (!rects.empty())
+                         flushUpdates( rects );
+               }
+          }
+     }
+
+
+
+     private: void queueUpdate( int x1, int y1, int x2, int y2 ) {
+          D_DEBUG_AT( PluggIt_SourceWin32, "%s( %d,%d-%dx%d )\n", __FUNCTION__, x1, y1, x2 - x1 + 1, y2 - y1 + 1 );
+
+          pthread_mutex_lock( &m_lock );
+
+          DFBRegion damage( x1, y1, x2, y2 );
+
+          m_updates.addRegion( damage );
+
+          pthread_mutex_unlock( &m_lock );
+
+          pthread_cond_signal( &m_cond );
+     }
+
+     private: bool flushUpdates( vector<DFBRectangle_C> &rects ) {
+          D_DEBUG_AT( PluggIt_SourceWin32, "%s()\n", __FUNCTION__ );
+
+          if (m_using_driver) {
+               m_view->update( rects, m_driver.myframebuffer, m_pitch );
+          }
+          else {
+               for (unsigned int i=0; i<rects.size(); i++) {
+                    BitBlt( m_bitmap_dc,
+                            rects[i].x,
+                            rects[i].y,
+                            rects[i].w,
+                            rects[i].h,
+                            m_window_dc,
+                            rects[i].x,
+                            rects[i].y,
+                            SRCCOPY );
+               }
+
+               m_view->update( rects, (void*)((char*) m_pixels + m_pitch * (m_size.h - 1)), - m_pitch );
+          }
+
+          D_DEBUG_AT( PluggIt_SourceWin32, "  -> flush done\n" );
+
+          return true;
+     }
+
+
+
+
+
+     private: static std::string getWindowTitle( HWND window ) {
+          char buf[1024] = { 0 };
+
+          GetWindowText( window, buf, sizeof(buf) );
+
+          D_DEBUG_AT( PluggIt_SourceWin32, "%s( %p ) -> '%s'\n", __FUNCTION__, window, buf );
+
+          return buf;
+     }
+
+
+
+
+     class EnumContext {
+          public: const std::string &title;
+          public: HWND window;
+
+          public: EnumContext( const std::string &title ) : title(title), window(0) {}
+     };
+
+     private: static BOOL CALLBACK enumWindowsProc( HWND hwnd,
+                                                   LPARAM lParam )
+     {
+          EnumContext *ctx = reinterpret_cast<EnumContext *>( lParam );
+
+          D_DEBUG_AT( PluggIt_SourceWin32, "%s( %p )\n", __FUNCTION__, hwnd );
+
+          std::string title = getWindowTitle( hwnd );
+
+          if (title == ctx->title || title.find( ctx->title ) < title.size())
+               ctx->window = hwnd;
+
+          return ctx->window == NULL;
+     }
+
+     private: HWND findWindow( const std::string &title ) {
+          D_DEBUG_AT( PluggIt_SourceWin32, "%s( %s )\n", __FUNCTION__, title.c_str() );
+
+          EnumContext ctx( title );
+
+          EnumWindows( enumWindowsProc, reinterpret_cast<LPARAM>( &ctx ) );
+
+          return ctx.window;
+     }
+
+
+
+
+     static LRESULT CALLBACK WndProc( HWND hwnd,
+                                      UINT uMsg,
+                                      WPARAM wParam,
+                                      LPARAM lParam )
+     {
+          static SourceWin32 *thiz;
+          POINT point;
+          CREATESTRUCT *create;
+
+          switch (uMsg) {
+               case WM_CREATE:
+                    create = reinterpret_cast<LPCREATESTRUCT>( lParam );
+                    thiz = reinterpret_cast<SourceWin32 *>( create->lpCreateParams );
+
+                    SetCursor( LoadCursor( NULL, IDC_CROSS ) );
+                    break;
+
+               case WM_LBUTTONDOWN:
+                    ShowWindow( hwnd, SW_HIDE );
+
+
+                    GetCursorPos( &point );
+
+                    D_DEBUG_AT( PluggIt_SourceWin32, "  -> Cursor position is %ld,%ld\n", point.x, point.y );
+
+
+                    thiz->m_window = WindowFromPoint( point );
+                    if (thiz->m_window) {
+                         HWND parent;
+
+                         while ((parent = GetParent( thiz->m_window )) != NULL)
+                              thiz->m_window = parent;
+                    }
+
+                    D_DEBUG_AT( PluggIt_SourceWin32, "  -> Window at cursor is %p: %s\n",
+                                thiz->m_window, getWindowTitle( thiz->m_window ).c_str() );
+
+                    DestroyWindow( hwnd );
+                    break;
+
+               case WM_TIMER:
+                    if (wParam == 666)
+                         DestroyWindow( hwnd );
+                    break;
+
+               case WM_DESTROY:
+                    KillTimer( hwnd, 666 );
+                    PostQuitMessage( 0 );
+                    break;
+
+              default:
+                   SetTimer( hwnd, 666, 5000, NULL );
+
+                   return DefWindowProc( hwnd, uMsg, wParam, lParam );
+          }
+
+          return 0;
+     }
+
+     private: void pickWindow() {
+          D_DEBUG_AT( PluggIt_SourceWin32, "%s()\n", __FUNCTION__ );
+
+          HDC hdc;
+
+          hdc = GetDC( NULL );
+          if (!hdc)
+               throw new Exception( "GetDC() returned NULL" );
+
+          RECT rect;
+
+          GetClipBox( hdc, &rect );
+
+          D_DEBUG_AT( PluggIt_SourceWin32, "  -> Desktop size: %ldx%ld\n",
+                      rect.right - rect.left, rect.bottom - rect.top );
+
+          ReleaseDC( NULL, hdc );
+
+
+
+          WNDCLASSEX wndClass;
+
+          ZeroMemory( &wndClass, sizeof(wndClass) );
+
+          wndClass.cbSize = sizeof(wndClass);
+          wndClass.style = CS_HREDRAW | CS_VREDRAW;
+          wndClass.lpfnWndProc = WndProc;
+          wndClass.cbClsExtra = 0;
+          wndClass.cbWndExtra = 0;
+          wndClass.hInstance = m_hInstance;
+          wndClass.hIcon = NULL;
+          wndClass.hIconSm = NULL;
+          wndClass.hCursor = LoadCursor( NULL, IDC_UPARROW );
+          wndClass.hbrBackground = (HBRUSH) GetStockObject( NULL_BRUSH );
+          wndClass.lpszMenuName = NULL;
+          wndClass.lpszClassName = "GrabWindow";
+
+          if (!RegisterClassEx( &wndClass ))
+               throw new Exception( "RegisterClassEx() failed!\n" );
+
+
+          AdjustWindowRect( &rect, WS_CAPTION, FALSE );
+
+
+          HWND grabwin;
+
+          grabwin = CreateWindowEx( 0,
+                                    "GrabWindow",
+                                    "GrabWindow",
+                                    WS_POPUP,
+                                    CW_USEDEFAULT,
+                                    CW_USEDEFAULT,
+                                    rect.right - rect.left,
+                                    rect.bottom - rect.top,
+                                    NULL,
+                                    NULL,
+                                    m_hInstance,
+                                    this );
+
+          SetWindowLong( grabwin, GWL_EXSTYLE,
+                         GetWindowLong( grabwin, GWL_EXSTYLE ) | WS_EX_TRANSPARENT | WS_EX_TOPMOST );
+
+          ShowWindow( grabwin, SW_SHOW );
+
+
+
+          MSG msg;
+
+          while (GetMessage( &msg, 0, 0, 0 )) {
+               TranslateMessage( &msg );
+
+               D_DEBUG_AT( PluggIt_SourceWin32, "  -> Dispatching event (id %u)...\n", msg.message );
+
+               DispatchMessage( &msg );
+          }
+     }
+
+
+
+     static LRESULT CALLBACK MsgWndProc( HWND hwnd,
+                                         UINT uMsg,
+                                         WPARAM wParam,
+                                         LPARAM lParam )
+     {
+          static SourceWin32 *thiz;
+          CREATESTRUCT *create;
+
+          switch (uMsg) {
+               case WM_CREATE:
+                    create = reinterpret_cast<LPCREATESTRUCT>( lParam );
+                    thiz = reinterpret_cast<SourceWin32 *>( create->lpCreateParams );
+                    break;
+
+               case WM_DESTROY:
+                    PostQuitMessage( 0 );
+                    break;
+
+               default:
+                    if (uMsg == specIpcCode) {
+                         int x1 = wParam >> 16;
+                         int y1 = wParam & 0xffff;
+                         int x2 = lParam >> 16;
+                         int y2 = lParam & 0xffff;
+
+                         if (x1 < x2 && y1 < y2)
+                              thiz->queueUpdate( x1, y1, x2 - 1, y2 - 1 );
+
+                         break;
+                    }
+
+                    return DefWindowProc( hwnd, uMsg, wParam, lParam );
+          }
+
+          return 0;
+     }
+
+     public: virtual int MainLoop() {
+          MSG msg;
+
+          while (GetMessage( &msg, 0, 0, 0 )) {
+               TranslateMessage( &msg );
+               DispatchMessage( &msg );
+          }
+
+          return 0;
+     }
+};
+
+}
+# 1 "Main.cxx"
+# 1 "<built-in>"
+# 1 "<command-line>"
+# 1 "Main.cxx"
+namespace PluggIt {
+
+D_DEBUG_DOMAIN( PluggIt_Main, "PluggIt/Main", "PluggIt Main" );
+D_DEBUG_DOMAIN( PluggIt_View, "PluggIt/View", "PluggIt View" );
+
+class Main :public View
+{
+     class Config {
+          public: DFBDimension m_size;
+          public: DFBPoint m_offset;
+          public: DFBDimension m_resolution;
+          public: DFBSurfacePixelFormat m_format;
+          public: std::string m_title;
+          public: bool m_interactive;
+          public: bool m_updating;
+          public: bool m_use_driver;
+
+          public: Config() :
+               m_format(DSPF_UNKNOWN),
+               m_interactive(false),
+               m_updating(false)
+          {
+          }
+     };
+
+
+     private: Config m_config;
+     private: Options m_options;
+     private: Scaler m_scaler;
+
+     private: IDirectFB m_dfb;
+     private: IDirectFBDisplayLayer m_layer;
+     private: IDirectFBWindow m_window;
+     private: IDirectFBSurface m_surface;
+     private: IDirectFBEventBuffer m_events;
+
+     private: Source *m_source;
+
+     private: DFBDimension m_source_resolution;
+
+     private: DFBDimension m_view_size;
+     private: DFBDimension m_view_resolution;
+     private: bool m_view_visible;
+     private: DFBSurfacePixelFormat m_view_format;
+
+
+     public: Main() :
+          m_source(NULL),
+          m_view_visible(false)
+     {
+          D_DEBUG_AT( PluggIt_Main, "%s()\n", __FUNCTION__ );
+
+          m_options.addOption( new Options::OptionDimension( "-s", "--size", "<width>x<height>", "Size of view", m_config.m_size ) );
+          m_options.addOption( new Options::OptionPoint ( "-o", "--offset", "<x>,<y>", "Offset of view", m_config.m_offset ) );
+          m_options.addOption( new Options::OptionDimension( "-r", "--resolution", "<X>x<Y>", "Resolution of view", m_config.m_resolution ) );
+          m_options.addOption( new Options::OptionFormat ( "-f", "--format", "<pixelformat>", "Pixel format of view", m_config.m_format ) );
+          m_options.addOption( new Options::OptionString ( "-t", "--title", "<string>", "Title of window to show", m_config.m_title ) );
+          m_options.addOption( new Options::OptionBool ( "-i", "--interactive", "", "Use interactive window picking", m_config.m_interactive ) );
+          m_options.addOption( new Options::OptionBool ( "-u", "--updating", "", "Update continuously", m_config.m_updating ) );
+          m_options.addOption( new Options::OptionBool ( "-d", "--driver", "", "Use driver mode", m_config.m_use_driver ) );
+     }
+
+     public: void main( int argc, char *argv[] ) {
+          D_DEBUG_AT( PluggIt_Main, "%s()\n", __FUNCTION__ );
+
+          try {
+
+               DirectFB::Init( &argc, &argv );
+
+               if (!m_options.parseCommandLine( argc, argv ))
+                    return;
+
+               initDFB();
+               initSource();
+
+               run();
+          }
+          catch (DFBException *e) {
+               cerr << endl;
+               cerr << "Caught exception!" << endl;
+               cerr << "  ==> " << e << endl;
+          }
+          catch (Exception *e) {
+               cerr << endl;
+               cerr << "Caught exception!" << endl;
+               cerr << "  ==> " << e << endl;
+          }
+     }
+
+     private: void initDFB() {
+          D_DEBUG_AT( PluggIt_Main, "%s()\n", __FUNCTION__ );
+
+
+          m_dfb = DirectFB::Create();
+
+          m_layer = m_dfb.GetDisplayLayer( DLID_PRIMARY );
+
+          m_events = m_dfb.CreateEventBuffer();
+     }
+
+     private: void initSource() {
+          D_DEBUG_AT( PluggIt_Main, "%s()\n", __FUNCTION__ );
+
+
+          SourceWin32::Config config( m_config.m_interactive ?
+                                      SourceWin32::Config::WINDOW_SELECTION_INTERACTIVE :
+                                      (m_config.m_title.size() > 0 ?
+                                       SourceWin32::Config::WINDOW_SELECTION_TITLE :
+                                       SourceWin32::Config::WINDOW_SELECTION_NONE), m_config.m_title,
+                                      m_config.m_updating, m_config.m_use_driver );
+
+          m_source = new SourceWin32( this, config );
+# 122 "Main.cxx"
+     }
+
+     private: void run() {
+          m_source->MainLoop();
+     }
+
+     public: virtual void config( DFBDimension &source_resolution ) {
+          D_DEBUG_AT( PluggIt_View, "%s( %u, %u )\n", __FUNCTION__, source_resolution.w, source_resolution.h );
+
+
+          if (m_source_resolution == source_resolution) {
+               D_DEBUG_AT( PluggIt_View, "  -> unchanged source size\n" );
+               return;
+          }
+
+          m_source_resolution = source_resolution;
+
+
+
+          DFBDimension resolution = m_config.m_resolution;
+
+          if (!resolution.w) {
+               if (!resolution.h) {
+                    resolution = source_resolution;
+
+                    D_DEBUG_AT( PluggIt_View, "  -> no width/height\n" );
+               }
+               else {
+                    resolution.w = resolution.h * source_resolution.w / source_resolution.h;
+
+                    D_DEBUG_AT( PluggIt_View, "  -> no width\n" );
+               }
+          }
+          else if (!resolution.h) {
+               resolution.h = resolution.w * source_resolution.h / source_resolution.w;
+
+               D_DEBUG_AT( PluggIt_View, "  -> no height\n" );
+          }
+
+          D_DEBUG_AT( PluggIt_View, "  -> resolution %ux%u\n", resolution.w, resolution.h );
+
+
+
+          DFBDimension size = m_config.m_size;
+
+          if (!size.w) {
+               if (!size.h) {
+                    size = resolution;
+
+                    D_DEBUG_AT( PluggIt_View, "  -> no width/height\n" );
+               }
+               else {
+                    size.w = size.h * resolution.w / resolution.h;
+
+                    D_DEBUG_AT( PluggIt_View, "  -> no width\n" );
+               }
+          }
+          else if (!size.h) {
+               size.h = size.w * resolution.h / resolution.w;
+
+               D_DEBUG_AT( PluggIt_View, "  -> no height\n" );
+          }
+
+          D_DEBUG_AT( PluggIt_View, "  -> %ux%u\n", size.w, size.h );
+
+
+          if (m_view_resolution == resolution)
+               D_DEBUG_AT( PluggIt_View, "  -> unchanged view resolution\n" );
+
+          if (m_view_size == size) {
+               D_DEBUG_AT( PluggIt_View, "  -> unchanged view size\n" );
+               return;
+          }
+
+          if (m_window)
+               m_window.Resize( size.w, size.h );
+          else {
+
+               DFBWindowDescription desc;
+
+               desc.flags = (DFBWindowDescriptionFlags)( DWDESC_POSX | DWDESC_POSY |
+                                                               DWDESC_WIDTH | DWDESC_HEIGHT | DWDESC_PIXELFORMAT );
+               desc.posx = 0;
+               desc.posy = 0;
+               desc.width = size.w;
+               desc.height = size.h;
+               desc.pixelformat = m_config.m_format;
+
+               m_window = m_layer.CreateWindow( desc );
+
+               m_surface = m_window.GetSurface();
+
+               m_view_format = m_surface.GetPixelFormat();
+
+               m_window.AttachEventBuffer( m_events );
+          }
+
+          m_view_size = size;
+          m_view_resolution = resolution;
+
+
+          D_DEBUG_AT( PluggIt_View, "  -> view size         %4ux%4u\n", m_view_size.w, m_view_size.h );
+          D_DEBUG_AT( PluggIt_View, "  -> view resolution   %4ux%4u\n", m_view_resolution.w, m_view_resolution.h );
+          D_DEBUG_AT( PluggIt_View, "  -> source resolution %4ux%4u\n", m_source_resolution.w, m_source_resolution.h );
+     }
+
+     public: virtual void update( const vector<DFBRectangle_C> &rects,
+                                 void *ptr,
+                                 int pitch )
+     {
+          unsigned int i;
+          DFBRegion clip( m_view_size );
+          const DFBPoint &offset = m_config.m_offset;
+          bool first = true;
+          DFBRegion flip;
+
+          D_DEBUG_AT( PluggIt_View, "%s( [%u], %p, %d )\n", __FUNCTION__, rects.size(), ptr, pitch );
+
+          D_ASSERT( rects.size() > 0 );
+          D_ASSERT( ptr != NULL );
+
+
+
+          if (m_source_resolution == m_view_resolution) {
+               D_DEBUG_AT( PluggIt_View, "  -> unscaled %4dx%4d\n",
+                           m_source_resolution.w, m_source_resolution.h );
+
+               if (m_view_format == DSPF_RGB16) {
+                    int tp = ((m_view_size.w * 2) + 7) & ~7;
+                    void *tmp = malloc( tp * m_view_size.h );
+
+                    for (i=0; i<rects.size(); i++) {
+                         D_DEBUG_AT( PluggIt_View, "  -> [%2d] %4d,%4d-%4dx%4d (original)\n",
+                                     i, DFB_RECTANGLE_VALS( &rects[i] ) );
+
+                         DFBRegion region( DFBRectangle(rects[i]) - offset );
+
+                         D_DEBUG_AT( PluggIt_View, "  ->      %4d,%4d-%4dx%4d (translated)\n",
+                                     DFB_RECTANGLE_VALS_FROM_REGION( &region ) );
+
+                         ptr = (void*)((char*) ptr + offset.x * 4 + offset.y * pitch);
+
+
+                         if (dfb_region_region_intersect( &region, &clip )) {
+                              D_DEBUG_AT( PluggIt_View, "  ->      %4d,%4d-%4dx%4d (clipped update)\n",
+                                          DFB_RECTANGLE_VALS_FROM_REGION( &region ) );
+
+                              DFBRectangle rect( region );
+
+                              dfb_convert_to_rgb16( DSPF_RGB32,
+                                                    (void*)((char*) ptr + rect.x * 4 + rect.y * pitch), pitch,
+                                                    m_view_size.h, (u16*) tmp, tp, rect.w, rect.h );
+
+                              m_surface.Write( (char*) tmp + DFB_BYTES_PER_LINE( m_view_format, region.x1 ) + region.y1 * tp, tp, &rect );
+
+                              if (first) {
+                                   first = false;
+                                   flip = region;
+                              }
+                              else
+                                   flip.unionWith( region );
+
+                         }
+                    }
+
+                    free( tmp );
+               }
+               else {
+                    for (i=0; i<rects.size(); i++) {
+                         D_DEBUG_AT( PluggIt_View, "  -> [%2d] %4d,%4d-%4dx%4d (original)\n",
+                                     i, DFB_RECTANGLE_VALS( &rects[i] ) );
+
+                         DFBRegion region( DFBRectangle(rects[i]) - offset );
+
+                         D_DEBUG_AT( PluggIt_View, "  ->      %4d,%4d-%4dx%4d (translated)\n",
+                                     DFB_RECTANGLE_VALS_FROM_REGION( &region ) );
+
+                         ptr = (void*)((char*) ptr + offset.x * 4 + offset.y * pitch);
+
+
+                         if (dfb_region_region_intersect( &region, &clip )) {
+                              D_DEBUG_AT( PluggIt_View, "  ->      %4d,%4d-%4dx%4d (clipped update)\n",
+                                          DFB_RECTANGLE_VALS_FROM_REGION( &region ) );
+
+                              DFBRectangle rect( region );
+
+                              if (m_view_format == DSPF_ARGB) {
+                                   u32 *p = (u32*)((char*) ptr + rect.x * 4 + rect.y * pitch);
+
+                                   for (int y=0; y<rect.h; y++) {
+                                        for (int x=0; x<rect.w; x++)
+                                             p[x] |= 0xff000000;
+
+                                        p = (u32*)((char*) p + pitch);
+                                   }
+                              }
+
+                              D_DEBUG_AT( PluggIt_View, "  -> Write...\n" );
+                              m_surface.Write( (char*) ptr + DFB_BYTES_PER_LINE( m_view_format, region.x1 ) + region.y1 * pitch, pitch, &rect );
+                              D_DEBUG_AT( PluggIt_View, "  -> Write done.\n" );
+
+                              if (first) {
+                                   first = false;
+                                   flip = region;
+                              }
+                              else
+                                   flip.unionWith( region );
+
+                         }
+                    }
+               }
+          }
+          else {
+               int tp = ((m_view_size.w * 4) + 7) & ~7;
+               void *tmp = malloc( tp * m_view_size.h );
+
+               D_DEBUG_AT( PluggIt_View, "  -> scaled %4dx%4d => %4dx%4d\n",
+                           m_source_resolution.w, m_source_resolution.h,
+                           m_view_resolution.w, m_view_resolution.h );
+
+               for (i=0; i<rects.size(); i++) {
+                    D_DEBUG_AT( PluggIt_View, "  -> [%2d] %4d,%4d-%4dx%4d (original)\n",
+                                i, DFB_RECTANGLE_VALS( &rects[i] ) );
+
+                    DFBRegion region( DFBRectangle(rects[i]) - offset );
+
+                    D_DEBUG_AT( PluggIt_View, "  ->      %4d,%4d-%4dx%4d (translated)\n",
+                                DFB_RECTANGLE_VALS_FROM_REGION( &region ) );
+
+                    ptr = (void*)((char*) ptr + offset.x * 4 + offset.y * pitch);
+
+
+                    region.x1 = region.x1 * m_view_resolution.w / m_source_resolution.w;
+                    region.y1 = region.y1 * m_view_resolution.h / m_source_resolution.h;
+                    region.x2 = region.x2 * m_view_resolution.w / m_source_resolution.w;
+                    region.y2 = region.y2 * m_view_resolution.h / m_source_resolution.h;
+
+                    if (region.x1 > 0)
+                         region.x1--;
+
+                    if (region.y1 > 0)
+                         region.y1--;
+
+                    if (region.x2 < m_view_resolution.w-1)
+                         region.x2++;
+                    if (region.x2 < m_view_resolution.w-1)
+                         region.x2++;
+
+                    if (region.y2 < m_view_resolution.h-1)
+                         region.y2++;
+                    if (region.y2 < m_view_resolution.h-1)
+                         region.y2++;
+
+                    D_DEBUG_AT( PluggIt_View, "  ->      %4d,%4d-%4dx%4d (scaled)\n",
+                                DFB_RECTANGLE_VALS_FROM_REGION( &region ) );
+
+
+                    if (dfb_region_region_intersect( &region, &clip )) {
+                         D_DEBUG_AT( PluggIt_View, "  ->      %4d,%4d-%4dx%4d (clipped)\n",
+                                     DFB_RECTANGLE_VALS_FROM_REGION( &region ) );
+
+                         DFBRectangle rect( region );
+
+                         m_scaler.scale( m_view_format, tmp, tp, ptr, pitch,
+                                         m_source_resolution.w, m_source_resolution.h,
+                                         m_view_resolution.w, m_view_resolution.h, region );
+
+                         m_surface.Write( (char*) tmp + DFB_BYTES_PER_LINE( m_view_format, region.x1 ) + region.y1 * tp, tp, &rect );
+
+                         if (first) {
+                              first = false;
+                              flip = region;
+                         }
+                         else
+                              flip.unionWith( region );
+
+                    }
+               }
+
+               free( tmp );
+          }
+
+          m_surface.Flip( &flip );
+
+          if (!m_view_visible) {
+               m_window.SetOpacity( 0xff );
+
+               m_view_visible = true;
+          }
+     }
+};
+
+}
+extern "C" {
+# 1 "main.c"
+# 1 "<built-in>"
+# 1 "<command-line>"
+# 1 "main.c"
+
+int
+main( int argc, char *argv[] )
+{
+     PluggIt::Main *main = new PluggIt::Main();
+
+     main->main( argc, argv );
+
+     delete main;
+}
+}
-- 
cgit