Initial import

1 files changed, 1703 insertions, 0 deletions

diff --git a/xine_post_swscale.c b/xine_post_swscale.c
new file mode 100644
index 00000000..bea7ce0a
--- /dev/null
+++ b/xine_post_swscale.c
@@ -0,0 +1,1703 @@
+/*
+ * Copyright (C) 2000-2007 the xine project
+ * 
+ * This file is part of xine, a free video player.
+ * 
+ * xine is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ * 
+ * xine is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ * 
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA
+ *
+ * $Id: xine_post_swscale.c,v 1.1 2008-02-20 22:31:23 phintuka Exp $
+ *
+ * Simple (faster) resize for avisynth
+ *     Copyright (C) 2002 Tom Barry
+ *
+ * Very simple 2 tap linear interpolation.  
+ * It is unfiltered which means it will not soften much.
+ *
+ * WarpedResize will do a non-linear stretch/squeeze in both the horizontal 
+ * and vertical dimensions. This can be useful when you want to change the 
+ * aspect ratio of a video clip and have it mostly distorted at the
+ * top, bottom, and side edges. 
+ *
+ *
+ * Ported to linux/xine by Petri Hintukainen <phintuka@users.sourceforge.net>
+ *    - Added x86_64 support
+ *    - Added PIC support (do not clobber ebx in x86, access only local variables from asm)
+ *    - Fixed yv12 stretched warp tables generation
+ */
+ 
+#include <xine/xine_internal.h>
+#include <xine/post.h>
+
+/*#define DBG(x...)*/
+#define DBG(x...) fprintf(stderr, "post_warp: " x)
+
+#define STREAMING_STORE
+#define PREFETCH
+/*#define VANILLA*/
+
+/*
+ * This function accepts a position from 0 to 1 and warps it, to 0 through 1 based
+ * upon the wFact var. The warp equations are designed to:
+ * 
+ * * Always be rising but yield results from 0 to 1
+ *
+ * * Have a first derivative that doesn't go to 0 or infinity, at least close
+ *   to the center of the screen
+ *
+ * * Have a curvature (absolute val of 2nd derivative) that is small in the
+ *   center and smoothly rises towards the edges. We would like the curvature
+ *   to be everywhere = 0 when the warp factor = 1
+ */
+static double WarpFactor(double position, double wFact)
+{
+  double x;
+  double z;
+  double w;
+  x = 2 * (position - .5);
+  if (1) /*(wFact < 1.0)*/
+    /* For warp factor < 1 the warp is calculated as (1-w) * x^3 + w *x, centered
+     *
+     * The warp is calculated as z = (1 - w) * x^3 + w * x, centered
+     * around .5 and ranging from 0 to 1. After some tinkering this seems
+     * to give decent values and derivatives at the right places.
+     */
+    w = 2.0 - wFact; /* reverse parm for compat with initial release */
+  
+  if (x < 0.0) {
+    z = -(1 - w) * x*x*x - w * x; /* -1 < x < 0, wFact < 1 */
+    return .5 - .5 * z;                     
+  } else {
+    z = (1 - w) * x*x*x + w * x;  /* -1 < x < 0, wFact < 1 */
+    return .5 + .5 * z;           /* amts to same formula as above for now */
+  }
+}
+
+/*
+ * YV12
+ *
+ * For each horizontal output pair of pixels there is are 2 qword masks followed by 2 int
+ * offsets. The 2 masks are the weights to be used for the luma and chroma, respectively.
+ * Each mask contains LeftWeight1, RightWeight1, LeftWeight2, RightWeight2. So a pair of pixels
+ * will later be processed each pass through the horizontal resize loop.  I think with my
+ * current math the Horizontal Luma and Chroma contains the same values but since I may have screwed it
+ * up I'll leave it this way for now. Vertical chroma is different.
+ *
+ * Note - try just using the luma calcs for both, seem to be the same.
+ *
+ * The weights are scaled 0-256 and the left and right weights will sum to 256 for each pixel.
+ */
+static void init_tables_yv12(int newwidth, int newheight, int oldwidth, int oldheight,
+			     int Interlaced, double hWarp, double vWarp,
+			     uint32_t *hControl,   uint32_t *vOffsets,   uint32_t *vWeights,
+			     uint32_t *hControlUV, uint32_t *vOffsetsUV, uint32_t *vWeightsUV)
+{
+  int i;
+  int j;
+  int k;
+  int wY1;
+  int wY2;
+  DBG("init_yv12: %dx%d->%dx%d hWarp %1.3lf vWarp %1.3lf\n", 
+      oldwidth, oldheight, newwidth, newheight, hWarp, vWarp);
+
+  /* First set up horizontal table, use for both luma & chroma since 
+   * it seems to have the same equation.
+   * We will geneerate these values in pairs, mostly because that's the way
+   * I wrote it for YUY2 above.
+   */
+
+  for(i=0; i < newwidth; i+=2) {
+    /* first make even pixel control */
+    if (hWarp==1)  /*if no warp factor */
+      j = i * 256 * (oldwidth-1) / (newwidth-1);
+    else           /* stretch and warp somehow */
+      j = (int) (256 * WarpFactor(i / (newwidth-1.0), hWarp) * (oldwidth-1));
+    
+    k = j>>8;
+    wY2 = j - (k << 8);  /* luma weight of right pixel */
+    wY1 = 256 - wY2;     /* luma weight of left pixel  */
+
+    if (k > oldwidth - 2) {
+      hControl[i*3+4] = oldwidth - 1;  /* point to last byte */
+      hControl[i*3] =   0x00000100;    /* use 100% of rightmost Y */
+    } else {
+      hControl[i*3+4] = k;             /* pixel offset */
+      hControl[i*3] = wY2 << 16 | wY1; /* luma weights */
+    }
+
+    /* now make odd pixel control */
+    if (hWarp==1)   /* if no warp factor */
+      j = (i+1) * 256 * (oldwidth-1) / (newwidth-1);
+    else        /* stretch and warp somehow */
+      j = (int) (256 * WarpFactor((i+1) / (newwidth-1.0), hWarp) * (oldwidth-1));
+
+    k = j>>8;
+    wY2 = j - (k << 8); /* luma weight of right pixel */
+    wY1 = 256 - wY2;    /* luma weight of left pixel  */
+
+    if (k > oldwidth - 2) {
+      hControl[i*3+5] = oldwidth - 1; /* point to last byte  */
+      hControl[i*3+1] = 0x00000100;   /* use 100% of rightmost Y */
+    } else {
+      hControl[i*3+5] = k;               /* pixel offset */
+      hControl[i*3+1] = wY2 << 16 | wY1; /* luma weights */
+    }
+  }
+
+  hControl[newwidth*3+4] =  2 * (oldwidth-1); /* give it something to prefetch at end */
+  hControl[newwidth*3+5] =  2 * (oldwidth-1); /*  "  */
+#ifndef VANILLA
+  // UV
+  for(i=0; i < newwidth/2; i+=2) {
+    /* first make even pixel control */
+    if (hWarp==1)  /*if no warp factor */
+      j = i * 256 * (oldwidth/2-1) / (newwidth/2-1);
+    else           /* stretch and warp somehow */
+      j = (int) (256 * WarpFactor(i / (newwidth/2-1.0), hWarp) * (oldwidth/2-1));
+    
+    k = j>>8;
+    wY2 = j - (k << 8);  /* luma weight of right pixel */
+    wY1 = 256 - wY2;     /* luma weight of left pixel  */
+
+    if (k > oldwidth/2 - 2) {
+      hControlUV[i*3+4] = oldwidth/2 - 1;  /* point to last byte */
+      hControlUV[i*3] =   0x00000100;    /* use 100% of rightmost Y */
+    } else {
+      hControlUV[i*3+4] = k;             /* pixel offset */
+      hControlUV[i*3] = wY2 << 16 | wY1; /* luma weights */
+    }
+
+    /* now make odd pixel control */
+    if (hWarp==1)   /* if no warp factor */
+      j = (i+1) * 256 * (oldwidth/2-1) / (newwidth/2-1);
+    else        /* stretch and warp somehow */
+      j = (int) (256 * WarpFactor((i+1) / (newwidth/2-1.0), hWarp) * (oldwidth/2-1));
+
+    k = j>>8;
+    wY2 = j - (k << 8); /* luma weight of right pixel */
+    wY1 = 256 - wY2;    /* luma weight of left pixel  */
+
+    if (k > oldwidth/2 - 2) {
+      hControlUV[i*3+5] = oldwidth/2 - 1; /* point to last byte  */
+      hControlUV[i*3+1] = 0x00000100;   /* use 100% of rightmost Y */
+    } else {
+      hControlUV[i*3+5] = k;               /* pixel offset */
+      hControlUV[i*3+1] = wY2 << 16 | wY1; /* luma weights */
+    }
+  }
+
+  hControlUV[newwidth/2*3+4] =  (oldwidth/2-1); /* give it something to prefetch at end */
+  hControlUV[newwidth/2*3+5] =  (oldwidth/2-1); /*  "  */
+#endif
+
+  /* Next set up vertical tables. The offsets are measured in lines and will be mult */
+  /* by the source pitch later . */
+
+  /* For YV12 we need separate Luma and chroma tables */
+
+  /* First Luma Table */
+  for(i=0; i< newheight; ++i) {
+    if (vWarp==1)  /* if no warp factor */
+      j = i * 256 * (oldheight-1) / (newheight-1);
+    else           /* stretch and warp somehow */
+      j = (int) (256 * WarpFactor(i / (newheight-1.0), vWarp) * (oldheight-1));
+    
+    if (Interlaced) {  /* do hard way? */
+      if (i%2) {       /* is odd output line? */
+	if (j < 256) {     /* before 1st odd input line */
+	  vOffsets[i] = 1; /* all from line 1 */
+	  vWeights[i] = 0; /* weight to give to 2nd line */
+	} else {
+	  k = (((j-256) >> 9) << 1) + 1; /* next lowest odd line */
+	  vOffsets[i] = k;
+	  wY2 = j - (k << 8); 
+	  vWeights[i] = wY2 >> 1; /* weight to give to 2nd line */
+	}
+      } else {         /* is even output line */
+	k = (j >> 9) << 1;        /* next lower even line */
+	vOffsets[i] = k;
+	wY2 = j - (k << 8); 
+	vWeights[i] = wY2 >> 1;   /* weight to give to 2nd line */
+      }
+    } else {           /* simple way, do as progressive */
+      k = j >> 8;
+      vOffsets[i] = k;
+      wY2 = j - (k << 8); 
+      vWeights[i] = wY2;   /* weight to give to 2nd line */
+    }
+  }
+
+  /* Vertical table for chroma */
+  for(i=0; i< newheight/2; ++i) {
+    if (vWarp==1)  /* if no warp factor */
+#ifdef VANILLA
+      j = (int) ( (i+.25) * 256 * (oldheight-1) / (newheight-1.0) - 64 );
+#else
+      j = (int) ( (i+.25) * 256 * (oldheight/2-1) / (newheight/2-1.0) - 64 );
+#endif
+    else           /* stretch and warp somehow */
+#ifdef VANILLA
+      j = (int) (256 * WarpFactor( (i+.25) / (newheight-1.0), vWarp) * (oldheight-1.0) );
+#else
+      j = (int) (256 * WarpFactor( (i+.25) / (newheight/2 - 1.0), vWarp) * (oldheight/2 - 1.0) );
+#endif
+#ifndef VANILLA
+    if(j<0) j=0;
+#endif
+    if (Interlaced) { /* do hard way? */
+      if (i%2) {                /* is odd output line? */
+	if (j < 256) {            /* before 1st odd input line */
+	  vOffsetsUV[i] = 1;         /* all from line 1 */
+	  vWeightsUV[i] = 0;         /* weight to give to 2nd line */
+	} else {
+	  k = (((j-256) >> 9) << 1) + 1; /* next lowest odd line */
+	  vOffsetsUV[i] = k;
+	  wY2 = j - (k << 8); 
+	  vWeightsUV[i] = wY2 >> 1;  /* weight to give to 2nd line */
+	}
+      } else {                  /* is even output line */
+#ifdef VANILLA
+	k = (j >> 9) << 1;         /* next lower even line */
+	vOffsetsUV[i] = k;
+	wY2 = j - (k << 8); 
+	vWeightsUV[i] = wY2 >> 1;  /* weight to give to 2nd line */
+#else
+	k = (j / 512) << 1;         /* next lower even line */
+	vOffsetsUV[i] = k;
+	wY2 = j - (k << 8); 
+	vWeightsUV[i] = wY2 >> 1;  /* weight to give to 2nd line */
+#endif
+      }
+    } else {              /* simple way, do as progressive */
+#ifdef VANILLA
+      k = j >> 8;
+#else
+      k = j / 256; /* j >> 8;  does not work right if  -256 < j < 0 */
+#endif
+      vOffsetsUV[i] = k;
+      wY2 = j - (k << 8);
+      vWeightsUV[i] = wY2;      /* weight to give to 2nd line */
+    }
+  }
+}
+
+/*
+ * YUY2
+ *
+ * For each horizontal output pair of pixels there is are 2 qword masks followed by 2 int
+ * offsets. The 2 masks are the weights to be used for the luma and chroma, respectively.
+ * Each mask contains LeftWeight1, RightWeight1, LeftWeight2, RightWeight2. So a pair of pixels
+ * will later be processed each pass through the horizontal resize loop.
+ *
+ * The weights are scaled 0-256 and the left and right weights will sum to 256 for each pixel.
+ */
+static void init_tables_yuy2(int newwidth, int newheight, int oldwidth, int oldheight,
+			     int Interlaced, double hWarp, double vWarp,
+			     uint32_t *hControl, uint32_t *vOffsets, uint32_t *vWeights )
+{
+  int i;
+  int j;
+  int k;
+  int wY1;
+  int wY2;
+  int wUV1;
+  int wUV2;
+  DBG("init_yuy2: %dx%d->%dx%d hWarp %1.3lf vWarp %1.3lf\n", 
+      oldwidth, oldheight, newwidth, newheight, hWarp, vWarp);
+  
+  /* First set up horizontal table */
+  for(i=0; i < newwidth; i+=2) {
+    /* first make even pixel control */
+    if (hWarp==1)          /* if no warp factor */
+      j = i * 256 * (oldwidth-1) / (newwidth-1);
+    else                   /* stretch and warp somehow */
+      j = (int) (256 * WarpFactor(i / (newwidth-1.0), hWarp) * (oldwidth-1));
+    
+    k = j>>8;
+    wY2 = j - (k << 8);	   /* luma weight of right pixel */
+    wY1 = 256 - wY2;       /* luma weight of left pixel  */
+    wUV2 = (k%2)  ?  128 + (wY2 >> 1)  :  wY2 >> 1;
+    wUV1 = 256 - wUV2;
+    
+    if (k > oldwidth - 2) {
+      hControl[i*3+4] = oldwidth - 1;      /* point to last byte      */
+      hControl[i*3]   = 0x00000100;        /* use 100% of rightmost Y */
+      hControl[i*3+2] = 0x00000100;        /* use 100% of rightmost U */
+    } else {
+      hControl[i*3+4] = k;                 /* pixel offset   */
+      hControl[i*3]   = wY2 << 16 | wY1;   /* luma weights   */
+      hControl[i*3+2] = wUV2 << 16 | wUV1; /* chroma weights */
+    }
+    
+    /* now make odd pixel control */
+    if (hWarp==1)                          /* if no warp factor */
+      j = (i+1) * 256 * (oldwidth-1) / (newwidth-1);
+    else                                   /* stretch and warp somehow */
+      j = (int) (256 * WarpFactor((i+1) / (newwidth-1.0), hWarp) * (oldwidth-1));
+    
+    k = j>>8;
+    wY2 = j - (k << 8); /* luma weight of right pixel */
+    wY1 = 256 - wY2;    /* luma weight of left pixel  */
+    wUV2 = (k%2)  ?  128 + (wY2 >> 1)  :  wY2 >> 1;
+    wUV1 = 256 - wUV2;
+    
+    if (k > oldwidth - 2) {
+      hControl[i*3+5] = oldwidth - 1;    /* point to last byte      */
+      hControl[i*3+1] = 0x00000100;      /* use 100% of rightmost Y */
+      hControl[i*3+3] = 0x00000100;      /* use 100% of rightmost V */
+    } else {
+      hControl[i*3+5] = k;               /* pixel offset */
+      hControl[i*3+1] = wY2 << 16 | wY1; /* luma weights */
+      /*			hControl[i*3+3] = wUV2 << 16 | wUV1; // chroma weights */
+      /* horiz chroma weights should be same as for even pixel - trbarry 09/16/2002 */
+      hControl[i*3+3] = hControl[i*3+2]; /* chroma weights */
+    }
+  }
+  
+  hControl[newwidth*3+4] =  2 * (oldwidth-1); /* give it something to prefetch at end */
+  hControl[newwidth*3+5] =  2 * (oldwidth-1);
+  
+  /* Next set up vertical table. The offsets are measured in lines and will be mult */
+  /* by the source pitch later */
+  for(i=0; i< newheight; ++i) {
+    if (vWarp==1)                   /* if no warp factor */
+      j = i * 256 * (oldheight-1) / (newheight-1);
+    else                            /* stretch and warp somehow */
+      j = (int) (256 * WarpFactor(i / (newheight-1.0), vWarp) * (oldheight-1));
+
+    if (Interlaced) {           /* do hard way? */
+      if (i%2) {                  /* is odd output line? */
+	if (j < 256) {            /* before 1st odd input line */
+	  vOffsets[i] = 1;        /* all from line 1 */
+	  vWeights[i] = 0;        /* weight to give to 2nd line */
+	} else  {
+	  k = (((j-256) >> 9) << 1) + 1; /* next lowest odd line */
+	  vOffsets[i] = k;
+	  wY2 = j - (k << 8); 
+	  vWeights[i] = wY2 >> 1; /* weight to give to 2nd line */
+	}
+      } else {                    /* is even output line */
+	k = (j >> 9) << 1;        /* next lower even line */
+	vOffsets[i] = k;
+	wY2 = j - (k << 8); 
+	vWeights[i] = wY2 >> 1;   /* weight to give to 2nd line */
+      }
+    } else {                    /* simple way, do as progressive */
+      k = j >> 8;
+      vOffsets[i] = k;
+      wY2 = j - (k << 8);  
+      vWeights[i] = wY2;          /* weight to give to 2nd line */
+    }
+  }
+}
+
+/* Register allocation */
+/* index/counter registers (REGA, REGC) are loaded from 32bit vars/arrays ! */
+#define     REGEA "eax"
+#define     REGEB "ebx"
+#if defined(__x86_64__)
+#  define   REGA  "rax"
+#  define   REGB  "rbx"
+#  define   REGC  "ecx"
+#  define   REGD  "rdx"
+#  define   REGDI "rdi"
+#  define   REGSI "rsi"
+#elif defined(__i386__) 
+#  define   REGA  "eax"
+#  define   REGB  "ebx"
+#  define   REGC  "ecx"
+#  define   REGD  "edx"
+#  define   REGDI "edi"
+#  define   REGSI "esi"
+#endif
+
+/* variables accessed from assembler code */
+#define _FPround1       "%0"
+#define _vWeight1       "%1" 
+#define _vWeight2       "%2" 
+#define _YMask          "%3"
+#define _src_row_size   "%4"
+#define _EndOffset      "%5"
+#define _pControl       "%6"
+#define _row_size       "%7"
+#define _vWorkYW        "%8"
+#define _dstp           "%9"
+#define _vWorkUVW       "%10"
+#define _FPround2       "%11"
+#define _srcp1          "%12"
+#define _srcp2          "%13"
+#if !defined(__x86_64__)
+#define _oldbx          "%14"
+#define _SSEMMXenabledW "%15"
+#define _SSE2enabledW   "%16"
+#endif
+
+/* structure for mmx constants */
+typedef union {
+  uint64_t uq[1];  /* Unsigned Quadword */
+  uint32_t ud[2];  /* Unsigned Doubleword */
+} ATTR_ALIGN(16) mmx_t;
+
+/* structure for sse2 constants */
+typedef union {
+  uint64_t uq[2];  /* Unsigned Quadword */
+  uint32_t ud[4];  /* Unsigned Doubleword */
+} ATTR_ALIGN(16) sse2_t;
+
+
+static int do_warp_yuy2(uint8_t *dst, const uint8_t *src,
+			const int dst_pitch, const int src_pitch,
+			const int dst_width, const int dst_height,			 
+			const int src_width, const int src_height,
+			const int Interlaced, const uint32_t * const hControl, 
+			const uint32_t * const vOffsets, const uint32_t * const vWeights,
+			uint32_t *vWorkY, uint32_t *vWorkUV,
+			int dst_start)
+{
+#if defined(__i386__) || defined(__x86_64__)
+  const sse2_t YMask    = {uq:{UINT64_C(0x00ff00ff00ff00ff),UINT64_C(0x00ff00ff00ff00ff)}}; /* keeps only luma */
+  const sse2_t FPround1 = {uq:{UINT64_C(0x0080008000800080),UINT64_C(0x0080008000800080)}}; /* round words      */
+  const sse2_t FPround2 = {uq:{UINT64_C(0x0000008000000080),UINT64_C(0x0000008000000080)}}; /* round dwords     */
+  sse2_t vWeight1;
+  sse2_t vWeight2;
+
+  const uint32_t *pControl = &hControl[0];
+  const uint32_t *vWorkYW = vWorkY;
+  const uint32_t *vWorkUVW = vWorkUV;
+  const uint8_t *srcp = src;
+  const uint8_t *srcp1;
+  const uint8_t *srcp2;
+  uint8_t *dstp = dst + dst_pitch*dst_start;
+
+  const uint32_t src_row_size = src_width * 2;
+  const uint32_t row_size = dst_width * 2;
+  const uint32_t EndOffset = src_row_size / 2;
+
+#if !defined(__x86_64__)
+  const int accel = xine_mm_accel();
+  const uint32_t SSE2enabledW   = !!(accel & MM_ACCEL_X86_SSE2);   /* in local storage for asm */
+  const uint32_t SSEMMXenabledW = !!(accel & MM_ACCEL_X86_MMXEXT); /* in local storage for asm */
+  long int oldbx;
+#endif
+  int y;
+
+  for (y = dst_start; y < dst_height; y++) {
+
+    if(vOffsets[y] >= src_height) {
+      /* slice completed */
+      /*DBG("do_warp_yuy2: max input height reached: need line %d, height %d\n -> Returning next output line: %d\n",
+	vOffsets[y], src_height, y);*/
+      return y;
+    }
+
+    vWeight1.ud[0] = vWeight1.ud[1] = vWeight1.ud[2] = vWeight1.ud[3] = 
+      (256-vWeights[y]) << 16 | (256-vWeights[y]);
+    vWeight2.ud[0] = vWeight2.ud[1] = vWeight2.ud[2] = vWeight2.ud[3] = 
+      vWeights[y] << 16 | vWeights[y];
+
+    srcp1 = srcp + vOffsets[y] * src_pitch;
+    if (Interlaced)
+      srcp2 = (y < dst_height-2)  ?  srcp1 + 2 * src_pitch  :  srcp1;
+    else
+      srcp2 = (y < dst_height-1)  ?  srcp1 + src_pitch      :  srcp1;
+
+    __asm__ __volatile__ (
+#if !defined(__x86_64__)
+            /* store ebx (PIC) */
+            "mov %%"REGB", "_oldbx"          \n\t"
+#endif
+	    "movl   "_src_row_size", %%"REGC"  \n\t"
+	    "shrl   $3,          %%"REGC"      \n\t" /* 8 bytes a time             */
+	    "mov    "_srcp1",    %%"REGSI"     \n\t" /* top of 2 src lines to get  */
+	    "mov    "_srcp2",    %%"REGD"      \n\t" /* next "                     */
+	    "mov    "_vWorkYW",  %%"REGDI"     \n\t" /* luma work destination line */
+	    "mov    "_vWorkUVW", %%"REGB"      \n\t" /* luma work destination line */
+	    "xor    %%"REGA",    %%"REGA"      \n\t"
+#if !defined(__x86_64__)
+	    /* Let's check here to see if we are on a P4 or higher and can use SSE2 instructions.
+	     * This first loop is not the performance bottleneck anyway but it is trivial to tune
+	     * using SSE2 if we have proper alignment.
+	     */
+	    "testl  $1, "_SSE2enabledW"  \n\t"  /* is SSE2 supported?*/
+	    "jz     vMaybeSSEMMX         \n\t"  /* n, can't do anyway*/
+#endif
+	    "cmpl   $2, %%"REGC"         \n\t"  /* we have at least 16 bytes, 2 qwords? */
+	    "jl     vMaybeSSEMMX         \n\t"  /* n, don't bother*/
+	    
+	    "shrl   $1, %%"REGC"         \n\t"  /* do 16 bytes at a time instead*/
+	    "decl   %%"REGC"             \n"    /* jigger loop ct */
+	    
+	    ".align 16                   \n\t"
+
+	    "movdqa "_FPround1", %%xmm0  \n\t"
+	    "movdqa "_vWeight1", %%xmm5  \n\t"
+	    "movdqa "_vWeight2", %%xmm6  \n\t"
+	    "movdqa "_YMask",    %%xmm7  \n"
+
+	    "vLoopSSE2_Fetch:            \n\t"
+#ifdef PREFETCH
+	    "  prefetcht0 16(%%"REGSI", %%"REGA", 2) \n\t"
+	    "  prefetcht0 16(%%"REGD",  %%"REGA", 2) \n"
+#endif	    
+	    "vLoopSSE2:  \n\t"
+	    "  movdqu   (%%"REGSI", %%"REGA", 2), %%xmm1 \n\t" /* top of 2 lines to interpolate */
+	    "  movdqu   (%%"REGD",  %%"REGA", 2), %%xmm2 \n\t" /* 2nd of 2 lines */
+
+	    "  movdqa   %%xmm1, %%xmm3  \n\t"  /* get chroma  bytes  */
+	    "  pand     %%xmm7, %%xmm1  \n\t"  /* keep only luma     */
+	    "  psrlw        $8, %%xmm3  \n\t"  /* right just chroma  */
+	    "  pmullw   %%xmm5, %%xmm1  \n\t"  /* mult by weighting factor */
+	    "  pmullw   %%xmm5, %%xmm3  \n\t"  /* mult by weighting factor */
+
+	    "  movdqa   %%xmm2, %%xmm4  \n\t"  /* get chroma bytes  */
+	    "  pand     %%xmm7, %%xmm2  \n\t"  /* keep only luma    */
+	    "  psrlw        $8, %%xmm4  \n\t"  /* right just chroma */
+	    "  pmullw   %%xmm6, %%xmm2  \n\t"  /* mult by weighting factor */
+	    "  pmullw   %%xmm6, %%xmm4  \n\t"  /* mult by weighting factor */
+	    
+	    "  paddw    %%xmm2, %%xmm1  \n\t"  /* combine lumas     */
+	    "  paddusw  %%xmm0, %%xmm1  \n\t"  /* round             */
+	    "  psrlw        $8, %%xmm1  \n\t"  /* right adjust luma */
+#ifdef STREAMING_STORE
+	    "  movntdq  %%xmm1, (%%"REGDI", %%"REGA", 2) \n\t" /* save lumas in our work area */
+#else
+	    "  movdqu   %%xmm1, (%%"REGDI", %%"REGA", 2) \n\t" /* save lumas in our work area */
+#endif
+	    "  paddw    %%xmm4, %%xmm3  \n\t"  /* combine chromas */
+	    "  paddusw  %%xmm0, %%xmm3  \n\t"  /* round */
+	    "  psrlw        $8, %%xmm3  \n\t"  /* right adjust chroma */
+	    "  packuswb %%xmm3, %%xmm3  \n\t"  /* pack UV's into low dword */
+	    "  movdq2q  %%xmm3, %%mm1   \n\t"  /* save in our work area    */
+#ifdef STREAMING_STORE
+	    "  movntq    %%mm1, (%%"REGB", %%"REGA") \n\t"  /* save in our work area */
+#else
+	    "  movq      %%mm1, (%%"REGB", %%"REGA") \n\t"  /* save in our work area */
+#endif
+	    "  lea   8(%%"REGA"), %%"REGA"  \n\t"
+	    "  decl  %%"REGC"               \n\t"
+	    
+	    "  jg    vLoopSSE2_Fetch        \n\t"  /* if not on last one loop, prefetch */
+	    "  jz    vLoopSSE2              \n\t"  /* or just loop, or not */
+
+	    /* done with our SSE2 fortified loop but we may need to pick up the spare change */
+#ifdef STREAMING_STORE
+	    "  sfence    \n\t"
+#endif
+	    "  movl  "_src_row_size", %%"REGC" \n\t"  /* get count again   */
+	    "  andl  $15, %%"REGC"          \n\t"  /* just need mod 16  */
+
+	    "  movq  "_YMask",    %%mm7     \n\t"  /* useful luma mask constant - lazy dupl init */
+	    "  movq  "_vWeight1", %%mm5     \n\t"
+	    "  movq  "_vWeight2", %%mm6     \n\t"
+	    "  movq  "_FPround1", %%mm0     \n\t"  /* useful rounding constant  */
+
+	    "  shrl  $3, %%"REGC"    \n\t"  /* 8 bytes at a time, any?  */
+	    "  jz   MoreSpareChange  \n"    /* n, did them all  */
+
+	    /* Let's check here to see if we are on a P2 or Athlon and can use SSEMMX instructions.
+	     * This first loop is not the performance bottleneck anyway but it is trivial to tune
+	     * using SSE if we have proper alignment.
+	     */
+	    "vMaybeSSEMMX:    \n\t"
+
+	    "  movq  "_YMask",    %%mm7    \n\t"  /* useful luma mask constant - lazy dupl init */
+	    "  movq  "_vWeight1", %%mm5    \n\t"  
+	    "  movq  "_vWeight2", %%mm6    \n\t"  
+	    "  movq  "_FPround1", %%mm0    \n\t"  /* useful rounding constant  */
+#if !defined(__x86_64__)
+	    "  testl $1, "_SSEMMXenabledW" \n\t"  /* MMXEXTsupported? */
+	    "  jz    vLoopMMX              \n\t"  /* n, can't do anyway */
+#endif
+	    "  decl  %%"REGC"              \n"    /* jigger loop ctr */
+
+	    ".align 16           \n"
+	    "vLoopSSEMMX_Fetch:  \n\t"
+#ifdef PREFETCH
+	    "  prefetcht0 8(%%"REGSI", %%"REGA", 2)  \n\t"
+	    "  prefetcht0 8(%%"REGD",  %%"REGA", 2)  \n"
+#endif
+	    "vLoopSSEMMX:   \n\t"
+	    "  movq    (%%"REGSI", %%"REGA", 2), %%mm1  \n\t"   /* top of 2 lines to interpolate */
+	    "  movq    (%%"REGD",  %%"REGA", 2), %%mm2  \n\t"   /* 2nd of 2 lines    */
+
+	    "  movq    %%mm1, %%mm3  \n\t"   /* copy top bytes */
+	    "  pand    %%mm7, %%mm1  \n\t"   /* keep only luma */
+	    "  pxor    %%mm1, %%mm3  \n\t"   /* keep only chroma */
+	    "  psrlw      $8, %%mm3  \n\t"   /* right just chroma */
+	    "  pmullw  %%mm5, %%mm1  \n\t"   /* mult by weighting factor */
+	    "  pmullw  %%mm5, %%mm3  \n\t"   /* mult by weighting factor */
+			  
+	    "  movq    %%mm2, %%mm4  \n\t"   /* copy 2nd bytes */
+	    "  pand    %%mm7, %%mm2  \n\t"   /* keep only luma */
+	    "  pxor    %%mm2, %%mm4  \n\t"   /* keep only chroma */
+	    "  psrlw      $8, %%mm4  \n\t"   /* right just chroma */
+	    "  pmullw  %%mm6, %%mm2  \n\t"   /* mult by weighting factor */
+	    "  pmullw  %%mm6, %%mm4  \n\t"   /* mult by weighting factor */
+	    
+	    "  paddw   %%mm2, %%mm1  \n\t"   /* combine lumas     */
+	    "  paddusw %%mm0, %%mm1  \n\t"   /* round             */
+	    "  psrlw      $8, %%mm1  \n\t"   /* right adjust luma */
+#ifdef STREAMING_STORE
+	    "  movntq  %%mm1, (%%"REGDI", %%"REGA", 2) \n\t"  /* save lumas in our work area */
+#else
+	    "  movq    %%mm1, (%%"REGDI", %%"REGA", 2) \n\t"  /* save lumas in our work area */
+#endif	    
+	    "  paddw    %%mm4, %%mm3  \n\t"  /* combine chromas  */
+	    "  paddusw  %%mm0, %%mm3  \n\t"  /* round            */
+	    "  psrlw       $8, %%mm3  \n\t"  /* right adjust chroma  */
+	    "  packuswb %%mm3, %%mm3  \n\t"  /* pack UV's into low dword */
+	    "  movd     %%mm3, (%%"REGB", %%"REGA") \n\t"  /* save in our work area    */
+	    
+	    "  lea   4(%%"REGA"), %%"REGA" \n\t"
+	    "  decl  %%"REGC"              \n\t"
+	    "  jg    vLoopSSEMMX_Fetch     \n\t"  /* if not on last one loop, prefetch  */
+	    "  jz    vLoopSSEMMX           \n\t"  /* or just loop, or not  */
+#ifdef STREAMING_STORE
+	    "  sfence                      \n\t"
+#endif
+	    "  jmp    MoreSpareChange      \n"    /* all done with vertical  */
+	    
+	    ".align 16     \n"
+	    "vLoopMMX:     \n\t"
+
+	    "  movq (%%"REGSI", %%"REGA", 2), %%mm1  \n\t" /* top of 2 lines to interpolate */
+	    "  movq (%%"REGD",  %%"REGA", 2), %%mm2  \n\t" /* 2nd of 2 lines */
+
+	    "  movq     %%mm1, %%mm3  \n\t"  /* copy top bytes    */
+	    "  pand     %%mm7, %%mm1  \n\t"  /* keep only luma    */
+	    "  pxor     %%mm1, %%mm3  \n\t"  /* keep only chroma  */
+	    "  psrlw       $8, %%mm3  \n\t"  /* right just chroma */
+	    "  pmullw   %%mm5, %%mm1  \n\t"  /* mult by weighting factor */
+	    "  pmullw   %%mm5, %%mm3  \n\t"  /* mult by weighting factor */
+	    
+	    "  movq     %%mm2, %%mm4  \n\t"  /* copy 2nd bytes    */
+	    "  pand     %%mm7, %%mm2  \n\t"  /* keep only luma    */
+	    "  pxor     %%mm2, %%mm4  \n\t"  /* keep only chroma  */
+	    "  psrlw       $8, %%mm4  \n\t"  /* right just chroma */
+	    "  pmullw   %%mm6, %%mm2  \n\t"  /* mult by weighting factor */
+	    "  pmullw   %%mm6, %%mm4  \n\t"  /* mult by weighting factor */
+	    
+	    "  paddw    %%mm2, %%mm1  \n\t"  /* combine lumas     */
+	    "  paddusw  %%mm0, %%mm1  \n\t"  /* round             */
+	    "  psrlw       $8, %%mm1  \n\t"  /* right adjust luma */
+	    "  movq     %%mm1, (%%"REGDI", %%"REGA", 2) \n\t"  /* save lumas in our work area */
+	    
+	    "  paddw    %%mm4, %%mm3  \n\t"  /* combine chromas     */
+	    "  paddusw  %%mm0, %%mm3  \n\t"  /* round               */
+	    "  psrlw       $8, %%mm3  \n\t"  /* right adjust chroma */
+	    "  packuswb %%mm3, %%mm3  \n\t"  /* pack UV's into low dword */
+	    "  movd     %%mm3, (%%"REGB", %%"REGA")  \n\t"  /* save in our work area */
+
+	    "  lea      4(%%"REGA"), %%"REGA"  \n\t"
+	    "  loop     vLoopMMX       \n"
+
+	    /* Add a little code here to check if we have 2 more pixels to do and, if so, make one
+	     * more pass thru vLoopMMX. We were processing in multiples of 4 pixels and alway have
+	     * an even number so there will never be more than 2 left. trbarry 7/29/2002
+	     */
+	    "MoreSpareChange:      \n\t"
+
+	    "  cmpl  "_EndOffset", %%"REGEA"  \n\t"  /* did we get them all */
+	    "  jnl   DoHorizontal  \n\t"  /* yes, else have 2 left */
+	    "  movl  $1, %%"REGC"  \n\t"  /* jigger loop ct */
+	    "  sub   $2, %%"REGA"  \n\t"  /* back up 2 pixels (4 bytes, but eax carried as 1/2) */
+	    "  jmp   vLoopMMX      \n"
+
+	    /*  We've taken care of the vertical scaling, now do horizontal  */
+	    "DoHorizontal:        \n\t"
+
+	    "  movq  "_YMask",    %%mm7     \n\t"  /* useful 0U0U..  mask constant  */
+	    "  movq  "_FPround2", %%mm6     \n\t"  /* useful rounding constant, dwords  */
+	    "  mov   "_pControl", %%"REGSI" \n\t"  /* @ horiz control bytes  */	
+	    "  movl  "_row_size", %%"REGC"  \n\t"
+	    "  shrl  $2,          %%"REGC"  \n\t"  /* bytes a time, 2 pixels  */
+	    "  mov   "_vWorkYW",  %%"REGD"  \n\t"  /* our luma data, as 0Y0Y 0Y0Y..  */
+	    "  mov   "_dstp",     %%"REGDI" \n\t"  /* the destination line  */
+	    "  mov   "_vWorkUVW", %%"REGB"  \n"    /* chroma data, as UVUV UVUV...  */
+
+	    ".align 16  \n"
+	    "hLoopMMX:    \n\t"
+
+	    /* x86_64: must use movl (accessing table of uint32's) */
+	    "  movl      16(%%"REGSI"), %%"REGEA"        \n\t"  /* get data offset in pixels, 1st pixel pair */
+	    "  movd      (%%"REGD", %%"REGA", 2), %%mm0  \n\t"  /* copy luma pair */
+	    "  shr       $1, %%"REGA"                    \n\t"  /* div offset by 2 */
+	    "  movd      (%%"REGB", %%"REGA", 2), %%mm1  \n\t"  /* copy UV pair VUVU */
+	    "  psllw     $8, %%mm1                       \n\t"  /* shift out V, keep 0000U0U0 */
+	    
+	    /*  we need to use both even and odd croma from same location - trb 9/2002 */
+	    "  punpckldq (%%"REGB", %%"REGA", 2), %%mm1  \r\n"  /* copy UV pair VUVU  */
+	    "  psrlw     $8, %%mm1                       \r\n"  /* shift out U0, keep 0V0V 0U0U   */
+	    "  movl      20(%%"REGSI"), %%"REGEA"        \r\n"  /* get data offset in pixels, 2nd pixel pair  */
+	    "  punpckldq (%%"REGD", %%"REGA", 2), %%mm0  \r\n"  /* copy luma pair  */
+	    
+	    "  pmaddwd    (%%"REGSI"), %%mm0  \r\n"  /* mult and sum lumas by ctl weights  */
+	    "  paddusw    %%mm6, %%mm0        \r\n"  /* round  */
+	    "  psrlw      $8, %%mm0           \r\n"  /* right just 2 luma pixel value 000Y,000Y  */
+	    
+	    "  pmaddwd    8(%%"REGSI"), %%mm1 \r\n"  /* mult and sum chromas by ctl weights */
+	    "  paddusw    %%mm6, %%mm1        \r\n"  /* round */
+	    "  pslld      $8, %%mm1           \r\n"  /* shift into low bytes of different words */
+	    "  pand       %%mm7, %%mm1        \r\n"  /* keep only 2 chroma values 0V00,0U00  */
+	    "  por        %%mm1, %%mm0        \r\n"  /* combine luma and chroma, 0V0Y,0U0Y  */
+	    "  packuswb   %%mm0, %%mm0        \r\n"  /* pack all into low dword, xxxxVYUY  */
+	    "  movd       %%mm0, (%%"REGDI")  \n\t"  /* done with 2 pixels */
+
+	    "  lea     24(%%"REGSI"), %%"REGSI"  \n\t"  /* bump to next control bytest */
+	    "  lea      4(%%"REGDI"), %%"REGDI"  \n\t"  /* bump to next output pixel addr */
+	    
+	    "  loop   hLoopMMX             \n\t"  /* loop for more */
+
+	    "emms              \n\t"
+	    /* done with one line */
+
+#if !defined(__x86_64__)
+	    "mov "_oldbx", %%"REGB" \n\t"
+#endif
+	    ::
+	    "m" /*0*/(FPround1), 
+	    "m" /*1*/(vWeight1), 
+	    "m" /*2*/(vWeight2), 
+	    "m" /*3*/(YMask),
+	    "m" /*4*/(src_row_size),
+	    "m" /*5*/(EndOffset),
+	    "m" /*6*/(pControl),
+	    "m" /*7*/(row_size),
+	    "m" /*8*/(vWorkYW),
+	    "m" /*9*/(dstp),
+	    "m" /*10*/(vWorkUVW),
+	    "m" /*11*/(FPround2),
+	    "m" /*12*/(srcp1),
+	    "m" /*13*/(srcp2)
+#if !defined(__x86_64__)
+	    ,
+	    "m" /*14*/(oldbx),
+	    "m" /*15*/(SSEMMXenabledW),
+	    "m" /*16*/(SSE2enabledW)
+	    : REGA, /*REGB,*/ REGC, REGD, REGSI, REGDI
+#else
+	    : REGA, REGB, REGC, REGD, REGSI, REGDI
+#endif
+	    );
+
+    dstp += dst_pitch;
+  }
+#endif
+  return 0;
+}
+
+static int do_warp_yv12(uint8_t *dst, const uint8_t * const src,
+			const int dst_pitch, const int src_pitch,
+			const int dst_width, const int dst_height,			 
+			const int src_width, const int src_height,
+			const int Interlaced, const uint32_t * const hControl, 
+			const uint32_t * vOffsets, const uint32_t * vWeights,
+			uint32_t *vWorkY, int dst_start)
+{
+#if defined(__i386__) || defined(__x86_64__)
+  const sse2_t FPround1 = {uq:{UINT64_C(0x0080008000800080),UINT64_C(0x0080008000800080)}}; /* round words     */
+  const sse2_t FPround2 = {uq:{UINT64_C(0x0000008000000080),UINT64_C(0x0000008000000080)}}; /* round dwords    */
+  sse2_t vWeight1;
+  sse2_t vWeight2;
+
+  const uint32_t *pControl = &hControl[0];
+  const uint32_t *vWorkYW = vWorkY;
+  const uint8_t *srcp = src;
+  const uint8_t *srcp1;
+  const uint8_t *srcp2;
+  uint8_t *dstp = dst + dst_pitch*dst_start;
+
+  const uint32_t src_row_size = src_width;
+  const uint32_t row_size = dst_width;
+
+#if !defined(__x86_64__)
+  const int accel = xine_mm_accel();
+  const uint32_t SSE2enabledW   = !!(accel & MM_ACCEL_X86_SSE2);   /* in local storage for asm */
+  const uint32_t SSEMMXenabledW = !!(accel & MM_ACCEL_X86_MMXEXT); /* in local storage for asm */
+  long int oldbx;
+#endif
+  int y;
+
+  /* Operation in sliced mode:
+   *  - continue until required next source line is out of slice
+   *  - return next output line
+   *  - at next call, continue from next souce line
+   */
+
+  for (y = dst_start; y < dst_height; y++) {
+    if(vOffsets[y] >= src_height) {
+      /* slice completed */
+      /*DBG("do_warp_yv12: max input height reached: need line %d, height %d\n -> Returning next output line: %d , start was %d\n",
+	(int)vOffsets[y], (int)src_height, (int)y, (int)dst_start);*/
+      return y;
+    }
+
+    vWeight1.ud[0] = vWeight1.ud[1] = vWeight1.ud[2] = vWeight1.ud[3] =
+      (256-vWeights[y]) << 16 | (256-vWeights[y]);
+    vWeight2.ud[0] = vWeight2.ud[1] = vWeight2.ud[2] = vWeight2.ud[3] =
+      vWeights[y] << 16 | vWeights[y];
+
+    srcp1 = srcp + vOffsets[y] * src_pitch;
+
+    if (Interlaced)
+      srcp2 = (y < dst_height-2)  ?  srcp1 + 2 * src_pitch  :  srcp1;
+    else
+      srcp2 = (y < dst_height-1)  ?  srcp1 + src_pitch  :  srcp1;
+
+    __asm__  __volatile__(
+             "movl "_src_row_size", %%"REGC" \n\t"
+	     "shr  $3,         %%"REGC"   \n\t"  /* 8 bytes a time */
+	     "mov  "_srcp1",   %%"REGSI"  \n\t"  /* top of 2 src lines to get */
+	     "mov  "_srcp2",   %%"REGD"   \n\t"  /* next "  */ 
+	     "mov  "_vWorkYW", %%"REGDI"  \n\t"  /* luma work destination line */
+	     "xor  %%"REGA",   %%"REGA"   \n\t"
+#if !defined(__x86_64__)
+	     /* Let's check here to see if we are on a P4 or higher and can use SSE2 instructions.
+	      * This first loop is not the performance bottleneck anyway but it is trivial to tune
+	      * using SSE2 if we have proper alignment.
+	      */
+	     "testl $1, "_SSE2enabledW"   \n\t"  /* is SSE2 supported? */
+	     "jz    vMaybeSSEMMX_12       \n\t"  /* n, can't do anyway */
+#endif
+	     "cmpl  $2, %%"REGC"          \n\t"  /* we have at least 16 byts, 2 qwords? */
+	     "jl    vMaybeSSEMMX_12       \n\t"  /* n, don't bother */
+	     
+	     "mov   %%"REGSI", %%"REGB"   \n\t"
+	     "or    %%"REGD",  %%"REGB"   \n\t"
+	     "test  $15,       %%"REGB"   \n\t"  /* both src rows 16 byte aligned? */
+	     "jnz   vMaybeSSEMMX_12       \n\t"  /* n, don't use sse2 */
+			 
+	     "shr   $1, %%"REGC"          \n\t"  /* do 16 bytes at a time instead */
+	     "dec   %%"REGC"              \n\t"  /* jigger loop ct */
+			 
+	     "movdqa "_FPround1", %%xmm0  \n\t"
+	     "movdqa "_vWeight1", %%xmm5  \n\t"
+	     "movdqa "_vWeight2", %%xmm6  \n\t"
+	     "pxor        %%xmm7, %%xmm7  \n"
+
+	     ".align 16                   \n"
+	     "vLoopSSE2_Fetch_12:         \n\t"
+#ifdef PREFETCH
+	     "  prefetcht0 16(%%"REGSI", %%"REGA", 2) \n\t"
+	     "  prefetcht0 16(%%"REGD",  %%"REGA", 2) \n"
+#endif
+	     "vLoopSSE2_12:  \n\t"
+	     /* we're already checked pointers to be on dqword aligned */
+	     "  movdqa  (%%"REGSI", %%"REGA"), %%xmm1 \n\t" /* top of 2 lines to interpolate */
+	     "  movdqa  (%%"REGD",  %%"REGA"), %%xmm3 \n\t" /* 2nd of 2 lines */
+	     "  movdqa    %%xmm1, %%xmm2  \n\t"
+	     "  movdqa    %%xmm3, %%xmm4  \n\t"
+
+	     "  punpcklbw %%xmm7, %%xmm1  \n\t"  /* make words */
+	     "  punpckhbw %%xmm7, %%xmm2  \n\t"  /*     "     */
+	     "  punpcklbw %%xmm7, %%xmm3  \n\t"  /*     "     */
+	     "  punpckhbw %%xmm7, %%xmm4  \n\t"  /*     "     */
+
+	     "  pmullw    %%xmm5, %%xmm1  \n\t"  /* mult by top weighting factor */
+	     "  pmullw    %%xmm5, %%xmm2  \n\t"  /*    "    */
+	     "  pmullw    %%xmm6, %%xmm3  \n\t"  /* mult by bot weighting factor */
+	     "  pmullw    %%xmm6, %%xmm4  \n\t"  /*    "    */
+
+	     "  paddw     %%xmm3, %%xmm1  \n\t"  /* combine lumas low */
+	     "  paddw     %%xmm4, %%xmm2  \n\t"  /* combine lumas high */
+
+	     "  paddusw   %%xmm0, %%xmm1  \n\t"  /* round */
+	     "  paddusw   %%xmm0, %%xmm2  \n\t"  /* round */
+			
+	     "  psrlw     $8, %%xmm1      \n\t"  /* right adjust luma */
+	     "  psrlw     $8, %%xmm2      \n\t"  /* right adjust luma */
+
+	     "  packuswb  %%xmm2, %%xmm1  \n\t"  /* pack words to our 16 byte answer */
+#ifdef STREAMING_STORE
+	     "  movntdq   %%xmm1, (%%"REGDI", %%"REGA") \n\t" /* save lumas in our work area */
+#else
+	     "  movdqu    %%xmm1, (%%"REGDI", %%"REGA") \n\t" /* save lumas in our work area */
+#endif			 
+	     "  lea   16(%%"REGA"), %%"REGA" \n\t"
+	     "  decl  %%"REGC"            \n\t"
+
+	     "  jg    vLoopSSE2_Fetch_12  \n\t"  /* if not on last one loop, prefetch  */
+	     "  jz    vLoopSSE2_12        \n\t"  /* or just loop, or not  */
+
+	     /* done with our SSE2 fortified loop but we may need to pick up the spare change */
+#ifdef STREAMING_STORE
+	     "  sfence                  \n\t"
+#endif
+	     "  movl  "_src_row_size", %%"REGC" \n\t"  /* get count again   */
+	     "  andl  $15, %%"REGC"       \n\t"  /* just need mod 16  */
+	     "  movq "_vWeight1", %%mm5   \n\t"
+	     "  movq "_vWeight2", %%mm6   \n\t"
+	     "  movq "_FPround1", %%mm0   \n\t"  /* useful rounding constant  */
+
+	     "  shrl  $3, %%"REGC"        \n\t"  /* 8 bytes at a time, any?  */
+	     "  jz   MoreSpareChange_12   \n"    /* n, did them all  */
+
+	     /* Let's check here to see if we are on a P2 or Athlon and can use SSEMMX instructions.
+	      * This first loop is not the performance bottleneck anyway but it is trivial to tune
+	      * using SSE if we have proper alignment.
+	      */
+	     "vMaybeSSEMMX_12:            \n\t"
+
+	     "  movq "_vWeight1", %%mm5   \n\t"  
+	     "  movq "_vWeight2", %%mm6   \n\t"  
+	     "  movq "_FPround1", %%mm0   \n\t"  /* useful rounding constant  */
+	     "  pxor       %%mm7, %%mm7   \n\t"
+#if !defined(__x86_64__)
+	     "  testl $1, "_SSEMMXenabledW" \n\t"/* MMXEXTsupported? */
+	     "  jz    vLoopMMX_12         \n\t"  /* n, can't do anyway */
+#endif
+	     "  decl  %%"REGC"      \n"  /* jigger loop ctr */
+			 
+	     ".align 16             \n"
+	     "vLoopSSEMMX_Fetch_12: \n\t"
+#ifdef PREFETCH
+	     "  prefetcht0 8(%%"REGSI", %%"REGA")  \n\t"
+	     "  prefetcht0 8(%%"REGD",  %%"REGA")  \n"
+#endif
+	     "vLoopSSEMMX_12:   \n\t"
+
+	     "  movq    (%%"REGSI", %%"REGA"), %%mm1  \n\t"   /* top of 2 lines to interpolate */
+	     "  movq    (%%"REGD",  %%"REGA"), %%mm3  \n\t"   /* 2nd of 2 lines    */
+
+	     "  movq      %%mm1, %%mm2  \n\t"
+	     "  movq      %%mm3, %%mm4  \n\t"
+
+	     "  punpcklbw %%mm7, %%mm1  \n\t"  /* make words */
+	     "  punpckhbw %%mm7, %%mm2  \n\t"  /*     "     */
+	     "  punpcklbw %%mm7, %%mm3  \n\t"  /*     "     */
+	     "  punpckhbw %%mm7, %%mm4  \n\t"  /*     "     */
+
+	     "  pmullw    %%mm5, %%mm1  \n\t"  /* mult by top weighting factor */
+	     "  pmullw    %%mm5, %%mm2  \n\t"  /*    "    */
+	     "  pmullw    %%mm6, %%mm3  \n\t"  /* mult by bot weighting factor */
+	     "  pmullw    %%mm6, %%mm4  \n\t"  /*    "    */
+
+	     "  paddw     %%mm3, %%mm1  \n\t"  /* combine lumas low */
+	     "  paddw     %%mm4, %%mm2  \n\t"  /* combine lumas high */
+
+	     "  paddusw   %%mm0, %%mm1  \n\t"  /* round */
+	     "  paddusw   %%mm0, %%mm2  \n\t"  /* round */
+			
+	     "  psrlw     $8, %%mm1     \n\t"  /* right adjust luma */
+	     "  psrlw     $8, %%mm2     \n\t"  /* right adjust luma */
+
+	     "  packuswb  %%mm2, %%mm1  \n\t"  /* pack words to our 16 byte answer */
+#ifdef STREAMING_STORE
+	     "  movntq    %%mm1, (%%"REGDI", %%"REGA") \n\t" /* save lumas in our work area */
+#else
+	     "  movq      %%mm1, (%%"REGDI", %%"REGA") \n\t" /* save lumas in our work area */
+#endif
+	     "  lea   8(%%"REGA"), %%"REGA" \n\t"
+	     "  decl  %%"REGC"              \n\t"
+
+	     "  jg    vLoopSSEMMX_Fetch_12  \n\t"  /* if not on last one loop, prefetch  */
+	     "  jz    vLoopSSEMMX_12        \n\t"  /* or just loop, or not  */
+#ifdef STREAMING_STORE
+	     "  sfence                      \n\t"
+#endif
+	     "  jmp    MoreSpareChange_12   \n"    /* all done with vertical  */
+
+	     ".align 16        \n"
+	     "vLoopMMX_12:     \n\t"
+
+	     "  movq    (%%"REGSI", %%"REGA"), %%mm1  \n\t"  /* top of 2 lines to interpolate */
+	     "  movq    (%%"REGD",  %%"REGA"), %%mm3  \n\t"  /* 2nd of 2 lines    */
+
+	     "  movq      %%mm1, %%mm2  \n\t"
+	     "  movq      %%mm3, %%mm4  \n\t"
+
+	     "  punpcklbw %%mm7, %%mm1  \n\t"  /* make words */
+	     "  punpckhbw %%mm7, %%mm2  \n\t"  /*     "     */
+	     "  punpcklbw %%mm7, %%mm3  \n\t"  /*     "     */
+	     "  punpckhbw %%mm7, %%mm4  \n\t"  /*     "     */
+	     
+	     "  pmullw    %%mm5, %%mm1  \n\t"  /* mult by top weighting factor */
+	     "  pmullw    %%mm5, %%mm2  \n\t"  /*    "    */
+	     "  pmullw    %%mm6, %%mm3  \n\t"  /* mult by bot weighting factor */
+	     "  pmullw    %%mm6, %%mm4  \n\t"  /*    "    */
+
+	     "  paddw     %%mm3, %%mm1  \n\t"  /* combine lumas low */
+	     "  paddw     %%mm4, %%mm2  \n\t"  /* combine lumas high */
+
+	     "  paddusw   %%mm0, %%mm1  \n\t"  /* round */
+	     "  paddusw   %%mm0, %%mm2  \n\t"  /* round */
+			
+	     "  psrlw     $8, %%mm1     \n\t"  /* right adjust luma */
+	     "  psrlw     $8, %%mm2     \n\t"  /* right adjust luma */
+
+	     "  packuswb  %%mm2, %%mm1  \n\t"  /* pack words to our 16 byte answer */
+	     "  movq      %%xmm1, (%%"REGDI", %%"REGA") \n\t" /* save lumas in our work area */
+			 
+	     "  lea   8(%%"REGA"), %%"REGA" \n\t"
+	     "  loop  vLoopMMX_12  \n"
+
+	     /* Add a little code here to check if we have more pixels to do and, if so, make one
+	      * more pass thru vLoopMMX. We were processing in multiples of 8 pixels and alway have
+	      * an even number so there will never be more than 7 left.
+	      */
+	     "MoreSpareChange_12:    \n\t"
+
+	     "  cmpl "_src_row_size", %%"REGEA"  \n\t"  /* did we get them all */
+	     "  jnl  DoHorizontal_12  \n\t"  /* yes, else have 2 left */
+	     "  movl $1, %%"REGC"     \n\t"  /* jigger loop ct */
+	     "  movl "_src_row_size", %%"REGEA"  \n\t"
+	     "  sub  $8, %%"REGA"     \n\t"  /* back up to last 8 pixels */
+	     "  jmp  vLoopMMX_12      \n"
+
+	     /*  We've taken care of the vertical scaling, now do horizontal  */
+	     "DoHorizontal_12:        \n\t"
+	     "  pxor        %%mm7, %%mm7     \n\t"
+	     "  movq  "_FPround2", %%mm6     \n\t"  /* useful rounding constant, dwords  */
+	     "  mov   "_pControl", %%"REGSI" \n\t"  /* @ horiz control bytes  */	
+	     "  movl  "_row_size", %%"REGC"  \n\t"
+	     "  shrl  $2, %%"REGC"          \n\t"  /* 4 bytes a time, 4 pixels  */
+	     "  mov   "_vWorkYW",  %%"REGD"  \n\t"  /* our luma data, as 0Y0Y 0Y0Y..  */
+	     "  mov   "_dstp",     %%"REGDI" \n\t"  /* the destination line  */
+#if !defined(__x86_64__)
+	     "  testl $1, "_SSEMMXenabledW" \n\t"  /* MMXEXTsupported? */
+	     "  jz    hLoopMMX_12           \n\t"  /* n, can't do anyway */
+#endif
+	     /* With SSE support we will make 8 pixels (from 8 pairs) at a time */
+	     "  shrl  $1, %%"REGC"  \n\t"  /* 8 bytes a time instead of 4  */
+	     "  jz    LessThan8     \n"
+
+	     ".align 16          \n"
+	     "hLoopMMXSSE_12:    \n\t"
+
+
+	     /* handle first 2 pixels */
+	     /* phi: must use movl here (x86_64, reading from table of uint_32's) */
+	     "  movl   16(%%"REGSI"), %%"REGEA"  \n\t"  /* get data offset in pixels, 1st pixel pair */
+	     "  movl   20(%%"REGSI"), %%"REGEB"  \r\n"  /* get data offset in pixels, 2nd pixel pair  */
+
+	     "  movd      (%%"REGD", %%"REGA"), %%mm0  \n\t"  /* copy luma pair 0000xxYY */
+	     "  punpcklwd (%%"REGD", %%"REGB"), %%mm0  \r\n"  /* 2nd luma pair, now xxxxYYYY  */
+	     "  punpcklbw %%mm7, %%mm0      \n\t"  /* make words out of bytes, 0Y0Y0Y0Y */
+	     "  movl      16+24(%%"REGSI"), %%"REGEA"  \n\t"  /* get data offset in pixels, 3st pixel pair */
+	     "  movl      20+24(%%"REGSI"), %%"REGEB"  \r\n"  /* get data offset in pixels, 4nd pixel pair  */
+	     "  pmaddwd   (%%"REGSI"), %%mm0  \n\t"  /* mult and sum lumas by ctl weights */
+	     "  paddusw    %%mm6, %%mm0       \n\t"  /* round */
+	     "  psrlw         $8, %%mm0       \n\t"  /* right just 4 luma pixel value 0Y0Y0Y0Y */
+
+	     /* handle 3rd and 4th pixel pairs */
+	     "  movd      (%%"REGD", %%"REGA"), %%mm1  \n\t"  /* copy luma pair 0000xxYY */
+	     "  punpcklwd (%%"REGD", %%"REGB"), %%mm1  \r\n"  /* 2nd luma pair, now xxxxYYYY  */
+	     "  punpcklbw %%mm7, %%mm1        \n\t"  /* make words out of bytes, 0Y0Y0Y0Y */
+	     "  movl      16+48(%%"REGSI"), %%"REGEA"  \n\t"  /* get data offset in pixels, 5st pixel pair */
+	     "  movl      20+48(%%"REGSI"), %%"REGEB"  \r\n"  /* get data offset in pixels, 6nd pixel pair  */
+	     "  pmaddwd 24(%%"REGSI"), %%mm1  \n\t"  /* mult and sum lumas by ctl weights */
+	     "  paddusw    %%mm6, %%mm1       \n\t"  /* round */
+	     "  psrlw         $8, %%mm1       \n\t"  /* right just 4 luma pixel value 0Y0Y0Y0Y */
+
+	     /* handle 5th and 6th pixel pairs */
+	     "  movd      (%%"REGD", %%"REGA"), %%mm2  \n\t"  /* copy luma pair 0000xxYY */
+	     "  punpcklwd (%%"REGD", %%"REGB"), %%mm2  \r\n"  /* 2nd luma pair, now xxxxYYYY  */
+	     "  punpcklbw %%mm7, %%mm2        \n\t"  /* make words out of bytes, 0Y0Y0Y0Y */
+	     "  movl      16+72(%%"REGSI"), %%"REGEA"  \n\t"  /* get data offset in pixels, 7st pixel pair */
+	     "  movl      20+72(%%"REGSI"), %%"REGEB"  \r\n"  /* get data offset in pixels, 8nd pixel pair  */
+	     "  pmaddwd 48(%%"REGSI"), %%mm2  \n\t"  /* mult and sum lumas by ctl weights */
+	     "  paddusw    %%mm6, %%mm2       \n\t"  /* round */
+	     "  psrlw         $8, %%mm2       \n\t"  /* right just 4 luma pixel value 0Y0Y0Y0Y */
+
+	     /* handle 7th and 8th pixel pairs */
+	     "  movd      (%%"REGD", %%"REGA"), %%mm3  \n\t"  /* copy luma pair 0000xxYY */
+	     "  punpcklwd (%%"REGD", %%"REGB"), %%mm3  \r\n"  /* 2nd luma pair, now xxxxYYYY  */
+	     "  punpcklbw %%mm7, %%mm3        \n\t"  /* make words out of bytes, 0Y0Y0Y0Y */
+	     "  pmaddwd 72(%%"REGSI"), %%mm3  \n\t"  /* mult and sum lumas by ctl weights */
+	     "  paddusw    %%mm6, %%mm3       \n\t"  /* round */
+	     "  psrlw         $8, %%mm3       \n\t"  /* right just 4 luma pixel value 0Y0Y0Y0Y */
+
+	     /* combine, store, and loop */
+	     "  packuswb %%mm1, %%mm0         \n\t"  /* pack into qword, 0Y0Y0Y0Y */
+	     "  packuswb %%mm3, %%mm2         \n\t"  /* pack into qword, 0Y0Y0Y0Y */
+	     "  packuswb %%mm2, %%mm0         \n\t"  /* and again into  YYYYYYYY */			
+#ifdef STREAMING_STORE
+	     "  movntq   %%mm0, (%%"REGDI")   \n\t"  /* done with 4 pixels */
+#else
+	     "  movq     %%mm0, (%%"REGDI")   \n\t"  /* done with 4 pixels */
+#endif
+
+	     "  lea  96(%%"REGSI"), %%"REGSI" \n\t"
+	     "  lea   8(%%"REGDI"), %%"REGDI" \n\t"
+	     "  decl  %%"REGC"                \n\t"
+	     "  jg    hLoopMMXSSE_12    \n\t"   /* loop for more  */
+#ifdef STREAMING_STORE
+	     "  sfence                  \n"
+#endif
+	     "LessThan8:    \n\t"
+	     "  movl "_row_size", %%"REGC"  \n\t"
+	     "  andl          $7, %%"REGC"  \n\t"  /* we have done all but maybe this */
+	     "  shrl          $2, %%"REGC"  \n\t"  /* now do only 4 bytes at a time */
+	     "  jz            LessThan4     \n"
+
+	     ".align 16   \n"
+	     "hLoopMMX_12:    \n\t"
+
+	     /* handle first 2 pixels */
+	     "  movl   16(%%"REGSI"), %%"REGEA"  \n\t"  /* get data offset in pixels, 1st pixel pair */
+	     "  movl   20(%%"REGSI"), %%"REGEB"  \r\n"  /* get data offset in pixels, 2nd pixel pair  */
+	     "  movd      (%%"REGD", %%"REGA"), %%mm0  \n\t"  /* copy luma pair 0000xxYY */
+	     "  punpcklwd (%%"REGD", %%"REGB"), %%mm0  \r\n"  /* 2nd luma pair, now xxxxYYYY  */
+	     "  punpcklbw %%mm7, %%mm0      \n\t"  /* make words out of bytes, 0Y0Y0Y0Y */
+	     "  movl      16+24(%%"REGSI"), %%"REGEA"  \n\t"  /* get data offset in pixels, 3st pixel pair */
+	     "  movl      20+24(%%"REGSI"), %%"REGEB"  \r\n"  /* get data offset in pixels, 4nd pixel pair  */
+	     "  pmaddwd   (%%"REGSI"), %%mm0  \n\t"  /* mult and sum lumas by ctl weights */
+	     "  paddusw    %%mm6, %%mm0       \n\t"  /* round */
+	     "  psrlw         $8, %%mm0       \n\t"  /* right just 4 luma pixel value 0Y0Y0Y0Y */
+
+	     /* handle 3rd and 4th pixel pairs */
+	     "  movd      (%%"REGD", %%"REGA"), %%mm1  \n\t"  /* copy luma pair 0000xxYY */
+	     "  punpckldq (%%"REGD", %%"REGB"), %%mm1  \r\n"  /* 2nd luma pair, now xxxxYYYY  */
+	     "  punpcklbw %%mm7, %%mm1        \n\t"  /* make words out of bytes, 0Y0Y0Y0Y */
+	     "  pmaddwd 24(%%"REGSI"), %%mm1  \n\t"  /* mult and sum lumas by ctl weights */
+	     "  paddusw    %%mm6, %%mm1       \n\t"  /* round */
+	     "  psrlw         $8, %%mm1       \n\t"  /* right just 4 luma pixel value 0Y0Y0Y0Y */
+
+	     /* combine, store, and loop */
+	     "  packuswb %%mm1, %%mm0         \n\t"  /* pack into qword, 0Y0Y0Y0Y */
+	     "  packuswb %%mm7, %%mm0         \n\t"  /* and again into  0000YYYY */			
+	     "  movd     %%mm0, (%%"REGDI")   \n\t"  /* done with 4 pixels */
+	     "  lea  48(%%"REGSI"), %%"REGSI" \n\t"
+	     "  lea   4(%%"REGDI"), %%"REGDI" \n\t"
+
+	     "  loop   hLoopMMX_12            \n"    /* loop for more */
+		 
+	     /* test to see if we have a mod 4 size row, if not then more spare change */
+	     "LessThan4:    \n\t"
+	     "  movl "_row_size", %%"REGC"    \n\t"
+	     "  andl          $3, %%"REGC"    \n\t"  /* remainder side mod 4 */
+	     "  cmpl          $2, %%"REGC"    \n\t"  
+	     "  jl            LastOne         \n\t"  /* none, none */
+
+	     /* handle 2 more pixels */
+	     "  movl      16(%%"REGSI"), %%"REGEA"  \n\t"  /* get data offset in pixels, 1st pixel pair */
+	     "  movl      20(%%"REGSI"), %%"REGEB"  \r\n"  /* get data offset in pixels, 2nd pixel pair  */
+	     "  movd      (%%"REGD", %%"REGA"), %%mm0  \n\t"  /* copy luma pair 0000xxYY */
+	     "  punpcklwd (%%"REGD", %%"REGB"), %%mm0  \r\n"  /* 2nd luma pair, now xxxxYYYY  */
+	     "  punpcklbw %%mm7, %%mm0        \n\t"  /* make words out of bytes, 0Y0Y0Y0Y */
+
+	     "  pmaddwd   (%%"REGSI"), %%mm0  \n\t"  /* mult and sum lumas by ctl weights */
+	     "  paddusw   %%mm6, %%mm0        \n\t"  /* round */
+	     "  psrlw        $8, %%mm0        \n\t"  /* right just 4 luma pixel value 0Y0Y0Y0Y */
+	     "  packuswb  %%mm7, %%mm0        \n\t"  /* pack into qword, 00000Y0Y */
+	     "  packuswb  %%mm7, %%mm0        \n\t"  /* and again into  000000YY */			
+	     "  movd      %%mm0, (%%"REGDI")  \n\t"  /* store, we are guarrenteed room in buffer (8 byte mult) */
+	     "  subl         $2, %%"REGC"     \n\t"  
+	     
+	     "  lea  24(%%"REGSI"), %%"REGSI" \n\t" /* bump to next control bytes */
+	     "  lea   2(%%"REGDI"), %%"REGDI" \n" /* bump to next output pixel addr */
+
+	     /* maybe one last pixel */
+	     "LastOne:    \n\t"
+	     "  cmpl   $0, %%"REGC"   \r\n"  /* still more ? */
+	     "  jz     AllDone        \r\n"  /* n, done */
+	     "  movl   16(%%"REGSI"), %%"REGEA"     \n\t"  /* get data offset in pixels, 1st pixel pair */
+	     "  movd   (%%"REGD", %%"REGA"), %%mm0  \n\t"  /* copy luma pair 0000xxYY */
+	     "  punpcklbw %%mm7, %%mm0        \n\t"  /* make words out of bytes, 0Y0Y0Y0Y */
+
+	     "  pmaddwd   (%%"REGSI"), %%mm0  \n\t"  /* mult and sum lumas by ctl weights */
+	     "  paddusw    %%mm6, %%mm0       \n\t"  /* round */
+	     "  psrlw         $8, %%mm0       \n\t"  /* right just 4 luma pixel value 0Y0Y0Y0Y */
+	     "  movd       %%mm0, %%"REGEA"   \n\t"
+	     "  movb        %%al, (%%"REGDI") \n"    /* store last one */
+			 
+	     "AllDone:  \n\t"
+	     "  emms    \n\t"
+#if !defined(__x86_64__)
+	     "mov "_oldbx", %%"REGB" \n\t"
+#endif
+	     ::
+	     "m" /*0*/(FPround1),
+	     "m" /*1*/(vWeight1),
+	     "m" /*2*/(vWeight2),
+	     "m" /*3*/(y/*YMask[0]*/),
+	     "m" /*4*/(src_row_size),
+	     "m" /*5*/(y/*EndOffset*/),
+	     "m" /*6*/(pControl),
+	     "m" /*7*/(row_size),
+	     "m" /*8*/(vWorkYW),
+	     "m" /*9*/(dstp),
+	     "m" /*10*/(y/*vWorkUVW*/),
+	     "m" /*11*/(FPround2),
+	     "m" /*12*/(srcp1),
+	     "m" /*13*/(srcp2)
+#if !defined(__x86_64__)
+	     ,
+	     "m" /*14*/(oldbx),
+	     "m" /*15*/(SSEMMXenabledW),
+	     "m" /*16*/(SSE2enabledW)
+	     : REGA, /*REGB,*/ REGC, REGD, REGSI, REGDI
+#else
+	     : REGA, REGB, REGC, REGD, REGSI, REGDI
+#endif
+	     );
+
+    dstp += dst_pitch;
+  }
+#endif
+  return 0; 
+}
+
+/*
+ * tools
+ */
+
+#ifndef ALIGN
+#  define ALIGN(b,p) ((void*)((((unsigned long)(p)) + (b)-1) & (~((b)-1))))
+#endif
+#ifndef MIN
+#  define MIN(a,b) ((a) < (b) ? (a) : (b))
+#endif
+#ifndef MAX
+#  define MAX(a,b) ((a) > (b) ? (a) : (b))
+#endif
+#ifndef FABS
+#  define FABS(x) ((x) < 0.0 ? -(x) : (x))
+#endif
+
+/*
+ * xine plugin
+ */
+
+#define PLUGIN_ID     "warp"
+#define PLUGIN_DESCR  "(non-)linear software scaling post plugin";
+#define PLUGIN_T      warp_plugin_t
+/*#define POST_THREADS*/
+/*#define POST_SLICES*/
+#include "xine/post_util.h"
+
+
+/* plugin class initialization function */
+void *warp_init_plugin(xine_t *xine, void *);
+
+/* plugin class functions */
+static post_plugin_t *open_plugin(post_class_t *class_gen, int inputs,
+				  xine_audio_port_t **audio_target,
+				  xine_video_port_t **video_target);
+
+/* plugin instance functions */
+static void        warp_dispose(post_plugin_t *this_gen);
+
+/* vo_frame functions */
+static vo_frame_t *got_frame(vo_frame_t *frame);
+static void        draw_internal(vo_frame_t *frame, vo_frame_t *new_frame);
+
+
+/* parameter functions */
+static xine_post_api_descr_t *warp_get_param_descr(void);
+static int                    warp_set_parameters(xine_post_t *this_gen, void *param_gen);
+static int                    warp_get_parameters(xine_post_t *this_gen, void *param_gen);
+static char                  *warp_get_help(void);
+
+
+typedef struct warp_parameters_s {
+  int    output_width;
+  int    output_height;
+  double output_aspect;
+  int    no_downscaling;
+} warp_parameters_t;
+
+START_PARAM_DESCR(warp_parameters_t)
+PARAM_ITEM(POST_PARAM_TYPE_INT,    output_width,  NULL, 640, 1920, 0,
+  "output video width")
+PARAM_ITEM(POST_PARAM_TYPE_INT,    output_height, NULL, 480, 1080, 0,
+  "output video height")
+PARAM_ITEM(POST_PARAM_TYPE_DOUBLE, output_aspect, NULL,   1,    3, 0,
+  "output video aspect ratio")
+PARAM_ITEM(POST_PARAM_TYPE_BOOL,   no_downscaling,NULL,   0,    1, 0,
+  "disable downscaling")
+END_PARAM_DESCR(warp_param_descr)
+
+
+typedef struct {
+  post_plugin_t  post;
+
+  xine_post_in_t parameter_input;
+
+  /* User config  (changes to actual config are delayed) */
+  warp_parameters_t config;
+
+  /* Current config */
+  int    enable;
+  int    output_width;
+  int    output_height;
+  double output_aspect;
+  double factor_x;
+  double factor_y;
+
+  /* Last seen input frame */
+  int    input_width;
+  int    input_height;
+  int    input_format;
+  int    input_interlaced;
+  double input_aspect;
+
+  /* working buffers */
+  uint32_t *vWorkY;
+  uint32_t *vWorkUV;
+
+  /* scaling tables */
+  uint32_t *hControl;
+  uint32_t *hControlUV;
+  uint32_t *vOffsets;
+  uint32_t *vOffsetsUV;
+  uint32_t *vWeights;
+  uint32_t *vWeightsUV;
+
+  /* memory for work areas and scaling tables */
+  void *pMem;
+
+} warp_plugin_t;
+
+/*
+ *
+ */
+
+static void init_tables(warp_plugin_t *this)
+{
+#define BP(x) ((uint8_t*)(x))
+  /* allocate memory for scaling tables and workspace */
+  free(this->pMem);
+  this->pMem = xine_xmalloc(this->input_width*3 + this->output_width*sizeof(uint32_t)*3*2 +
+			    this->output_height*sizeof(uint32_t)*4 + 2*9*128);
+
+  /* - aligned for P4 cache line */
+  this->vWorkY   = (uint32_t*)ALIGN(128, this->pMem);
+  this->vWorkUV  = (uint32_t*)ALIGN(128, BP(this->vWorkY)   + this->input_width*2 + 128);
+  this->hControl = (uint32_t*)ALIGN(128, BP(this->vWorkUV)  + this->input_width   + 128);
+  this->vOffsets = (uint32_t*)ALIGN(128, BP(this->hControl) + this->output_width  * sizeof(uint32_t) * 3 + 128);
+  this->vWeights = (uint32_t*)ALIGN(128, BP(this->vOffsets) + this->output_height * sizeof(uint32_t) + 128);
+
+  if (this->input_format == XINE_IMGFMT_YV12) {
+    this->vOffsetsUV = (uint32_t*)ALIGN(128, BP(this->vWeights)   + this->output_height * sizeof(uint32_t) + 128);
+    this->vWeightsUV = (uint32_t*)ALIGN(128, BP(this->vOffsetsUV) + this->output_height * sizeof(uint32_t) + 128);
+    this->hControlUV = (uint32_t*)ALIGN(128, BP(this->vWeightsUV) + this->output_height * sizeof(uint32_t) + 128);
+
+    init_tables_yv12(this->output_width, this->output_height,
+		     this->input_width,  this->input_height,
+		     this->input_interlaced, this->factor_x, this->factor_y, 
+		     this->hControl,   this->vOffsets,   this->vWeights,
+		     this->hControlUV, this->vOffsetsUV, this->vWeightsUV );
+
+  } else if (this->input_format == XINE_IMGFMT_YUY2) {
+
+    init_tables_yuy2(this->output_width, this->output_height,
+		     this->input_width,  this->input_height,
+		     this->input_interlaced, this->factor_x, this->factor_y, 
+		     this->hControl, this->vOffsets, this->vWeights );
+  }
+}
+
+static void calculate_factors(warp_plugin_t *this)
+{
+  /* try to guess amount to stretch/shrink */
+  double adiff = this->input_aspect - this->output_aspect;
+  this->factor_x = 1.0;
+  this->factor_y = 1.0;
+
+  if (adiff > 0.1) {
+
+    if (adiff > 0.1 + ((16.0-12.0)/9.0)) {
+      /* >16:9 -> >4:3 */
+      DBG("aspect ratio diff %1.3lf > 0 : too large !\n", adiff);
+      this->factor_x = 0.95;
+      this->factor_y = 1.15;
+      this->output_aspect += (adiff - 4.0/9.0);
+      DBG("  changing target ratio to %3.1lf\n", this->output_aspect);
+    } else {
+      /* 16:9 ... 12:9 -> 4:3 */
+      DBG("aspect ratio diff %1.3lf > 0 : 16.9...12:9 -> 4:3\n", adiff);
+      this->factor_x = 1.0 - 0.05 * adiff * 9.0/4.0;
+      this->factor_y = 1.0 + 0.15 * adiff * 9.0/4.0;
+    }
+
+  } else if (adiff < -0.1) {
+
+    if(adiff < -0.1-((16.0-12.0)/9.0)) {
+      /* <4:3 -> <16:9 */
+      DBG("aspect ratio diff %1.3lf > 0 : too large !\n", adiff);
+      this->factor_x = 1.05;
+      this->factor_y = 0.85;
+      this->output_aspect += (adiff + 4.0/9.0);
+      DBG("  changing target ratio to %3.1lf\n", this->output_aspect);
+    } else {
+      /* 4:3...16:9 -> 16:9 */
+      DBG("aspect ratio diff %1.3lf < 0 : 4:3...16:9 -> 16:9\n", adiff);
+      this->factor_x = 1.0 + 0.05 * adiff * 9.0/4.0;
+      this->factor_y = 1.0 - 0.15 * adiff * 9.0/4.0;
+    }
+
+  } else {
+    DBG("aspect ratio matches, no warp\n");
+    this->factor_x = 1.0;
+    this->factor_y = 1.0;
+  }
+
+  DBG("factor_x = %1.3lf factor_y = %1.3lf  output ratio = %1.3lf\n", 
+      this->factor_x, this->factor_y, this->output_aspect);
+}
+
+/*
+ *
+ */
+
+void *warp_init_plugin(xine_t *xine, void *data)
+{
+#if !defined(__x86_64__)
+  /* Need at least MMX */
+  if (!(xine_mm_accel() & MM_ACCEL_X86_MMX)) {
+    fprintf(stderr, "warp_init_plugin: ERROR: at least MMX required\n");
+    return NULL;
+  }
+#endif
+
+  return init_plugin(xine, data);
+}
+
+static post_plugin_t *open_plugin(post_class_t *class_gen, int inputs,
+					 xine_audio_port_t **audio_target,
+					 xine_video_port_t **video_target)
+{
+  warp_plugin_t     *this     = (warp_plugin_t *) xine_xmalloc(sizeof(warp_plugin_t));
+  post_plugin_t     *this_gen = (post_plugin_t *) this;
+  post_in_t         *input;
+  post_out_t        *output;
+  xine_post_in_t    *input_param;
+  post_video_port_t *port;
+
+  static xine_post_api_t post_api =
+    { warp_set_parameters,  warp_get_parameters, warp_get_param_descr, warp_get_help };
+  
+  if (!this || !video_target || !video_target[0]) {
+    free(this);
+    return NULL;
+  }
+  
+  _x_post_init(this_gen, 0, 1);
+  
+  port = _x_post_intercept_video_port(this_gen, video_target[0], &input, &output);
+  port->intercept_frame = intercept_frame_yuy;
+  port->new_frame->draw = post_draw;
+  input->xine_in.name   = "video";
+  output->xine_out.name = "video (scaled)";
+  this_gen->xine_post.video_input[0] = &port->new_port;
+
+  this_gen->dispose = warp_dispose;
+
+  input_param       = &this->parameter_input;
+  input_param->name = "parameters";
+  input_param->type = XINE_POST_DATA_PARAMETERS;
+  input_param->data = &post_api;
+  xine_list_push_back(this_gen->input, input_param);
+
+  this->config.output_aspect  = 0.0; /* -> do not change aspect ratio */
+  this->config.output_width   = 0;   /* -> do not change width */
+  this->config.output_height  = 0;   /* -> do not change height */
+  this->config.no_downscaling = 0;
+
+  this->input_width  = 0; /* not known yet, triggers initialization later */
+  this->input_height = 0;
+
+  return this_gen;
+}
+
+static void warp_dispose(post_plugin_t *this_gen)
+{
+  if (_x_post_dispose(this_gen)) {
+    warp_plugin_t *this = (warp_plugin_t *) this_gen;
+
+    DBG("dispose\n");
+
+    free(this->pMem);
+    free(this);
+  }
+}
+
+static vo_frame_t *got_frame(vo_frame_t *frame)
+{
+  post_video_port_t *port = (post_video_port_t *)frame->port;
+  warp_plugin_t     *this = (warp_plugin_t *)port->post;
+  double             adiff = this->input_aspect - frame->ratio;
+
+  if (this->input_width != frame->width || this->input_height != frame->height ||
+      this->input_format != frame->format || FABS(adiff)>0.1 ||
+      this->input_interlaced != !!(frame->flags & VO_INTERLACED_FLAG)) {
+
+    DBG("detected frame format change: %dx%d -> %dx%d, interlaced %d->%d, aspect %1.3lf->%1.3lf, %s->%s\n",
+	this->input_width, this->input_height, frame->width, frame->height,
+	this->input_interlaced, !!(frame->flags & VO_INTERLACED_FLAG),
+	this->input_aspect, frame->ratio, 
+	this->input_format==XINE_IMGFMT_YV12 ? "yv12":"yuy2", 
+	frame->format==XINE_IMGFMT_YV12 ? "yv12":"yuy2" );
+
+    /* free tables and buffers */
+    free(this->pMem);
+    this->pMem = NULL;
+
+    /* remember frame properties to detect changes in video format */
+    this->input_width  = frame->width;
+    this->input_height = frame->height;
+    this->input_format = frame->format;
+    this->input_aspect = frame->ratio;
+    this->input_interlaced = !!(frame->flags & VO_INTERLACED_FLAG);
+
+    /* re-configure target size and aspect ratio */ 
+    this->output_aspect = this->config.output_aspect ?: frame->ratio;
+    if (!this->config.no_downscaling) {
+      this->output_width  = this->config.output_width  ?: frame->width;
+      this->output_height = this->config.output_height ?: frame->height;
+    } else {
+      this->output_width  = MAX(this->config.output_width,  frame->width);
+      this->output_height = MAX(this->config.output_height, frame->height);
+    }
+
+    /* calculate warp function factors */
+    calculate_factors(this);
+
+    if(this->output_width  == frame->width &&
+       this->output_height == frame->height &&
+       adiff < 0.1  && 
+       adiff > -0.1 ) {
+      this->enable = 0;
+      DBG("--> nothing to do, disabling processing for now");
+      return NULL;
+    }
+
+    this->enable = 1;
+
+    init_tables(this);
+  }
+
+  if (!this->enable)
+    return NULL;
+
+  return port->original_port->get_frame(port->original_port,
+					this->output_width, this->output_height, 
+					this->output_aspect, frame->format,
+					frame->flags | VO_BOTH_FIELDS);
+}
+
+static void draw_internal(vo_frame_t *frame, vo_frame_t *new_frame)
+{
+  post_video_port_t *port = (post_video_port_t *)frame->port;
+  warp_plugin_t *this = (warp_plugin_t *)port->post;
+  int proc_height = frame->height;
+
+  if (frame->format == XINE_IMGFMT_YV12) {
+
+    do_warp_yv12(new_frame->base[0], frame->base[0], 
+		 new_frame->pitches[0], frame->pitches[0],
+		 this->output_width, this->output_height,
+		 frame->width, proc_height,
+		 this->input_interlaced,
+		 this->hControl, this->vOffsets, this->vWeights,
+		 this->vWorkY,
+		 0);
+    proc_height /= 2;
+    do_warp_yv12(new_frame->base[1], frame->base[1], 
+		 new_frame->pitches[1], frame->pitches[1],
+		 this->output_width/2, this->output_height/2,
+		 frame->width/2, proc_height, 
+		 this->input_interlaced,
+		 this->hControlUV, this->vOffsetsUV, this->vWeightsUV,
+		 this->vWorkUV,
+		 0);
+    do_warp_yv12(new_frame->base[2], frame->base[2], 
+		 new_frame->pitches[2], frame->pitches[2],
+		 this->output_width/2, this->output_height/2,
+		 frame->width/2, proc_height, 
+		 this->input_interlaced,
+		 this->hControlUV, this->vOffsetsUV, this->vWeightsUV,
+		 this->vWorkUV,
+		 0);
+
+  } else if (frame->format == XINE_IMGFMT_YUY2) {
+    do_warp_yuy2(new_frame->base[0], frame->base[0], 
+		 new_frame->pitches[0], frame->pitches[0],
+		 this->output_width, this->output_height,
+		 frame->width, proc_height, 
+		 this->input_interlaced,
+		 this->hControl, this->vOffsets, this->vWeights,
+		 this->vWorkY, this->vWorkUV, 
+		 0);
+  }
+}
+
+/*
+ * parameter functions
+ */
+
+static xine_post_api_descr_t *warp_get_param_descr(void)
+{
+  return &warp_param_descr;
+}
+
+static int warp_set_parameters(xine_post_t *this_gen, void *param_gen)
+{
+  warp_plugin_t *this = (warp_plugin_t *)this_gen;
+  warp_parameters_t *params = (warp_parameters_t *)param_gen;
+
+  memcpy(&this->config, params, sizeof(warp_parameters_t));  
+  this->input_width = this->input_height = 0;
+
+  DBG("warp_set_parameters: "
+      "output_width=%d, output_height=%d, output_aspect=%4.3lf, no_downscaling=%d\n",
+      this->config.output_width, this->config.output_height, this->config.output_aspect,
+      this->config.no_downscaling);
+
+  return 1;
+}
+
+static int warp_get_parameters(xine_post_t *this_gen, void *param_gen)
+{
+  warp_plugin_t *this = (warp_plugin_t *)this_gen;
+  warp_parameters_t *params = (warp_parameters_t *)param_gen;
+  
+  DBG("warp_get_parameters\n");
+  memcpy(params, &this->config, sizeof(warp_parameters_t));
+
+  return 1;
+}
+
+static char *warp_get_help(void) {
+  return _(
+	   "The warp plugin scales video to another resolution. "
+           "It supports non-linear stretching to change video aspect ratio. "
+	   "\n"
+           "Parameters\n"
+	   "  output_width:       Scale video to width\n"
+	   "                      (0 -> do not change video width)\n"
+	   "  output_height:      Scale video to height\n"
+	   "                      (0 -> do not change video height)\n"
+	   "  output_aspect:      Adjust aspect ratio using non-linear scaling\n"
+	   "                      (0 -> do not change video aspect ratio)\n"
+	   "  no_downscaling:     Do not downscale video\n"
+           "\n"
+         );
+}
+
+
+/*
+ * plugin info
+ */
+
+static post_info_t info = { XINE_POST_TYPE_VIDEO_FILTER };
+
+const plugin_info_t xine_plugin_info[] __attribute__((visibility("default"))) =
+{
+  /* type, API, "name", version, special_info, init_function */  
+  { PLUGIN_POST, 9, "warp",    XINE_VERSION_CODE, &info, &warp_init_plugin },
+  { PLUGIN_POST, 9, "swscale", XINE_VERSION_CODE, &info, &warp_init_plugin },
+  { PLUGIN_NONE, 0, "", 0, NULL, NULL }
+};