Port of Duke Nukem 3D

This ports Fabien Sanglard's Chocolate Duke to run on a version of SDL
for Rockbox.

Change-Id: I8f2c4c78af19de10c1633ed7bb7a997b43256dd9

1 files changed, 358 insertions, 0 deletions

diff --git a/apps/plugins/sdl/src/video/SDL_stretch.c b/apps/plugins/sdl/src/video/SDL_stretch.c
new file mode 100644
index 0000000000..7ce401ff7a
--- /dev/null
+++ b/apps/plugins/sdl/src/video/SDL_stretch.c
@@ -0,0 +1,358 @@
+/*
+    SDL - Simple DirectMedia Layer
+    Copyright (C) 1997-2012 Sam Lantinga
+
+    This library is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Lesser General Public
+    License as published by the Free Software Foundation; either
+    version 2.1 of the License, or (at your option) any later version.
+
+    This library is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+    Lesser General Public License for more details.
+
+    You should have received a copy of the GNU Lesser General Public
+    License along with this library; if not, write to the Free Software
+    Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+
+    Sam Lantinga
+    slouken@libsdl.org
+*/
+#include "SDL_config.h"
+
+/* This a stretch blit implementation based on ideas given to me by
+   Tomasz Cejner - thanks! :)
+
+   April 27, 2000 - Sam Lantinga
+*/
+
+#include "SDL_video.h"
+#include "SDL_blit.h"
+
+/* This isn't ready for general consumption yet - it should be folded
+   into the general blitting mechanism.
+*/
+
+#if ((defined(_MFC_VER) && defined(_M_IX86)/* && !defined(_WIN32_WCE) still needed? */) || \
+     defined(__WATCOMC__) || \
+     (defined(__GNUC__) && defined(__i386__))) && SDL_ASSEMBLY_ROUTINES
+/* There's a bug with gcc 4.4.1 and -O2 where srcp doesn't get the correct
+ * value after the first scanline.  FIXME? */
+/*#define USE_ASM_STRETCH*/
+#endif
+
+#ifdef USE_ASM_STRETCH
+
+#ifdef HAVE_MPROTECT
+#include <sys/types.h>
+#include <sys/mman.h>
+#endif
+#ifdef __GNUC__
+#define PAGE_ALIGNED __attribute__((__aligned__(4096)))
+#else
+#define PAGE_ALIGNED
+#endif
+
+#if defined(_M_IX86) || defined(i386)
+#define PREFIX16        0x66
+#define STORE_BYTE      0xAA
+#define STORE_WORD      0xAB
+#define LOAD_BYTE       0xAC
+#define LOAD_WORD       0xAD
+#define RETURN          0xC3
+#else
+#error Need assembly opcodes for this architecture
+#endif
+
+static unsigned char copy_row[4096] PAGE_ALIGNED;
+
+static int generate_rowbytes(int src_w, int dst_w, int bpp)
+{
+        static struct {
+                int bpp;
+                int src_w;
+                int dst_w;
+                int status;
+        } last;
+
+        int i;
+        int pos, inc;
+        unsigned char *eip, *fence;
+        unsigned char load, store;
+
+        /* See if we need to regenerate the copy buffer */
+        if ( (src_w == last.src_w) &&
+             (dst_w == last.dst_w) && (bpp == last.bpp) ) {
+                return(last.status);
+        }
+        last.bpp = bpp;
+        last.src_w = src_w;
+        last.dst_w = dst_w;
+        last.status = -1;
+
+        switch (bpp) {
+            case 1:
+                load = LOAD_BYTE;
+                store = STORE_BYTE;
+                break;
+            case 2:
+            case 4:
+                load = LOAD_WORD;
+                store = STORE_WORD;
+                break;
+            default:
+                SDL_SetError("ASM stretch of %d bytes isn't supported\n", bpp);
+                return(-1);
+        }
+#ifdef HAVE_MPROTECT
+        /* Make the code writeable */
+        if ( mprotect(copy_row, sizeof(copy_row), PROT_READ|PROT_WRITE) < 0 ) {
+                SDL_SetError("Couldn't make copy buffer writeable");
+                return(-1);
+        }
+#endif
+        pos = 0x10000;
+        inc = (src_w << 16) / dst_w;
+        eip = copy_row;
+        fence = copy_row+sizeof(copy_row)-2;
+        for ( i=0; i<dst_w && eip < end; ++i ) {
+                while ( pos >= 0x10000L ) {
+                        if ( eip == fence ) {
+                                return -1;
+                        }
+                        if ( bpp == 2 ) {
+                                *eip++ = PREFIX16;
+                        }
+                        *eip++ = load;
+                        pos -= 0x10000L;
+                }
+                if ( eip == fence ) {
+                        return -1;
+                }
+                if ( bpp == 2 ) {
+                        *eip++ = PREFIX16;
+                }
+                *eip++ = store;
+                pos += inc;
+        }
+        *eip++ = RETURN;
+
+#ifdef HAVE_MPROTECT
+        /* Make the code executable but not writeable */
+        if ( mprotect(copy_row, sizeof(copy_row), PROT_READ|PROT_EXEC) < 0 ) {
+                SDL_SetError("Couldn't make copy buffer executable");
+                return(-1);
+        }
+#endif
+        last.status = 0;
+        return(0);
+}
+
+#endif /* USE_ASM_STRETCH */
+
+#define DEFINE_COPY_ROW(name, type)                     \
+void name(type *src, int src_w, type *dst, int dst_w)   \
+{                                                       \
+        int i;                                          \
+        int pos, inc;                                   \
+        type pixel = 0;                                 \
+                                                        \
+        pos = 0x10000;                                  \
+        inc = (src_w << 16) / dst_w;                    \
+        for ( i=dst_w; i>0; --i ) {                     \
+                while ( pos >= 0x10000L ) {             \
+                        pixel = *src++;                 \
+                        pos -= 0x10000L;                \
+                }                                       \
+                *dst++ = pixel;                         \
+                pos += inc;                             \
+        }                                               \
+}
+DEFINE_COPY_ROW(copy_row1, Uint8)
+DEFINE_COPY_ROW(copy_row2, Uint16)
+DEFINE_COPY_ROW(copy_row4, Uint32)
+
+/* The ASM code doesn't handle 24-bpp stretch blits */
+void copy_row3(Uint8 *src, int src_w, Uint8 *dst, int dst_w)
+{
+        int i;
+        int pos, inc;
+        Uint8 pixel[3] = { 0, 0, 0 };
+
+        pos = 0x10000;
+        inc = (src_w << 16) / dst_w;
+        for ( i=dst_w; i>0; --i ) {
+                while ( pos >= 0x10000L ) {
+                        pixel[0] = *src++;
+                        pixel[1] = *src++;
+                        pixel[2] = *src++;
+                        pos -= 0x10000L;
+                }
+                *dst++ = pixel[0];
+                *dst++ = pixel[1];
+                *dst++ = pixel[2];
+                pos += inc;
+        }
+}
+
+/* Perform a stretch blit between two surfaces of the same format.
+   NOTE:  This function is not safe to call from multiple threads!
+*/
+int SDL_SoftStretch(SDL_Surface *src, SDL_Rect *srcrect,
+                    SDL_Surface *dst, SDL_Rect *dstrect)
+{
+        int src_locked;
+        int dst_locked;
+        int pos, inc;
+        int dst_maxrow;
+        int src_row, dst_row;
+        Uint8 *srcp = NULL;
+        Uint8 *dstp;
+        SDL_Rect full_src;
+        SDL_Rect full_dst;
+#ifdef USE_ASM_STRETCH
+        SDL_bool use_asm = SDL_TRUE;
+#ifdef __GNUC__
+        int u1, u2;
+#endif
+#endif /* USE_ASM_STRETCH */
+        const int bpp = dst->format->BytesPerPixel;
+
+        if ( src->format->BitsPerPixel != dst->format->BitsPerPixel ) {
+                SDL_SetError("Only works with same format surfaces");
+                return(-1);
+        }
+
+        /* Verify the blit rectangles */
+        if ( srcrect ) {
+                if ( (srcrect->x < 0) || (srcrect->y < 0) ||
+                     ((srcrect->x+srcrect->w) > src->w) ||
+                     ((srcrect->y+srcrect->h) > src->h) ) {
+                        SDL_SetError("Invalid source blit rectangle");
+                        return(-1);
+                }
+        } else {
+                full_src.x = 0;
+                full_src.y = 0;
+                full_src.w = src->w;
+                full_src.h = src->h;
+                srcrect = &full_src;
+        }
+        if ( dstrect ) {
+                if ( (dstrect->x < 0) || (dstrect->y < 0) ||
+                     ((dstrect->x+dstrect->w) > dst->w) ||
+                     ((dstrect->y+dstrect->h) > dst->h) ) {
+                        SDL_SetError("Invalid destination blit rectangle");
+                        return(-1);
+                }
+        } else {
+                full_dst.x = 0;
+                full_dst.y = 0;
+                full_dst.w = dst->w;
+                full_dst.h = dst->h;
+                dstrect = &full_dst;
+        }
+
+        /* Lock the destination if it's in hardware */
+        dst_locked = 0;
+        if ( SDL_MUSTLOCK(dst) ) {
+                if ( SDL_LockSurface(dst) < 0 ) {
+                        SDL_SetError("Unable to lock destination surface");
+                        return(-1);
+                }
+                dst_locked = 1;
+        }
+        /* Lock the source if it's in hardware */
+        src_locked = 0;
+        if ( SDL_MUSTLOCK(src) ) {
+                if ( SDL_LockSurface(src) < 0 ) {
+                        if ( dst_locked ) {
+                                SDL_UnlockSurface(dst);
+                        }
+                        SDL_SetError("Unable to lock source surface");
+                        return(-1);
+                }
+                src_locked = 1;
+        }
+
+        /* Set up the data... */
+        pos = 0x10000;
+        inc = (srcrect->h << 16) / dstrect->h;
+        src_row = srcrect->y;
+        dst_row = dstrect->y;
+
+#ifdef USE_ASM_STRETCH
+        /* Write the opcodes for this stretch */
+        if ( (bpp == 3) ||
+             (generate_rowbytes(srcrect->w, dstrect->w, bpp) < 0) ) {
+                use_asm = SDL_FALSE;
+        }
+#endif
+
+        /* Perform the stretch blit */
+        for ( dst_maxrow = dst_row+dstrect->h; dst_row<dst_maxrow; ++dst_row ) {
+                dstp = (Uint8 *)dst->pixels + (dst_row*dst->pitch)
+                                            + (dstrect->x*bpp);
+                while ( pos >= 0x10000L ) {
+                        srcp = (Uint8 *)src->pixels + (src_row*src->pitch)
+                                                    + (srcrect->x*bpp);
+                        ++src_row;
+                        pos -= 0x10000L;
+                }
+#ifdef USE_ASM_STRETCH
+                if (use_asm) {
+#ifdef __GNUC__
+                        __asm__ __volatile__ (
+                        "call *%4"
+                        : "=&D" (u1), "=&S" (u2)
+                        : "0" (dstp), "1" (srcp), "r" (copy_row)
+                        : "memory" );
+#elif defined(_MSC_VER) || defined(__WATCOMC__)
+                { void *code = copy_row;
+                        __asm {
+                                push edi
+                                push esi
+        
+                                mov edi, dstp
+                                mov esi, srcp
+                                call dword ptr code
+
+                                pop esi
+                                pop edi
+                        }
+                }
+#else
+#error Need inline assembly for this compiler
+#endif
+                } else
+#endif
+                switch (bpp) {
+                    case 1:
+                        copy_row1(srcp, srcrect->w, dstp, dstrect->w);
+                        break;
+                    case 2:
+                        copy_row2((Uint16 *)srcp, srcrect->w,
+                                  (Uint16 *)dstp, dstrect->w);
+                        break;
+                    case 3:
+                        copy_row3(srcp, srcrect->w, dstp, dstrect->w);
+                        break;
+                    case 4:
+                        copy_row4((Uint32 *)srcp, srcrect->w,
+                                  (Uint32 *)dstp, dstrect->w);
+                        break;
+                }
+                pos += inc;
+        }
+
+        /* We need to unlock the surfaces if they're locked */
+        if ( dst_locked ) {
+                SDL_UnlockSurface(dst);
+        }
+        if ( src_locked ) {
+                SDL_UnlockSurface(src);
+        }
+        return(0);
+}
+