8 files changed, 1893 insertions, 689 deletions
diff --git a/noncore/multimedia/opieplayer2/alphablend.c b/noncore/multimedia/opieplayer2/alphablend.c
index cdd7b28..ab80531 100644
--- a/noncore/multimedia/opieplayer2/alphablend.c
+++ b/noncore/multimedia/opieplayer2/alphablend.c
@@ -1,755 +1,1784 @@
-//TOAST_SPU will define ALL spu entries - no matter the tranparency
-//#define TOAST_SPU
-/* #define PRIV_CLUT */
-/* Currently only blend_yuv(..) works */
 /*
 *
 * Copyright (C) James Courtier-Dutton James@superbug.demon.co.uk - July 2001
 * 
 * Copyright (C) 2000  Thomas Mirlacher
+ *               2002-2004 the xine project
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
 *
 * The author may be reached as <dent@linuxvideo.org>
 *
 *------------------------------------------------------------
 *
 */
 /*
 #define LOG_BLEND_YUV
+#define LOG_BLEND_RGB16
 */
 #include <string.h>
 #include <stdlib.h>
 #include <stdio.h>
-#include <inttypes.h>
-#include <xine.h>
 #include <xine/xine_internal.h>
 #include <xine/video_out.h>
 #include "alphablend.h"
+#include "bswap.h"
 #define BLEND_COLOR(dst, src, mask, o) ((((src&mask)*o + ((dst&mask)*(0x0f-o)))/0xf) & mask)
 #define BLEND_BYTE(dst, src, o) (((src)*o + ((dst)*(0xf-o)))/0xf)
 static void mem_blend16(uint16_t *mem, uint16_t clr, uint8_t o, int len) {
  uint16_t *limit = mem + len;
  while (mem < limit) {
    *mem =
     BLEND_COLOR(*mem, clr, 0xf800, o) |
     BLEND_COLOR(*mem, clr, 0x07e0, o) |
     BLEND_COLOR(*mem, clr, 0x001f, o);
    mem++;
  }
 }
 static void mem_blend24(uint8_t *mem, uint8_t r, uint8_t g, uint8_t b,
- uint8_t o, int len) {
+                        uint8_t o, int len) {
  uint8_t *limit = mem + len*3;
  while (mem < limit) {
    *mem = BLEND_BYTE(*mem, r, o);
    mem++;
    *mem = BLEND_BYTE(*mem, g, o);
    mem++;
    *mem = BLEND_BYTE(*mem, b, o);
    mem++;
  }
 }
-static void mem_blend24_32(uint8_t *mem, uint8_t r, uint8_t g, uint8_t b,
- uint8_t o, int len) {
-  uint8_t *limit = mem + len*4;
-  while (mem < limit) {
-    *mem = BLEND_BYTE(*mem, r, o);
-    mem++;
-    *mem = BLEND_BYTE(*mem, g, o);
-    mem++;
-    *mem = BLEND_BYTE(*mem, b, o);
-    mem += 2;
-  }
-}
 static void mem_blend32(uint8_t *mem, uint8_t *src, uint8_t o, int len) {
  uint8_t *limit = mem + len*4;
  while (mem < limit) {
    *mem = BLEND_BYTE(*mem, src[0], o);
    mem++;
    *mem = BLEND_BYTE(*mem, src[1], o);
    mem++;
    *mem = BLEND_BYTE(*mem, src[2], o);
    mem++;
    *mem = BLEND_BYTE(*mem, src[3], o);
    mem++;
  }
 }
 /*
 * Some macros for fixed point arithmetic.
 *
 * The blend_rgb* routines perform rle image scaling using
 * scale factors that are expressed as integers scaled with
 * a factor of 2**16.
 *
 * INT_TO_SCALED()/SCALED_TO_INT() converts from integer
 * to scaled fixed point and back.
 */
        #define         SCALE_SHIFT  16
        #define         SCALE_FACTOR  (1<<SCALE_SHIFT)
        #defineINT_TO_SCALED(i)  ((i)  << SCALE_SHIFT)
        #defineSCALED_TO_INT(sc) ((sc) >> SCALE_SHIFT)
 static rle_elem_t *
 rle_img_advance_line(rle_elem_t *rle, rle_elem_t *rle_limit, int w)
 {
  int x;
  for (x = 0; x < w && rle < rle_limit; ) {
    x += rle->len;
    rle++;
  }
  return rle;
 }
 void blend_rgb16 (uint8_t * img, vo_overlay_t * img_overl,
-                  int img_width, int img_height,
+                  int img_width, int img_height,
-                  int dst_width, int dst_height)
+                  int dst_width, int dst_height,
+                  alphablend_t *extra_data)
 {
  uint8_t *trans;
-  clut_t* clut = (clut_t*) img_overl->clip_color;
+  clut_t *clut;
  int src_width = img_overl->width;
  int src_height = img_overl->height;
  rle_elem_t *rle = img_overl->rle;
+  rle_elem_t *rle_start = img_overl->rle;
  rle_elem_t *rle_limit = rle + img_overl->num_rle;
  int x, y, x1_scaled, x2_scaled;
-          int dy, dy_step, x_scale;/* scaled 2**SCALE_SHIFT */
+  int dy, dy_step, x_scale;     /* scaled 2**SCALE_SHIFT */
  int clip_right;
  uint16_t *img_pix;
+  int rlelen;
+  int rle_this_bite;
+  int rle_remainder;
+  int zone_state=0;
+  uint8_t clr_next,clr;
+  uint16_t o;
+  double img_offset;
+  int stripe_height;
+/*
+ * Let zone_state keep state.
+ * 0 = Starting.
+ * 1 = Above button.
+ * 2 = Left of button.
+ * 3 = Inside of button.
+ * 4 = Right of button.
+ * 5 = Below button.
+ * 6 = Finished.
+ *
+ * Each time round the loop, update the state.
+ * We can do this easily and cheaply(fewer IF statements per cycle) as we are testing rle end position anyway.
+ * Possible optimization is to ensure that rle never overlaps from outside to inside a button.
+ * Possible optimization is to pre-scale the RLE overlay, so that no scaling is needed here.
+ */
-  dy_step = INT_TO_SCALED(dst_height) / img_height;
+#ifdef LOG_BLEND_RGB16
-  x_scale = INT_TO_SCALED(img_width)  / dst_width;
+  printf("blend_rgb16: img_height=%i, dst_height=%i\n", img_height, dst_height);
+  printf("blend_rgb16: img_width=%i, dst_width=%i\n", img_width, dst_width);
+  if (img_width & 1) { printf("blend_rgb16s: odd\n");}
+  else { printf("blend_rgb16s: even\n");}
-  img_pix = (uint16_t *) img
+#endif
+/* stripe_height is used in yuv2rgb scaling, so use the same scale factor here for overlays. */
+  stripe_height = 16 * img_height / dst_height;
+/*  dy_step = INT_TO_SCALED(dst_height) / img_height; */
+  dy_step = INT_TO_SCALED(16) / stripe_height;
+  x_scale = INT_TO_SCALED(img_width)  / dst_width;
+#ifdef LOG_BLEND_RGB16
+  printf("blend_rgb16: dy_step=%i, x_scale=%i\n", dy_step, x_scale);
+#endif
+  if (img_width & 1) img_width++;
+  img_offset = ( ( (img_overl->y * img_height) / dst_height) * img_width) 
+             + ( (img_overl->x * img_width) / dst_width);
+#ifdef LOG_BLEND_RGB16
+  printf("blend_rgb16: x=%i, y=%i, w=%i, h=%i, img_offset=%lf\n", img_overl->x, img_overl->y,
+    img_overl->width,
+    img_overl->height,
+    img_offset);
+#endif
+  img_pix = (uint16_t *) img + (int)img_offset;
+/* 
      + (img_overl->y * img_height / dst_height) * img_width
      + (img_overl->x * img_width / dst_width);
+*/
-  trans = img_overl->clip_trans;
  /* avoid wraping overlay if drawing to small image */
  if( (img_overl->x + img_overl->clip_right) < dst_width )
    clip_right = img_overl->clip_right;
  else
-    clip_right = dst_width - 1 - img_overl->x;
+    clip_right = dst_width - img_overl->x;
  /* avoid buffer overflow */
  if( (src_height + img_overl->y) >= dst_height )
-    src_height = dst_height - 1 - img_overl->y;
+    src_height = dst_height - img_overl->y;
-  for (y = dy = 0; y < src_height && rle < rle_limit;) {
+  rlelen = rle_remainder = rle_this_bite = 0;
-    int mask = !(img_overl->clip_top > y || img_overl->clip_bottom < y);
+  rle_remainder = rlelen = rle->len;
-    rle_elem_t *rle_start = rle;
+  clr_next = rle->color;
+  rle++;
+  y = dy = 0;
+  x = x1_scaled = x2_scaled = 0;
-    for (x = x1_scaled = 0; x < src_width;) {
+#ifdef LOG_BLEND_RGB16
-      uint8_t clr;
+  printf("blend_rgb16 started\n"); 
-      uint16_t o;
+#endif
-      int rlelen;
+  while (zone_state != 6) {
+    clr = clr_next;
+    switch (zone_state) {
+    case 0:  /* Starting */
+      /* FIXME: Get libspudec to set clip_top to -1 if no button */
+      if (img_overl->clip_top < 0) {
+#ifdef LOG_BLEND_RGB16
+        printf("blend_rgb16: No button clip area\n");
+#endif
-      clr = rle->color;
+        zone_state = 7;
+        break;
+      }
+#ifdef LOG_BLEND_RGB16
+      printf("blend_rgb16: Button clip area found. (%d,%d) .. (%d,%d)\n",
+        img_overl->clip_left,
+        img_overl->clip_top,
+        img_overl->clip_right,
+        img_overl->clip_bottom);
+#endif
+      if (y < img_overl->clip_top) {
+        zone_state = 1;
+        break;
+      } else if (y >= img_overl->clip_bottom) {
+        zone_state = 5;
+        break;
+      } else if (x < img_overl->clip_left) {
+        zone_state = 2;
+        break;
+      } else if (x >= img_overl->clip_right) {
+        zone_state = 4;
+        break;
+      } else {
+        zone_state = 3;
+        break;
+      }
+      break;
+    case 1:  /* Above clip area */
+      clut = (clut_t*) img_overl->color;
+      trans = img_overl->trans;
      o   = trans[clr];
-      rlelen = rle->len;
+      rle_this_bite = rle_remainder;
+      rle_remainder = 0;
-      if (o && mask) {
+      rlelen -= rle_this_bite;
-        /* threat cases where clipping border is inside rle->len pixels */
+      /*printf("(x,y) = (%03i,%03i), clr=%03x, len=%03i, zone=%i\n", x, y, clr, rle_this_bite, zone_state); */
-        if ( img_overl->clip_left > x ) {
+      if (o) {
-          if( img_overl->clip_left < x + rlelen ) {
+        x1_scaled = SCALED_TO_INT( x * x_scale );
-            x1_scaled = SCALED_TO_INT( img_overl->clip_left * x_scale );
+        x2_scaled = SCALED_TO_INT( (x + rle_this_bite) * x_scale);
-            rlelen -= img_overl->clip_left - x;
+        mem_blend16(img_pix+x1_scaled, *((uint16_t *)&clut[clr]), o, x2_scaled-x1_scaled);
-            x += img_overl->clip_left - x;
+      }
-          } else {
+      x += rle_this_bite;
-            o = 0;
+      if (x >= src_width ) { 
+        x -= src_width;
+        img_pix += img_width;
+ 
+        dy += dy_step;
+        if (dy >= INT_TO_SCALED(1)) {
+          dy -= INT_TO_SCALED(1);
+          ++y;
+          while (dy >= INT_TO_SCALED(1)) {
+            rle = rle_img_advance_line(rle, rle_limit, src_width);
+            dy -= INT_TO_SCALED(1);
+            ++y;
          }
-        } else if( clip_right < x + rlelen ) {
+          rle_start = rle;
-          if( clip_right > x ) {
+        } else {
-            x2_scaled = SCALED_TO_INT( clip_right * x_scale);
+          rle = rle_start;          /* y-scaling, reuse the last rle encoded line */
-            mem_blend16(img_pix+x1_scaled, *((uint16_t *)&clut[clr]), o,
+        }
-                        x2_scaled-x1_scaled);
+      } 
-            o = 0;            
+      rle_remainder = rlelen = rle->len;
-          } else {
+      clr_next = rle->color;
-            o = 0;
+      rle++;
+      if (rle >= rle_limit) {
+        zone_state = 6;
+      }
+      if (y >= img_overl->clip_top) {
+        zone_state = 2;
+#ifdef LOG_BLEND_RGB16
+        printf("blend_rgb16: Button clip top reached. y=%i, top=%i\n",
+                y, img_overl->clip_top);
+#endif
+        if (x >= img_overl->clip_left) {
+          zone_state = 3;
+          if (x >= img_overl->clip_right) {
+            zone_state = 4;
          }
-        } 
+        }
      }
-      
+      break;
-      x2_scaled = SCALED_TO_INT((x + rlelen) * x_scale);
+    case 2:  /* Left of button */
-      if (o && mask) {
+      clut = (clut_t*) img_overl->color;
-        mem_blend16(img_pix+x1_scaled, *((uint16_t *)&clut[clr]), o, x2_scaled-x1_scaled);
+      trans = img_overl->trans;
+      o   = trans[clr];
+      if (x + rle_remainder <= img_overl->clip_left) {
+        rle_this_bite = rle_remainder;
+        rle_remainder = rlelen = rle->len;
+        clr_next = rle->color;
+        rle++;
+      } else {
+        rle_this_bite = img_overl->clip_left - x;
+        rle_remainder -= rle_this_bite;
+        zone_state = 3;
      }
+      if (o) {
-      x1_scaled = x2_scaled;
+        x1_scaled = SCALED_TO_INT( x * x_scale );
-      x += rlelen;
+        x2_scaled = SCALED_TO_INT( (x + rle_this_bite) * x_scale);
+        mem_blend16(img_pix+x1_scaled, *((uint16_t *)&clut[clr]), o, x2_scaled-x1_scaled);
+      }
+      x += rle_this_bite;
+      if (x >= src_width ) { 
+        x -= src_width;
+        img_pix += img_width;
+        dy += dy_step;
+        if (dy >= INT_TO_SCALED(1)) {
+          dy -= INT_TO_SCALED(1);
+          ++y;
+          while (dy >= INT_TO_SCALED(1)) {
+            rle = rle_img_advance_line(rle, rle_limit, src_width);
+            dy -= INT_TO_SCALED(1);
+            ++y;
+          }
+          rle_start = rle;
+        } else {
+          rle = rle_start;          /* y-scaling, reuse the last rle encoded line */
+        }
+        if (y >= img_overl->clip_bottom) {
+          zone_state = 5;
+          break;
+        }
+      }
+      if (rle >= rle_limit) {
+        zone_state = 6;
+      }
+      break;
+    case 3:  /* In button */
+      clut = (clut_t*) img_overl->clip_color;
+      trans = img_overl->clip_trans;
+      o   = trans[clr];
+      if (x + rle_remainder <= img_overl->clip_right) {
+        rle_this_bite = rle_remainder;
+        rle_remainder = rlelen = rle->len;
+        clr_next = rle->color;
+        rle++;
+      } else {
+        rle_this_bite = img_overl->clip_right - x;
+        rle_remainder -= rle_this_bite;
+        zone_state = 4;
+      }
+      if (o) {
+        x1_scaled = SCALED_TO_INT( x * x_scale );
+        x2_scaled = SCALED_TO_INT( (x + rle_this_bite) * x_scale);
+        mem_blend16(img_pix+x1_scaled, *((uint16_t *)&clut[clr]), o, x2_scaled-x1_scaled);
+      }
+      x += rle_this_bite;
+      if (x >= src_width ) { 
+        x -= src_width;
+        img_pix += img_width;
+        dy += dy_step;
+        if (dy >= INT_TO_SCALED(1)) {
+          dy -= INT_TO_SCALED(1);
+          ++y;
+          while (dy >= INT_TO_SCALED(1)) {
+            rle = rle_img_advance_line(rle, rle_limit, src_width);
+            dy -= INT_TO_SCALED(1);
+            ++y;
+          }
+          rle_start = rle;
+        } else {
+          rle = rle_start;          /* y-scaling, reuse the last rle encoded line */
+        }
+        if (y >= img_overl->clip_bottom) {
+          zone_state = 5;
+          break;
+        }
+      } 
+      if (rle >= rle_limit) {
+        zone_state = 6;
+      }
+      break;
+    case 4:  /* Right of button */
+      clut = (clut_t*) img_overl->color;
+      trans = img_overl->trans;
+      o   = trans[clr];
+      if (x + rle_remainder <= src_width) {
+        rle_this_bite = rle_remainder;
+        rle_remainder = rlelen = rle->len;
+        clr_next = rle->color;
+        rle++;
+      } else {
+        rle_this_bite = src_width - x;
+        rle_remainder -= rle_this_bite;
+        zone_state = 2;
+      }
+      if (o) {
+        x1_scaled = SCALED_TO_INT( x * x_scale );
+        x2_scaled = SCALED_TO_INT( (x + rle_this_bite) * x_scale);
+        mem_blend16(img_pix+x1_scaled, *((uint16_t *)&clut[clr]), o, x2_scaled-x1_scaled);
+      }
+      x += rle_this_bite;
+      if (x >= src_width ) { 
+        x -= src_width;
+        img_pix += img_width;
+        dy += dy_step;
+        if (dy >= INT_TO_SCALED(1)) {
+          dy -= INT_TO_SCALED(1);
+          ++y;
+          while (dy >= INT_TO_SCALED(1)) {
+            rle = rle_img_advance_line(rle, rle_limit, src_width);
+            dy -= INT_TO_SCALED(1);
+            ++y;
+          }
+          rle_start = rle;
+        } else {
+          rle = rle_start;          /* y-scaling, reuse the last rle encoded line */
+        }
+        if (y >= img_overl->clip_bottom) {
+          zone_state = 5;
+          break;
+        }
+      } 
+      if (rle >= rle_limit) {
+        zone_state = 6;
+      }
+      break;
+    case 5:  /* Below button */
+      clut = (clut_t*) img_overl->color;
+      trans = img_overl->trans;
+      o   = trans[clr];
+      rle_this_bite = rle_remainder;
+      rle_remainder = 0;
+      rlelen -= rle_this_bite;
+      if (o) {
+        x1_scaled = SCALED_TO_INT( x * x_scale );
+        x2_scaled = SCALED_TO_INT( (x + rle_this_bite) * x_scale);
+        mem_blend16(img_pix+x1_scaled, *((uint16_t *)&clut[clr]), o, x2_scaled-x1_scaled);
+      }
+      x += rle_this_bite;
+      if (x >= src_width ) { 
+        x -= src_width;
+        img_pix += img_width;
+        dy += dy_step;
+        if (dy >= INT_TO_SCALED(1)) {
+          dy -= INT_TO_SCALED(1);
+          ++y;
+          while (dy >= INT_TO_SCALED(1)) {
+            rle = rle_img_advance_line(rle, rle_limit, src_width);
+            dy -= INT_TO_SCALED(1);
+            ++y;
+          }
+          rle_start = rle;
+        } else {
+          rle = rle_start;          /* y-scaling, reuse the last rle encoded line */
+        }
+      } 
+      rle_remainder = rlelen = rle->len;
+      clr_next = rle->color;
      rle++;
-      if (rle >= rle_limit) break;
+      if (rle >= rle_limit) {
-    }
+        zone_state = 6;
+      }
+      break;
+    case 6:  /* Finished */
+      _x_abort();
-    img_pix += img_width;
+    case 7:  /* No button */
-    dy += dy_step;
+      clut = (clut_t*) img_overl->color;
-    if (dy >= INT_TO_SCALED(1)) {
+      trans = img_overl->trans;
-      dy -= INT_TO_SCALED(1);
+      o   = trans[clr];
-      ++y;
+      rle_this_bite = rle_remainder;
-      while (dy >= INT_TO_SCALED(1)) {
+      rle_remainder = 0;
-        rle = rle_img_advance_line(rle, rle_limit, src_width);
+      rlelen -= rle_this_bite;
-        dy -= INT_TO_SCALED(1);
+      if (o) {
-        ++y;
+        x1_scaled = SCALED_TO_INT( x * x_scale );
+        x2_scaled = SCALED_TO_INT( (x + rle_this_bite) * x_scale);
+        mem_blend16(img_pix+x1_scaled, *((uint16_t *)&clut[clr]), o, x2_scaled-x1_scaled);
      }
-    } else {
+      x += rle_this_bite;
-              rle = rle_start;  /* y-scaling, reuse the last rle encoded line */
+      if (x >= src_width ) { 
+        x -= src_width;
+        img_pix += img_width;
+        dy += dy_step;
+        if (dy >= INT_TO_SCALED(1)) {
+          dy -= INT_TO_SCALED(1);
+          ++y;
+          while (dy >= INT_TO_SCALED(1)) {
+            rle = rle_img_advance_line(rle, rle_limit, src_width);
+            dy -= INT_TO_SCALED(1);
+            ++y;
+          }
+          rle_start = rle;
+        } else {
+          rle = rle_start;          /* y-scaling, reuse the last rle encoded line */
+        }
+      } 
+      rle_remainder = rlelen = rle->len;
+      clr_next = rle->color;
+      rle++;
+      if (rle >= rle_limit) {
+        zone_state = 6;
+      }
+      break;
+    default:
+      ;
    }
  }
+#ifdef LOG_BLEND_RGB16
+  printf("blend_rgb16 ended\n");
+#endif
+ 
 }
 void blend_rgb24 (uint8_t * img, vo_overlay_t * img_overl,
                  int img_width, int img_height,
-                  int dst_width, int dst_height)
+                  int dst_width, int dst_height,
+                  alphablend_t *extra_data)
 {
-  clut_t* clut = (clut_t*) img_overl->clip_color;
-  uint8_t *trans;
  int src_width = img_overl->width;
  int src_height = img_overl->height;
  rle_elem_t *rle = img_overl->rle;
  rle_elem_t *rle_limit = rle + img_overl->num_rle;
  int x, y, x1_scaled, x2_scaled;
          int dy, dy_step, x_scale;/* scaled 2**SCALE_SHIFT */
  int clip_right;
  uint8_t *img_pix;
  dy_step = INT_TO_SCALED(dst_height) / img_height;
  x_scale = INT_TO_SCALED(img_width)  / dst_width;
  img_pix = img + 3 * (  (img_overl->y * img_height / dst_height) * img_width
                       + (img_overl->x * img_width  / dst_width));
-  trans = img_overl->clip_trans;
  /* avoid wraping overlay if drawing to small image */
-  if( (img_overl->x + img_overl->clip_right) < dst_width )
+  if( (img_overl->x + img_overl->clip_right) <= dst_width )
    clip_right = img_overl->clip_right;
  else
-    clip_right = dst_width - 1 - img_overl->x;
+    clip_right = dst_width - img_overl->x;
  /* avoid buffer overflow */
-  if( (src_height + img_overl->y) >= dst_height )
+  if( (src_height + img_overl->y) > dst_height )
-    src_height = dst_height - 1 - img_overl->y;
+    src_height = dst_height - img_overl->y;
  for (dy = y = 0; y < src_height && rle < rle_limit; ) {
-    int mask = !(img_overl->clip_top > y || img_overl->clip_bottom < y);
+    int mask = !(y < img_overl->clip_top || y >= img_overl->clip_bottom);
    rle_elem_t *rle_start = rle;
+    int rlelen = 0;
+    uint8_t clr = 0;
    for (x = x1_scaled = 0; x < src_width;) {
-      uint8_t clr;
+      int rle_bite;
+      clut_t *colors;
+      uint8_t *trans;
      uint16_t o;
-      int rlelen;
-      clr = rle->color;
+      /* take next element from rle list everytime an element is finished */
-      o   = trans[clr];
+      if (rlelen <= 0) {
-      rlelen = rle->len;
+        if (rle >= rle_limit)
+          break;
-      if (o && mask) {
+        
-        /* threat cases where clipping border is inside rle->len pixels */
+        rlelen = rle->len;
-        if ( img_overl->clip_left > x ) {
+        clr = rle->color;
-          if( img_overl->clip_left < x + rlelen ) {
+        rle++;
-            x1_scaled = SCALED_TO_INT( img_overl->clip_left * x_scale );
+      }
-            rlelen -= img_overl->clip_left - x;
-            x += img_overl->clip_left - x;
+      if (!mask) {
+        /* above or below clipping area */
+        
+        rle_bite = rlelen;
+        /* choose palette for surrounding area */
+        colors = (clut_t*)img_overl->color;
+        trans = img_overl->trans;
+      } else {
+        /* treat cases where clipping border is inside rle->len pixels */
+        if ( x < img_overl->clip_left ) {
+          /* starts left */
+          if( x + rlelen > img_overl->clip_left ) {
+            /* ends not left */
+            /* choose the largest "bite" up to palette change */
+            rle_bite = img_overl->clip_left - x;
+            /* choose palette for surrounding area */
+            colors = (clut_t*)img_overl->color;
+            trans = img_overl->trans;
          } else {
-            o = 0;
+            /* ends left */
+            
+            rle_bite = rlelen;
+            /* choose palette for surrounding area */
+            colors = (clut_t*)img_overl->color;
+            trans = img_overl->trans;
          }
-        } else if( clip_right < x + rlelen ) {
+        } else if( x + rlelen > clip_right ) {
-          if( clip_right > x ) {
+          /* ends right */
-            x2_scaled = SCALED_TO_INT( clip_right * x_scale);
+          if( x < clip_right ) {
-            mem_blend24(img_pix + x1_scaled*3, clut[clr].cb,
+            /* starts not right */
-                    clut[clr].cr, clut[clr].y,
-                    o, x2_scaled-x1_scaled);
+            /* choose the largest "bite" up to palette change */
-            o = 0;            
+            rle_bite = clip_right - x;
+            /* we're in the center area so choose clip palette */
+            colors = (clut_t*)img_overl->clip_color;
+            trans = img_overl->clip_trans;
          } else {
-            o = 0;
+            /* starts right */
+            
+            rle_bite = rlelen;
+            /* choose palette for surrounding area */
+            colors = (clut_t*)img_overl->color;
+            trans = img_overl->trans;
          }
-        } 
+        } else {
+          /* starts not left and ends not right */
+          
+          rle_bite = rlelen;
+          /* we're in the center area so choose clip palette */
+          colors = (clut_t*)img_overl->clip_color;
+          trans = img_overl->clip_trans;
+        }
      }
      
-      x2_scaled = SCALED_TO_INT((x + rlelen) * x_scale);
+      x2_scaled = SCALED_TO_INT((x + rle_bite) * x_scale);
-      if (o && mask) {
-        mem_blend24(img_pix + x1_scaled*3, clut[clr].cb,
+      o = trans[clr];
-                    clut[clr].cr, clut[clr].y,
+      if (o) {
+        mem_blend24(img_pix + x1_scaled*3,
+                    colors[clr].cb, colors[clr].cr, colors[clr].y,
                    o, x2_scaled-x1_scaled);
      }
      x1_scaled = x2_scaled;
-      x += rlelen;
+      x += rle_bite;
-      rle++;
+      rlelen -= rle_bite;
-      if (rle >= rle_limit) break;
    }
    img_pix += img_width * 3;
    dy += dy_step;
    if (dy >= INT_TO_SCALED(1)) {
      dy -= INT_TO_SCALED(1);
      ++y;
      while (dy >= INT_TO_SCALED(1)) {
        rle = rle_img_advance_line(rle, rle_limit, src_width);
        dy -= INT_TO_SCALED(1);
        ++y;
      }
    } else {
              rle = rle_start;  /* y-scaling, reuse the last rle encoded line */
    }
  }
 }
 void blend_rgb32 (uint8_t * img, vo_overlay_t * img_overl,
                  int img_width, int img_height,
-                  int dst_width, int dst_height)
+                  int dst_width, int dst_height,
+                  alphablend_t *extra_data)
 {
-  clut_t* clut = (clut_t*) img_overl->clip_color;
-  uint8_t *trans;
  int src_width = img_overl->width;
  int src_height = img_overl->height;
  rle_elem_t *rle = img_overl->rle;
  rle_elem_t *rle_limit = rle + img_overl->num_rle;
  int x, y, x1_scaled, x2_scaled;
          int dy, dy_step, x_scale;/* scaled 2**SCALE_SHIFT */
  int clip_right;
  uint8_t *img_pix;
  dy_step = INT_TO_SCALED(dst_height) / img_height;
  x_scale = INT_TO_SCALED(img_width)  / dst_width;
  img_pix = img + 4 * (  (img_overl->y * img_height / dst_height) * img_width
                       + (img_overl->x * img_width / dst_width));
-  trans = img_overl->clip_trans;
  /* avoid wraping overlay if drawing to small image */
-  if( (img_overl->x + img_overl->clip_right) < dst_width )
+  if( (img_overl->x + img_overl->clip_right) <= dst_width )
    clip_right = img_overl->clip_right;
  else
-    clip_right = dst_width - 1 - img_overl->x;
+    clip_right = dst_width - img_overl->x;
  /* avoid buffer overflow */
-  if( (src_height + img_overl->y) >= dst_height )
+  if( (src_height + img_overl->y) > dst_height )
-    src_height = dst_height - 1 - img_overl->y;
+    src_height = dst_height - img_overl->y;
  for (y = dy = 0; y < src_height && rle < rle_limit; ) {
-    int mask = !(img_overl->clip_top > y || img_overl->clip_bottom < y);
+    int mask = !(y < img_overl->clip_top || y >= img_overl->clip_bottom);
    rle_elem_t *rle_start = rle;
+    int rlelen = 0;
+    uint8_t clr = 0;
+    
    for (x = x1_scaled = 0; x < src_width;) {
-      uint8_t clr;
+      int rle_bite;
+      clut_t *colors;
+      uint8_t *trans;
      uint16_t o;
-      int rlelen;
+      
+      /* take next element from rle list everytime an element is finished */
+      if (rlelen <= 0) {
+        if (rle >= rle_limit)
+          break;
+        
+        rlelen = rle->len;
+        clr = rle->color;
+        rle++;
+      }
-      clr = rle->color;
+      if (!mask) {
-      o   = trans[clr];
+        /* above or below clipping area */
-      rlelen = rle->len;
+        
+        rle_bite = rlelen;
-      if (o && mask) {
+        /* choose palette for surrounding area */
-        /* threat cases where clipping border is inside rle->len pixels */
+        colors = (clut_t*)img_overl->color;
-        if ( img_overl->clip_left > x ) {
+        trans = img_overl->trans;
-          if( img_overl->clip_left < x + rlelen ) {
+      } else {
-            x1_scaled = SCALED_TO_INT( img_overl->clip_left * x_scale );
+        /* treat cases where clipping border is inside rle->len pixels */
-            rlelen -= img_overl->clip_left - x;
+        if ( x < img_overl->clip_left ) {
-            x += img_overl->clip_left - x;
+          /* starts left */
+          if( x + rlelen > img_overl->clip_left ) {
+            /* ends not left */
+            /* choose the largest "bite" up to palette change */
+            rle_bite = img_overl->clip_left - x;
+            /* choose palette for surrounding area */
+            colors = (clut_t*)img_overl->color;
+            trans = img_overl->trans;
          } else {
-            o = 0;
+            /* ends left */
+            
+            rle_bite = rlelen;
+            /* choose palette for surrounding area */
+            colors = (clut_t*)img_overl->color;
+            trans = img_overl->trans;
          }
-        } else if( clip_right < x + rlelen ) {
+        } else if( x + rlelen > clip_right ) {
-          if( clip_right > x ) {
+          /* ends right */
-            x2_scaled = SCALED_TO_INT( clip_right * x_scale);
+          if( x < clip_right ) {
-            mem_blend24_32(img_pix + x1_scaled*4, clut[clr].cb,
+            /* starts not right */
-                    clut[clr].cr, clut[clr].y,
-                    o, x2_scaled-x1_scaled);
+            /* choose the largest "bite" up to palette change */
-            o = 0;            
+            rle_bite = clip_right - x;
+            /* we're in the center area so choose clip palette */
+            colors = (clut_t*)img_overl->clip_color;
+            trans = img_overl->clip_trans;
          } else {
-            o = 0;
+            /* starts right */
+            
+            rle_bite = rlelen;
+            /* choose palette for surrounding area */
+            colors = (clut_t*)img_overl->color;
+            trans = img_overl->trans;
          }
-        } 
+        } else {
+          /* starts not left and ends not right */
+          
+          rle_bite = rlelen;
+          /* we're in the center area so choose clip palette */
+          colors = (clut_t*)img_overl->clip_color;
+          trans = img_overl->clip_trans;
+        }
      }
+      
+      x2_scaled = SCALED_TO_INT((x + rle_bite) * x_scale);
-      x2_scaled = SCALED_TO_INT((x + rlelen) * x_scale);
+      o = trans[clr];
-      if (o && mask) {
+      if (o) {
-        mem_blend24_32(img_pix + x1_scaled*4, clut[clr].cb,
+        mem_blend32(img_pix + x1_scaled*4, (uint8_t *)&colors[clr], o, x2_scaled-x1_scaled);
-                    clut[clr].cr, clut[clr].y,
-                    o, x2_scaled-x1_scaled);
      }
      x1_scaled = x2_scaled;
-      x += rlelen;
+      x += rle_bite;
-      rle++;
+      rlelen -= rle_bite;
-      if (rle >= rle_limit) break;
    }
    img_pix += img_width * 4;
    dy += dy_step;
    if (dy >= INT_TO_SCALED(1)) {
      dy -= INT_TO_SCALED(1);
      ++y;
      while (dy >= INT_TO_SCALED(1)) {
        rle = rle_img_advance_line(rle, rle_limit, src_width);
        dy -= INT_TO_SCALED(1);
        ++y;
      }
    } else {
              rle = rle_start;  /* y-scaling, reuse the last rle encoded line */
    }
  }
 }
 static void mem_blend8(uint8_t *mem, uint8_t val, uint8_t o, size_t sz)
 {
  uint8_t *limit = mem + sz;
  while (mem < limit) {
    *mem = BLEND_BYTE(*mem, val, o);
    mem++;
  }
 }
+static void blend_yuv_exact(uint8_t *dst_cr, uint8_t *dst_cb,
+                            int src_width, int x_odd,
+                            uint8_t *(*blend_yuv_data)[ 3 ][ 2 ])
+{
+  int x;
+  
+  for (x = 0; x < src_width; x += 2) {
+    /* get opacity of the 4 pixels that share chroma */
+    int o00 = (*blend_yuv_data)[ 0 ][ 0 ][ x + 0 ];
+    int o01 = (*blend_yuv_data)[ 0 ][ 0 ][ x + 1 ];
+    int o10 = (*blend_yuv_data)[ 0 ][ 1 ][ x + 0 ];
+    int o11 = (*blend_yuv_data)[ 0 ][ 1 ][ x + 1 ];
+    /* are there any pixels a little bit opaque? */
+    if (o00 || o01 || o10 || o11) {
+      /* get the chroma components of the 4 pixels */
+      int cr00 = -128 + (*blend_yuv_data)[ 1 ][ 0 ][ x + 0 ];
+      int cr01 = -128 + (*blend_yuv_data)[ 1 ][ 0 ][ x + 1 ];
+      int cr10 = -128 + (*blend_yuv_data)[ 1 ][ 1 ][ x + 0 ];
+      int cr11 = -128 + (*blend_yuv_data)[ 1 ][ 1 ][ x + 1 ];
+          
+      int cb00 = -128 + (*blend_yuv_data)[ 2 ][ 0 ][ x + 0 ];
+      int cb01 = -128 + (*blend_yuv_data)[ 2 ][ 0 ][ x + 1 ];
+      int cb10 = -128 + (*blend_yuv_data)[ 2 ][ 1 ][ x + 0 ];
+      int cb11 = -128 + (*blend_yuv_data)[ 2 ][ 1 ][ x + 1 ];
+      /* are all pixels completely opaque? */
+      if (o00 >= 0xf && o01 >= 0xf && o10 >= 0xf && o11 >= 0xf) {
+        /* set the output chroma to the average of the four pixels */
+        *dst_cr = 128 + (cr00 + cr01 + cr10 + cr11) / 4;
+        *dst_cb = 128 + (cb00 + cb01 + cb10 + cb11) / 4;
+      } else {
+        int t4, cr, cb;
+        
+        /* blending required, so clamp opacity values to allowed range */
+        if (o00 > 0xf) o00 = 0xf;
+        if (o01 > 0xf) o01 = 0xf;
+        if (o10 > 0xf) o10 = 0xf;
+        if (o11 > 0xf) o11 = 0xf;
+        /* calculate transparency of background over the four pixels */
+        t4 = (0xf - o00) + (0xf - o01) + (0xf - o10) + (0xf - o11);
+        /* get background chroma */
+        cr = -128 + *dst_cr;
+        cb = -128 + *dst_cb;
+        /* blend the output chroma to the average of the four pixels */
+        *dst_cr = 128 + (cr * t4 + cr00 * o00 + cr01 * o01 + cr10 * o10 + cr11 * o11) / (4 * 0xf);
+        *dst_cb = 128 + (cb * t4 + cb00 * o00 + cb01 * o01 + cb10 * o10 + cb11 * o11) / (4 * 0xf);
+      }
+    }
+    /* next chroma sample */
+    dst_cr++;
+    dst_cb++;
+  }
+}
+static uint8_t *(*blend_yuv_grow_extra_data(alphablend_t *extra_data, int osd_width))[ 3 ][ 2 ]
+{
+  struct __attribute__((packed)) header_s {
+    int id;
+    int max_width;
+    uint8_t *data[ 3 ][ 2 ];
+  } **header = (struct header_s **)&extra_data->buffer;
+  
+  int needed_buffer_size = sizeof (**header) + sizeof (uint8_t[ 3 ][ 2 ][ osd_width ]);
+  
+  if (extra_data->buffer_size < needed_buffer_size) {
+    
+    free(extra_data->buffer);
+    extra_data->buffer = xine_xmalloc(needed_buffer_size);
+    if (!extra_data->buffer) {
+      extra_data->buffer_size = 0;
+      return 0;
+    }
+    
+    extra_data->buffer_size = needed_buffer_size;
+    (*header)->max_width = 0;
+  }
+  if ((*header)->id != ME_FOURCC('y', 'u', 'v', 0) || (*header)->max_width < osd_width) {
+    (*header)->id = ME_FOURCC('y', 'u', 'v', 0);
+    (*header)->max_width = osd_width;
+    (*header)->data[ 0 ][ 0 ] = ((uint8_t *)extra_data->buffer) + sizeof (**header);
+    (*header)->data[ 0 ][ 1 ] = (*header)->data[ 0 ][ 0 ] + osd_width;
+    (*header)->data[ 1 ][ 0 ] = (*header)->data[ 0 ][ 1 ] + osd_width;
+    (*header)->data[ 1 ][ 1 ] = (*header)->data[ 1 ][ 0 ] + osd_width;
+    (*header)->data[ 2 ][ 0 ] = (*header)->data[ 1 ][ 1 ] + osd_width;
+    (*header)->data[ 2 ][ 1 ] = (*header)->data[ 2 ][ 0 ] + osd_width;
+  }
+  return &(*header)->data;
+}
+  
 void blend_yuv (uint8_t *dst_base[3], vo_overlay_t * img_overl,
-                int dst_width, int dst_height)
+                int dst_width, int dst_height, int dst_pitches[3],
+                alphablend_t *extra_data)
 {
+  int enable_exact_blending = !extra_data->disable_exact_blending;
  clut_t *my_clut;
  uint8_t *my_trans;
  int src_width = img_overl->width;
  int src_height = img_overl->height;
  rle_elem_t *rle = img_overl->rle;
  rle_elem_t *rle_limit = rle + img_overl->num_rle;
  int x_off = img_overl->x;
  int y_off = img_overl->y;
+  int x_odd = x_off & 1;
+  int y_odd = y_off & 1;
  int ymask,xmask;
  int rle_this_bite;
  int rle_remainder;
  int rlelen;
  int x, y;
  int clip_right;
  uint8_t clr=0;
+  
-  uint8_t *dst_y = dst_base[0] + dst_width * y_off + x_off;
+  int any_line_buffered = 0;
-  uint8_t *dst_cr = dst_base[2] +
+  int exact_blend_width = ((src_width <= (dst_width - x_off)) ? src_width : (dst_width - x_off));
-    (y_off / 2) * (dst_width / 2) + (x_off / 2) + 1;
+  int exact_blend_width_m2 = (x_odd + exact_blend_width + 1) & ~1; /* make it a (larger) multiple of 2 */
-  uint8_t *dst_cb = dst_base[1] +
+  uint8_t *(*blend_yuv_data)[ 3 ][ 2 ] = 0;
-    (y_off / 2) * (dst_width / 2) + (x_off / 2) + 1;
+  
+  uint8_t *dst_y = dst_base[0] + dst_pitches[0] * y_off + x_off;
+  uint8_t *dst_cr = dst_base[2] + (y_off / 2) * dst_pitches[1] + (x_off / 2);
+  uint8_t *dst_cb = dst_base[1] + (y_off / 2) * dst_pitches[2] + (x_off / 2);
 #ifdef LOG_BLEND_YUV
  printf("overlay_blend started x=%d, y=%d, w=%d h=%d\n",img_overl->x,img_overl->y,img_overl->width,img_overl->height);
 #endif
  my_clut = (clut_t*) img_overl->clip_color;
  my_trans = img_overl->clip_trans;
  /* avoid wraping overlay if drawing to small image */
-  if( (x_off + img_overl->clip_right) < dst_width )
+  if( (x_off + img_overl->clip_right) <= dst_width )
    clip_right = img_overl->clip_right;
  else
-    clip_right = dst_width - 1 - x_off;
+    clip_right = dst_width - x_off;
  /* avoid buffer overflow */
-  if( (src_height + y_off) >= dst_height )
+  if( (src_height + y_off) > dst_height )
-    src_height = dst_height - 1 - y_off;
+    src_height = dst_height - y_off;
+  if (src_height <= 0)
+    return;
+  if (enable_exact_blending) {
+    if (exact_blend_width <= 0)
+      return;
+  
+    blend_yuv_data = blend_yuv_grow_extra_data(extra_data, exact_blend_width_m2);
+    if (!blend_yuv_data)
+      return;
+    
+    /* make linebuffer transparent */
+    memset(&(*blend_yuv_data)[ 0 ][ 0 ][ 0 ], 0, exact_blend_width_m2);
+    memset(&(*blend_yuv_data)[ 0 ][ 1 ][ 0 ], 0, exact_blend_width_m2);
+  }
+  
  rlelen=rle_remainder=0;
  for (y = 0; y < src_height; y++) {
-    ymask = ((img_overl->clip_top > y) || (img_overl->clip_bottom < y));
+    if (rle >= rle_limit) {
+#ifdef LOG_BLEND_YUV
+      printf("y-rle_limit\n");
+#endif
+      break;
+    }
+    
+    ymask = ((y < img_overl->clip_top) || (y >= img_overl->clip_bottom));
    xmask = 0;
 #ifdef LOG_BLEND_YUV
    printf("X started ymask=%d y=%d src_height=%d\n",ymask, y, src_height);
 #endif
    for (x = 0; x < src_width;) {
      uint16_t o;
+      
+      if (rle >= rle_limit) {
+#ifdef LOG_BLEND_YUV
+        printf("x-rle_limit\n");
+#endif
+        break;
+      }
+      
 #ifdef LOG_BLEND_YUV
      printf("1:rle_len=%d, remainder=%d, x=%d\n",rlelen, rle_remainder, x);
 #endif
      if ((rlelen < 0) || (rle_remainder < 0)) {
+#ifdef LOG_BLEND_YUV
        printf("alphablend: major bug in blend_yuv < 0\n");
+#endif
      } 
      if (rlelen == 0) {
        rle_remainder = rlelen = rle->len;
        clr = rle->color;
        rle++;
      }
      if (rle_remainder == 0) {
        rle_remainder = rlelen;
      }
      if ((rle_remainder + x) > src_width) {
        /* Do something for long rlelengths */
-        rle_remainder = src_width - x; 
+        rle_remainder = src_width - x;
-        ;
      }
 #ifdef LOG_BLEND_YUV
      printf("2:rle_len=%d, remainder=%d, x=%d\n",rlelen, rle_remainder, x);
 #endif
      if (ymask == 0) {
-        if (x <= img_overl->clip_left) { 
+        if (x < img_overl->clip_left) { 
          /* Starts outside clip area */
-          if ((x + rle_remainder - 1) > img_overl->clip_left ) {
+          if ((x + rle_remainder) > img_overl->clip_left ) {
 #ifdef LOG_BLEND_YUV
            printf("Outside clip left %d, ending inside\n", img_overl->clip_left); 
 #endif
            /* Cutting needed, starts outside, ends inside */
-            rle_this_bite = (img_overl->clip_left - x + 1);
+            rle_this_bite = (img_overl->clip_left - x);
            rle_remainder -= rle_this_bite;
            rlelen -= rle_this_bite;
            my_clut = (clut_t*) img_overl->color;
            my_trans = img_overl->trans;
            xmask = 0;
          } else {
 #ifdef LOG_BLEND_YUV
            printf("Outside clip left %d, ending outside\n", img_overl->clip_left); 
 #endif
          /* no cutting needed, starts outside, ends outside */
            rle_this_bite = rle_remainder;
            rle_remainder = 0;
            rlelen -= rle_this_bite;
            my_clut = (clut_t*) img_overl->color;
            my_trans = img_overl->trans;
            xmask = 0;
          }
        } else if (x < clip_right) {
          /* Starts inside clip area */
          if ((x + rle_remainder) > clip_right ) {
 #ifdef LOG_BLEND_YUV
            printf("Inside clip right %d, ending outside\n", clip_right);
 #endif
            /* Cutting needed, starts inside, ends outside */
            rle_this_bite = (clip_right - x);
            rle_remainder -= rle_this_bite;
            rlelen -= rle_this_bite;
            my_clut = (clut_t*) img_overl->clip_color;
            my_trans = img_overl->clip_trans;
            xmask++;
          } else {
 #ifdef LOG_BLEND_YUV
            printf("Inside clip right %d, ending inside\n", clip_right);
 #endif
          /* no cutting needed, starts inside, ends inside */
            rle_this_bite = rle_remainder;
            rle_remainder = 0;
            rlelen -= rle_this_bite;
            my_clut = (clut_t*) img_overl->clip_color;
            my_trans = img_overl->clip_trans;
            xmask++;
          }
        } else if (x >= clip_right) {
-          /* Starts outside clip area, ends outsite clip area */
+          /* Starts outside clip area, ends outside clip area */
          if ((x + rle_remainder ) > src_width ) { 
 #ifdef LOG_BLEND_YUV
            printf("Outside clip right %d, ending eol\n", clip_right);
 #endif
            /* Cutting needed, starts outside, ends at right edge */
            /* It should never reach here due to the earlier test of src_width */
            rle_this_bite = (src_width - x );
            rle_remainder -= rle_this_bite;
            rlelen -= rle_this_bite;
            my_clut = (clut_t*) img_overl->color;
            my_trans = img_overl->trans;
            xmask = 0;
          } else {
          /* no cutting needed, starts outside, ends outside */
 #ifdef LOG_BLEND_YUV
            printf("Outside clip right %d, ending outside\n", clip_right);
 #endif
            rle_this_bite = rle_remainder;
            rle_remainder = 0;
            rlelen -= rle_this_bite;
            my_clut = (clut_t*) img_overl->color;
            my_trans = img_overl->trans;
            xmask = 0;
          }
        }
      } else {
        /* Outside clip are due to y */
        /* no cutting needed, starts outside, ends outside */
        rle_this_bite = rle_remainder;
        rle_remainder = 0;
        rlelen -= rle_this_bite;
        my_clut = (clut_t*) img_overl->color;
        my_trans = img_overl->trans;
        xmask = 0;
      }
      o   = my_trans[clr];
 #ifdef LOG_BLEND_YUV
      printf("Trans=%d clr=%d xmask=%d my_clut[clr]=%d\n",o, clr, xmask, my_clut[clr].y);
 #endif
-      if (o) {
-        if(o >= 15) {
+      if (x < (dst_width - x_off)) {
-          memset(dst_y + x, my_clut[clr].y, rle_this_bite);
+        /* clip against right edge of destination area */
-          if (y & 1) {
+        if ((x + rle_this_bite) > (dst_width - x_off)) {
-            memset(dst_cr + (x >> 1), my_clut[clr].cr, (rle_this_bite+1) >> 1);
+          int toClip = (x + rle_this_bite) - (dst_width - x_off);
-            memset(dst_cb + (x >> 1), my_clut[clr].cb, (rle_this_bite+1) >> 1);
+          
-          }
+          rle_this_bite -= toClip;
-        } else {
+          rle_remainder += toClip;
-          mem_blend8(dst_y + x, my_clut[clr].y, o, rle_this_bite);
+          rlelen += toClip;
-          if (y & 1) {
-            /* Blending cr and cb should use a different function, with pre -128 to each sample */
-            mem_blend8(dst_cr + (x >> 1), my_clut[clr].cr, o, (rle_this_bite+1) >> 1);
-            mem_blend8(dst_cb + (x >> 1), my_clut[clr].cb, o, (rle_this_bite+1) >> 1);
-          }
        }
+        if (enable_exact_blending) {
+          /* remember opacity of current line */
+          memset(&(*blend_yuv_data)[ 0 ][ (y + y_odd) & 1 ][ x + x_odd ], o, rle_this_bite);
+          any_line_buffered |= ((y + y_odd) & 1) ? 2 : 1;
+        }
+      
+        if (o) {
+          if(o >= 15) {
+            memset(dst_y + x, my_clut[clr].y, rle_this_bite);
+            if (!enable_exact_blending) {
+              if ((y + y_odd) & 1) {
+                memset(dst_cr + ((x + x_odd) >> 1), my_clut[clr].cr, (rle_this_bite+1) >> 1);
+                memset(dst_cb + ((x + x_odd) >> 1), my_clut[clr].cb, (rle_this_bite+1) >> 1);
+              }
+            }
+          } else {
+            mem_blend8(dst_y + x, my_clut[clr].y, o, rle_this_bite);
+            if (!enable_exact_blending) {
+              if ((y + y_odd) & 1) {
+                /* Blending cr and cb should use a different function, with pre -128 to each sample */
+                mem_blend8(dst_cr + ((x + x_odd) >> 1), my_clut[clr].cr, o, (rle_this_bite+1) >> 1);
+                mem_blend8(dst_cb + ((x + x_odd) >> 1), my_clut[clr].cb, o, (rle_this_bite+1) >> 1);
+              }
+            }
+          }
+          if (enable_exact_blending) {
+            /* remember chroma of current line */
+            memset(&(*blend_yuv_data)[ 1 ][ (y + y_odd) & 1 ][ x + x_odd ], my_clut[ clr ].cr, rle_this_bite);
+            memset(&(*blend_yuv_data)[ 2 ][ (y + y_odd) & 1 ][ x + x_odd ], my_clut[ clr ].cb, rle_this_bite);
+          }
+        }
      }
 #ifdef LOG_BLEND_YUV
      printf("rle_this_bite=%d, remainder=%d, x=%d\n",rle_this_bite, rle_remainder, x);
 #endif
      x += rle_this_bite;
-      if (rle >= rle_limit) {
-#ifdef LOG_BLEND_YUV
-        printf("x-rle_limit\n");
-#endif
-        break;
-      }
-    }
-    if (rle >= rle_limit) {
-#ifdef LOG_BLEND_YUV
-        printf("x-rle_limit\n");
-#endif
-        break;
    }
-    dst_y += dst_width;
+    if ((y + y_odd) & 1) {
+      if (enable_exact_blending) {
+        /* blend buffered lines */
+        if (any_line_buffered) {
+          if (!(any_line_buffered & 2)) {
+            /* make second line transparent */
+            memset(&(*blend_yuv_data)[ 0 ][ 1 ][ 0 ], 0, exact_blend_width_m2);
+          }
+          
+          blend_yuv_exact(dst_cr, dst_cb, exact_blend_width, x_odd, blend_yuv_data);
+          
+          any_line_buffered = 0;
+        }
+      }
+      
+      dst_cr += dst_pitches[2];
+      dst_cb += dst_pitches[1];
+    }
+    
+    dst_y += dst_pitches[0];
+  }
-    if (y & 1) {
+  if (enable_exact_blending) {
-      dst_cr += (dst_width + 1) / 2;
+    /* blend buffered lines */
-      dst_cb += (dst_width + 1) / 2;
+    if (any_line_buffered) {
+      if (!(any_line_buffered & 2)) {
+        /* make second line transparent */
+        memset(&(*blend_yuv_data)[ 0 ][ 1 ][ 0 ], 0, exact_blend_width_m2);
+      }
+      
+      blend_yuv_exact(dst_cr, dst_cb, exact_blend_width, x_odd, blend_yuv_data);
    }
  }
+      
 #ifdef LOG_BLEND_YUV
  printf("overlay_blend ended\n");
 #endif
 }
            
+static void blend_yuy2_exact(uint8_t *dst_cr, uint8_t *dst_cb,
+                             int src_width, int x_odd,
+                             uint8_t *(*blend_yuy2_data)[ 3 ])
+{
+  int x;
+  
+  for (x = 0; x < src_width; x += 2) {
+    /* get opacity of the 2 pixels that share chroma */
+    int o0 = (*blend_yuy2_data)[ 0 ][ x + 0 ];
+    int o1 = (*blend_yuy2_data)[ 0 ][ x + 1 ];
+    /* are there any pixels a little bit opaque? */
+    if (o0 || o1) {
+      /* get the chroma components of the 2 pixels */
+      int cr0 = -128 + (*blend_yuy2_data)[ 1 ][ x + 0 ];
+      int cr1 = -128 + (*blend_yuy2_data)[ 1 ][ x + 1 ];
+          
+      int cb0 = -128 + (*blend_yuy2_data)[ 2 ][ x + 0 ];
+      int cb1 = -128 + (*blend_yuy2_data)[ 2 ][ x + 1 ];
+      /* are all pixels completely opaque? */
+      if (o0 >= 0xf && o1 >= 0xf) {
+        /* set the output chroma to the average of the two pixels */
+        *dst_cr = 128 + (cr0 + cr1) / 2;
+        *dst_cb = 128 + (cb0 + cb1) / 2;
+      } else {
+        int t2, cr, cb;
+        
+        /* blending required, so clamp opacity values to allowed range */
+        if (o0 > 0xf) o0 = 0xf;
+        if (o1 > 0xf) o1 = 0xf;
+        /* calculate transparency of background over the two pixels */
+        t2 = (0xf - o0) + (0xf - o1);
+        /* get background chroma */
+        cr = -128 + *dst_cr;
+        cb = -128 + *dst_cb;
+        /* blend the output chroma to the average of the two pixels */
+        *dst_cr = 128 + (cr * t2 + cr0 * o0 + cr1 * o1) / (2 * 0xf);
+        *dst_cb = 128 + (cb * t2 + cb0 * o0 + cb1 * o1) / (2 * 0xf);
+      }
+    }
+    /* next chroma sample */
+    dst_cr += 4;
+    dst_cb += 4;
+  }
+}
+static uint8_t *(*blend_yuy2_grow_extra_data(alphablend_t *extra_data, int osd_width))[ 3 ]
+{
+  struct __attribute__((packed)) header_s {
+    int id;
+    int max_width;
+    uint8_t *data[ 3 ];
+  } **header = (struct header_s **)&extra_data->buffer;
+  
+  int needed_buffer_size = sizeof (**header) + sizeof (uint8_t[ 3 ][ osd_width ]);
+  
+  if (extra_data->buffer_size < needed_buffer_size) {
+    
+    free(extra_data->buffer);
+    extra_data->buffer = xine_xmalloc(needed_buffer_size);
+    if (!extra_data->buffer) {
+      extra_data->buffer_size = 0;
+      return 0;
+    }
+    
+    extra_data->buffer_size = needed_buffer_size;
+    (*header)->max_width = 0;
+  }
+  if ((*header)->id != ME_FOURCC('y', 'u', 'y', '2') || (*header)->max_width < osd_width) {
+    (*header)->id = ME_FOURCC('y', 'u', 'y', '2');
+    (*header)->max_width = osd_width;
+    (*header)->data[ 0 ] = ((uint8_t *)extra_data->buffer) + sizeof (**header);
+    (*header)->data[ 1 ] = (*header)->data[ 0 ] + osd_width;
+    (*header)->data[ 2 ] = (*header)->data[ 1 ] + osd_width;
+  }
+  return &(*header)->data;
+}
 void blend_yuy2 (uint8_t * dst_img, vo_overlay_t * img_overl,
-                int dst_width, int dst_height)
+                 int dst_width, int dst_height, int dst_pitch,
+                 alphablend_t *extra_data)
 {
+  int enable_exact_blending = !extra_data->disable_exact_blending;
  clut_t *my_clut;
  uint8_t *my_trans;
  int src_width = img_overl->width;
  int src_height = img_overl->height;
  rle_elem_t *rle = img_overl->rle;
  rle_elem_t *rle_limit = rle + img_overl->num_rle;
  int x_off = img_overl->x;
  int y_off = img_overl->y;
-  int mask;
+  int x_odd = x_off & 1;
+  int ymask;
+  int rle_this_bite;
+  int rle_remainder;
+  int rlelen;
  int x, y;
-  int l;
+  int l = 0;
  int clip_right;
-  uint32_t yuy2;
+  union {
+    uint32_t value;
+    uint8_t  b[4];
+    uint16_t h[2];
+  } yuy2;
+  uint8_t clr = 0;
+  int any_line_buffered = 0;
+  int exact_blend_width = ((src_width <= (dst_width - x_off)) ? src_width : (dst_width - x_off));
+  int exact_blend_width_m2 = (x_odd + exact_blend_width + 1) & ~1; /* make it a (larger) multiple of 2 */
+  uint8_t *(*blend_yuy2_data)[ 3 ] = 0;
  
-  uint8_t *dst_y = dst_img + 2 * (dst_width * y_off + x_off);
+  uint8_t *dst_y = dst_img + dst_pitch * y_off + 2 * x_off;
  uint8_t *dst;
  my_clut = (clut_t*) img_overl->clip_color;
  my_trans = img_overl->clip_trans;
  /* avoid wraping overlay if drawing to small image */
-  if( (x_off + img_overl->clip_right) < dst_width )
+  if( (x_off + img_overl->clip_right) <= dst_width )
    clip_right = img_overl->clip_right;
  else
-    clip_right = dst_width - 1 - x_off;
+    clip_right = dst_width - x_off;
  /* avoid buffer overflow */
-  if( (src_height + y_off) >= dst_height )
+  if( (src_height + y_off) > dst_height )
-    src_height = dst_height - 1 - y_off;
+    src_height = dst_height - y_off;
+  if (src_height <= 0)
+    return;
+  if (enable_exact_blending) {
+    if (exact_blend_width <= 0)
+      return;
+    
+    blend_yuy2_data = blend_yuy2_grow_extra_data(extra_data, exact_blend_width_m2);
+    if (!blend_yuy2_data)
+      return;
+    
+    /* make linebuffer transparent */
+    memset(&(*blend_yuy2_data)[ 0 ][ 0 ], 0, exact_blend_width_m2);
+  }
+  rlelen=rle_remainder=0;
  for (y = 0; y < src_height; y++) {
-    mask = !(img_overl->clip_top > y || img_overl->clip_bottom < y);
+    if (rle >= rle_limit)
+      break;
+    
+    ymask = ((y < img_overl->clip_top) || (y >= img_overl->clip_bottom));
    dst = dst_y;
    for (x = 0; x < src_width;) {
-      uint8_t clr;
      uint16_t o;
-      int rlelen;
-      clr = rle->color;
+      if (rle >= rle_limit)
-      o   = my_trans[clr];
+        break;
-      rlelen = rle->len;
+    
+      if ((rlelen < 0) || (rle_remainder < 0)) {
-      if (o && mask) {
+#ifdef LOG_BLEND_YUV
-        /* threat cases where clipping border is inside rle->len pixels */
+        printf("alphablend: major bug in blend_yuv < 0\n");
-        if ( img_overl->clip_left > x ) {
+#endif
-          if( img_overl->clip_left < x + rlelen ) {
+      } 
-            rlelen -= img_overl->clip_left - x;
+      if (rlelen == 0) {
-            x += img_overl->clip_left - x;
+        rle_remainder = rlelen = rle->len;
+        clr = rle->color;
+        rle++;
+      }
+      if (rle_remainder == 0) {
+        rle_remainder = rlelen;
+      }
+      if ((rle_remainder + x) > src_width) {
+        /* Do something for long rlelengths */
+        rle_remainder = src_width - x;
+      }
+#ifdef LOG_BLEND_YUV
+      printf("2:rle_len=%d, remainder=%d, x=%d\n",rlelen, rle_remainder, x);
+#endif
+      if (ymask == 0) {
+        if (x < img_overl->clip_left) { 
+          /* Starts outside clip area */
+          if ((x + rle_remainder) > img_overl->clip_left ) {
+#ifdef LOG_BLEND_YUV
+            printf("Outside clip left %d, ending inside\n", img_overl->clip_left); 
+#endif
+            /* Cutting needed, starts outside, ends inside */
+            rle_this_bite = (img_overl->clip_left - x);
+            rle_remainder -= rle_this_bite;
+            rlelen -= rle_this_bite;
+            my_clut = (clut_t*) img_overl->color;
+            my_trans = img_overl->trans;
          } else {
-            o = 0;
+#ifdef LOG_BLEND_YUV
+            printf("Outside clip left %d, ending outside\n", img_overl->clip_left); 
+#endif
+          /* no cutting needed, starts outside, ends outside */
+            rle_this_bite = rle_remainder;
+            rle_remainder = 0;
+            rlelen -= rle_this_bite;
+            my_clut = (clut_t*) img_overl->color;
+            my_trans = img_overl->trans;
          }
-        } else if( clip_right < x + rlelen ) {
+        } else if (x < clip_right) {
-          if( clip_right > x ) {
+          /* Starts inside clip area */
-            /* fixme: case not implemented */
+          if ((x + rle_remainder) > clip_right ) {
-            o = 0;            
+#ifdef LOG_BLEND_YUV
+            printf("Inside clip right %d, ending outside\n", clip_right);
+#endif
+            /* Cutting needed, starts inside, ends outside */
+            rle_this_bite = (clip_right - x);
+            rle_remainder -= rle_this_bite;
+            rlelen -= rle_this_bite;
+            my_clut = (clut_t*) img_overl->clip_color;
+            my_trans = img_overl->clip_trans;
          } else {
-            o = 0;
+#ifdef LOG_BLEND_YUV
+            printf("Inside clip right %d, ending inside\n", clip_right);
+#endif
+          /* no cutting needed, starts inside, ends inside */
+            rle_this_bite = rle_remainder;
+            rle_remainder = 0;
+            rlelen -= rle_this_bite;
+            my_clut = (clut_t*) img_overl->clip_color;
+            my_trans = img_overl->clip_trans;
          }
-        } 
+        } else if (x >= clip_right) {
+          /* Starts outside clip area, ends outsite clip area */
+          if ((x + rle_remainder ) > src_width ) { 
+#ifdef LOG_BLEND_YUV
+            printf("Outside clip right %d, ending eol\n", clip_right);
+#endif
+            /* Cutting needed, starts outside, ends at right edge */
+            /* It should never reach here due to the earlier test of src_width */
+            rle_this_bite = (src_width - x );
+            rle_remainder -= rle_this_bite;
+            rlelen -= rle_this_bite;
+            my_clut = (clut_t*) img_overl->color;
+            my_trans = img_overl->trans;
+          } else {
+          /* no cutting needed, starts outside, ends outside */
+#ifdef LOG_BLEND_YUV
+            printf("Outside clip right %d, ending outside\n", clip_right);
+#endif
+            rle_this_bite = rle_remainder;
+            rle_remainder = 0;
+            rlelen -= rle_this_bite;
+            my_clut = (clut_t*) img_overl->color;
+            my_trans = img_overl->trans;
+          }
+        }
+      } else {
+        /* Outside clip are due to y */
+        /* no cutting needed, starts outside, ends outside */
+        rle_this_bite = rle_remainder;
+        rle_remainder = 0;
+        rlelen -= rle_this_bite;
+        my_clut = (clut_t*) img_overl->color;
+        my_trans = img_overl->trans;
      }
-      
+      o   = my_trans[clr];
+      if (x < (dst_width - x_off)) {
+        /* clip against right edge of destination area */
+        if ((x + rle_this_bite) > (dst_width - x_off)) {
+          int toClip = (x + rle_this_bite) - (dst_width - x_off);
+          
+          rle_this_bite -= toClip;
+          rle_remainder += toClip;
+          rlelen += toClip;
+        }
+        if (enable_exact_blending) {
+          /* remember opacity of current line */
+          memset(&(*blend_yuy2_data)[ 0 ][ x + x_odd ], o, rle_this_bite);
+          any_line_buffered = 1;
+        }
+        if (o) {
+          if (!enable_exact_blending) {
+            l = rle_this_bite>>1;
+            if( !((x_odd+x) & 1) ) {
+              yuy2.b[0] = my_clut[clr].y;
+              yuy2.b[1] = my_clut[clr].cb;
+              yuy2.b[2] = my_clut[clr].y;
+              yuy2.b[3] = my_clut[clr].cr;
+            } else {
+              yuy2.b[0] = my_clut[clr].y;
+              yuy2.b[1] = my_clut[clr].cr;
+              yuy2.b[2] = my_clut[clr].y;
+              yuy2.b[3] = my_clut[clr].cb;
+            }
+          }
+          if (o >= 15) {
+            if (!enable_exact_blending) {
+              while(l--) {
+                *(uint16_t *)dst = yuy2.h[0];
+                dst += 2;
+                *(uint16_t *)dst = yuy2.h[1];
+                dst += 2;
+              }
+              if(rle_this_bite & 1) {
+                *(uint16_t *)dst = yuy2.h[0];
+                dst += 2;
+              }
+            } else {
+              l = rle_this_bite;
+              while (l--) {
+                *dst = my_clut[clr].y;
+                dst += 2;
+              }
+            }
+          } else {
+            if (!enable_exact_blending) {
+              if( l ) {
+                mem_blend32(dst, &yuy2.b[0], o, l);
+                dst += 4*l;
+              }
+              
+              if(rle_this_bite & 1) {
+                *dst = BLEND_BYTE(*dst, yuy2.b[0], o);
+                dst++;
+                *dst = BLEND_BYTE(*dst, yuy2.b[1], o);
+                dst++;
+              }
+            } else {
+              l = rle_this_bite;
+              while (l--) {
+                *dst = BLEND_BYTE(*dst, my_clut[clr].y, o);
+                dst += 2;
+              }
+            }
+          }
-      if (o && mask) {
+          if (enable_exact_blending) {
-        l = rlelen>>1;
+            /* remember chroma of current line */
-        if( !(x & 1) ) {
+            memset(&(*blend_yuy2_data)[ 1 ][ x + x_odd ], my_clut[ clr ].cr, rle_this_bite);
-          yuy2 =  my_clut[clr].y + (my_clut[clr].cb << 8) +
+            memset(&(*blend_yuy2_data)[ 2 ][ x + x_odd ], my_clut[ clr ].cb, rle_this_bite);
-                 (my_clut[clr].y << 16) + (my_clut[clr].cr << 24);
+          }
        } else {
-          yuy2 =  my_clut[clr].y + (my_clut[clr].cr << 8) +
+          dst += rle_this_bite*2;
-                 (my_clut[clr].y << 16) + (my_clut[clr].cb << 24);
        }
+      }
+      
+      x += rle_this_bite;
+    }
+    
+    if (enable_exact_blending) {
+      /* blend buffered line */
+      if (any_line_buffered) {
+        blend_yuy2_exact(dst_y - x_odd * 2 + 3, dst_y - x_odd * 2 + 1, exact_blend_width, x_odd, blend_yuy2_data);
        
-        if (o >= 15) {
+        any_line_buffered = 0;
-          while(l--) {
+      }
-            *((uint32_t *)dst)++ = yuy2;
+    }
+    dst_y += dst_pitch;
+  }
+}
+void clear_xx44_palette(xx44_palette_t *p) 
+{
+  register int i;
+  register uint32_t *cluts = p->cluts;
+  register int *ids = p->lookup_cache;
+  i= p->size;
+  while(i--)
+    *cluts++ = 0;
+  i = 2*OVL_PALETTE_SIZE;
+  while(i--)
+    *ids++ = -1;
+  p->max_used=1; 
+}
+void init_xx44_palette(xx44_palette_t *p, unsigned num_entries) 
+{
+  p->size = (num_entries > XX44_PALETTE_SIZE) ? XX44_PALETTE_SIZE : num_entries; 
+}
+void dispose_xx44_palette(xx44_palette_t *p) 
+{
+}
+static void colorToPalette(const uint32_t *icolor, unsigned char *palette_p,
+                           unsigned num_xvmc_components, char *xvmc_components) 
+{
+  const clut_t *color = (const clut_t *) icolor;
+  int i;
+  for (i=0; i<num_xvmc_components; ++i) {
+    switch(xvmc_components[i]) {
+    case 'V': *palette_p = color->cr; break;
+    case 'U': *palette_p = color->cb; break;
+    case 'Y': 
+    default:  *palette_p = color->y; break;
+    }
+    *palette_p++;
+  }
+}
+void xx44_to_xvmc_palette(const xx44_palette_t *p,unsigned char *xvmc_palette,
+                          unsigned first_xx44_entry, unsigned num_xx44_entries,
+                          unsigned num_xvmc_components, char *xvmc_components) 
+{
+  register int i;
+  register const uint32_t *cluts = p->cluts + first_xx44_entry;
+  for (i=0; i<num_xx44_entries; ++i) {
+    if ((cluts - p->cluts) < p->size) {
+      colorToPalette(cluts++, xvmc_palette, num_xvmc_components, xvmc_components);
+      xvmc_palette += num_xvmc_components;
+    }
+  }
+} 
+static int xx44_paletteIndex(xx44_palette_t *p, int color, uint32_t clut) 
+{
+  register int i;
+  register uint32_t *cluts = p->cluts;
+  register int tmp;
+  if ((tmp = p->lookup_cache[color]) >= 0) 
+    if (cluts[tmp] == clut) return tmp;
+  for (i=0; i<p->max_used; ++i) {
+    if (*cluts++ == clut) return p->lookup_cache[color] = i;
+  }
+  if (p->max_used == p->size -1) {
+    printf("video_out: Warning! Out of xx44 palette colors!\n");
+    return 1;
+  }
+  p->cluts[p->max_used] = clut;
+  return p->lookup_cache[color] = p->max_used++;
+}
+static void memblend_xx44(uint8_t *mem,uint8_t val, register size_t size, uint8_t mask)
+{
+  register uint8_t masked_val = val & mask;
+  while(size--) {
+    if ((*mem & mask) <= masked_val ) *mem = val;
+    mem++;
+  }
+}
+void blend_xx44 (uint8_t *dst_img, vo_overlay_t *img_overl,
+                int dst_width, int dst_height, int dst_pitch, 
+                alphablend_t *extra_data,
+                xx44_palette_t *palette,int ia44) 
+{
+  int  src_width  = img_overl->width;
+  int  src_height = img_overl->height;
+  rle_elem_t *rle        = img_overl->rle;
+  rle_elem_t *rle_limit  = rle + img_overl->num_rle;
+  int mask;
+  int x_off = img_overl->x;
+  int y_off = img_overl->y;
+  int x, y;
+  uint8_t norm_pixel,clip_pixel;  
+  uint8_t *dst_y;
+  uint8_t *dst;
+  uint8_t alphamask = (ia44) ? 0x0F : 0xF0;
+  int clip_right;
+  if (!img_overl)
+    return;
+  dst_y = dst_img + dst_pitch*y_off + x_off;
+  if( (x_off + img_overl->width) <= dst_width )
+    clip_right = img_overl->width;
+  else
+    clip_right = dst_width - x_off;
+  if ((src_height + y_off) > dst_height)
+    src_height = dst_height - y_off;
+  for (y = 0; y < src_height; y++) {
+    mask = !(y < img_overl->clip_top || y >= img_overl->clip_bottom);
+    dst = dst_y;
+    for (x = 0; x < src_width;) {
+      int len = (x + rle->len > clip_right) ? clip_right - x : rle->len;
+      if (len > 0) {
+        norm_pixel = (uint8_t)((xx44_paletteIndex(palette,rle->color,
+                                             img_overl->color[rle->color]) << 4) | 
+                               (img_overl->trans[rle->color] & 0x0F));
+        clip_pixel = (uint8_t)((xx44_paletteIndex(palette,rle->color+OVL_PALETTE_SIZE,
+                                             img_overl->clip_color[rle->color]) << 4) | 
+                               (img_overl->clip_trans[rle->color] & 0x0F));
+        if (!ia44) {
+          norm_pixel = ((norm_pixel & 0x0F) << 4) | ((norm_pixel & 0xF0) >> 4);
+          clip_pixel = ((clip_pixel & 0x0F) << 4) | ((clip_pixel & 0xF0) >> 4);
+        }
+        if (mask) {
+          if (x < img_overl->clip_left) {
+            if (x + len <= img_overl->clip_left) {
+              memblend_xx44(dst,norm_pixel,len, alphamask);
+              dst += len;
+            } else {
+              memblend_xx44(dst,norm_pixel,img_overl->clip_left -x, alphamask);
+              dst += img_overl->clip_left - x;
+              len -= img_overl->clip_left - x;
+              if (len <= img_overl->clip_right - img_overl->clip_left) {
+                memblend_xx44(dst,clip_pixel,len, alphamask);
+                dst += len;
+              } else {
+                memblend_xx44(dst,clip_pixel,img_overl->clip_right - img_overl->clip_left,
+                              alphamask);
+                dst += img_overl->clip_right - img_overl->clip_left;
+                len -= img_overl->clip_right - img_overl->clip_left;
+                memblend_xx44(dst,norm_pixel,len, alphamask);
+                dst += len;
+              }
+            }
+          } else if (x < img_overl->clip_right) {  
+            if (len <= img_overl->clip_right - x) {
+              memblend_xx44(dst,clip_pixel,len, alphamask);
+              dst += len;
+            } else {
+              memblend_xx44(dst,clip_pixel,img_overl->clip_right - x,alphamask);
+              dst += img_overl->clip_right - x;
+              len -= img_overl->clip_right - x;
+              memblend_xx44(dst,norm_pixel,len, alphamask);
+              dst += len;
+            }
+          } else {
+            memblend_xx44(dst,norm_pixel,len, alphamask);
+            dst += len;
          }
-          if(rlelen & 1)
-            *((uint16_t *)dst)++ = yuy2 & 0xffff;
        } else {
-          if( l ) {
+          memblend_xx44(dst,norm_pixel,len, alphamask);
-            mem_blend32(dst, (uint8_t *)&yuy2, o, l);
+          dst += len;
-            dst += 4*l;
-          }
-          
-          if(rlelen & 1) {
-            *dst = BLEND_BYTE(*dst, *((uint8_t *)&yuy2), o);
-            dst++;
-            *dst = BLEND_BYTE(*dst, *((uint8_t *)&yuy2+1), o);
-            dst++;
-          }
        }
-      } else {
-        dst += rlelen*2;
      }
+      x += rle->len;
-      x += rlelen;
      rle++;
      if (rle >= rle_limit) break;
-    }
+    }  
    if (rle >= rle_limit) break;
+    dst_y += dst_pitch;
+  }
+}
+static void alphablend_disable_exact_osd_alpha_blending_changed(void *user_data, xine_cfg_entry_t *entry)
+{
+  alphablend_t *extra_data = (alphablend_t *)user_data;
+  extra_data->disable_exact_blending = entry->num_value;
+}
-    dst_y += dst_width*2;
+void _x_alphablend_init(alphablend_t *extra_data, xine_t *xine)
+{
+  config_values_t *config = xine->config;
+  
+  extra_data->buffer = 0;
+  extra_data->buffer_size = 0;
+  extra_data->disable_exact_blending =
+    config->register_bool(config, "video.output.disable_exact_alphablend", 0,
+      _("disable exact alpha blending of overlays"),
+      _("If you experience a performance impact when an On Screen Display or other "
+        "overlays like DVD subtitles are active, then you might want to enable this option.\n"
+        "The result is that alpha blending of overlays is less accurate than before, "
+        "but the CPU usage will be decreased as well."),
+      10, alphablend_disable_exact_osd_alpha_blending_changed, extra_data);
+}
+void _x_alphablend_free(alphablend_t *extra_data)
+{
+  if (extra_data->buffer) {
+    free(extra_data->buffer);
+    extra_data->buffer = NULL;
  }
+  extra_data->buffer_size = 0;
 }
diff --git a/noncore/multimedia/opieplayer2/alphablend.h b/noncore/multimedia/opieplayer2/alphablend.h
index 7230f41..1edb5ba 100644
--- a/noncore/multimedia/opieplayer2/alphablend.h
+++ b/noncore/multimedia/opieplayer2/alphablend.h
@@ -1,57 +1,134 @@
 /*
 *
 * Copyright (C) 2000  Thomas Mirlacher
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
 *
 * The author may be reached as <dent@linuxvideo.org>
 *
 *------------------------------------------------------------
 *
 */
 #ifndef __ALPHABLEND_H__
 #define __ALPHABLEND_H__
 #include <xine/video_out.h>
+typedef struct {
+  void *buffer;
+  int buffer_size;
+  int disable_exact_blending;
+} alphablend_t;
+void _x_alphablend_init(alphablend_t *extra_data, xine_t *xine);
+void _x_alphablend_free(alphablend_t *extra_data);
+/* _MSC_VER port changes */
+#undef ATTRIBUTE_PACKED
+#undef PRAGMA_PACK_BEGIN 
+#undef PRAGMA_PACK_END
+#if __GNUC__ > 2 || (__GNUC__ == 2 && __GNUC_MINOR__ >= 95) || defined(__ICC)
+#define ATTRIBUTE_PACKED __attribute__ ((packed))
+#define PRAGMA_PACK 0
+#endif
+#if !defined(ATTRIBUTE_PACKED)
+#define ATTRIBUTE_PACKED
+#define PRAGMA_PACK 1
+#endif
+#if PRAGMA_PACK
+#pragma pack(8)
+#endif
 typedef struct {         /* CLUT == Color LookUp Table */
  uint8_t cb    : 8;
  uint8_t cr    : 8;
  uint8_t y     : 8;
  uint8_t foo   : 8;
-} __attribute__ ((packed)) clut_t;
+} ATTRIBUTE_PACKED clut_t;
+#if PRAGMA_PACK
+#pragma pack()
+#endif
+#define XX44_PALETTE_SIZE 32
+typedef struct {
+  unsigned size;
+  unsigned max_used;
+  uint32_t cluts[XX44_PALETTE_SIZE];
+  /* cache palette entries for both colors and clip_colors */
+  int lookup_cache[OVL_PALETTE_SIZE*2];
+} xx44_palette_t;
 void blend_rgb16 (uint8_t * img, vo_overlay_t * img_overl,
                  int img_width, int img_height,
-                  int dst_width, int dst_height);
+                  int dst_width, int dst_height,
+                  alphablend_t *extra_data);
 void blend_rgb24 (uint8_t * img, vo_overlay_t * img_overl,
                  int img_width, int img_height,
-                  int dst_width, int dst_height);
+                  int dst_width, int dst_height,
+                  alphablend_t *extra_data);
 void blend_rgb32 (uint8_t * img, vo_overlay_t * img_overl,
                  int img_width, int img_height,
-                  int dst_width, int dst_height);
+                  int dst_width, int dst_height,
+                  alphablend_t *extra_data);
 void blend_yuv (uint8_t *dst_base[3], vo_overlay_t * img_overl,
-                int dst_width, int dst_height);
+                int dst_width, int dst_height, int dst_pitches[3],
+                alphablend_t *extra_data);
 void blend_yuy2 (uint8_t * dst_img, vo_overlay_t * img_overl,
-                int dst_width, int dst_height);
+                 int dst_width, int dst_height, int dst_pitch,
+                 alphablend_t *extra_data);
+/*
+ * This function isn't too smart about blending. We want to avoid creating new
+ * colors in the palette as a result from two non-zero colors needed to be
+ * blended. Instead we choose the color with the highest alpha value to be
+ * visible. Some parts of the code taken from the "VeXP" project.
+ */
+void blend_xx44 (uint8_t *dst_img, vo_overlay_t *img_overl,
+                int dst_width, int dst_height, int dst_pitch, 
+                alphablend_t *extra_data,
+                xx44_palette_t *palette,int ia44);
+/*
+ * Functions to handle the xine-specific palette.
+ */
+void clear_xx44_palette(xx44_palette_t *p);
+void init_xx44_palette(xx44_palette_t *p, unsigned num_entries);
+void dispose_xx44_palette(xx44_palette_t *p);
+/*
+ * Convert the xine-specific palette to something useful.
+ */
+void xx44_to_xvmc_palette(const xx44_palette_t *p,unsigned char *xvmc_palette,
+                          unsigned first_xx44_entry, unsigned num_xx44_entries,
+                          unsigned num_xvmc_components, char *xvmc_components);
-void crop_overlay (vo_overlay_t * overlay);
 #endif
diff --git a/noncore/multimedia/opieplayer2/lib.cpp b/noncore/multimedia/opieplayer2/lib.cpp
index 4ae8490..84d28ce 100644
--- a/noncore/multimedia/opieplayer2/lib.cpp
+++ b/noncore/multimedia/opieplayer2/lib.cpp
@@ -1,471 +1,491 @@
 /*
                    This file is part of the Opie Project
                      Copyright (c)  2002 Max Reiss <harlekin@handhelds.org>
                             Copyright (c)  2002 LJP <>
                             Copyright (c)  2002 Holger Freyther <zecke@handhelds.org>
              =.
            .=l.
     .>+-=
 _;:,   .>  :=|.         This program is free software; you can
 .> <`_,  > .  <=          redistribute it and/or  modify it under
 :`=1 )Y*s>-.--  :           the terms of the GNU General Public
 .="- .-=="i,   .._         License as published by the Free Software
 - .  .-<_>   .<>         Foundation; either version 2 of the License,
  ._= =}    :          or (at your option) any later version.
  .%`+i>    _;_.
  .i_,=:_.   -<s.       This program is distributed in the hope that
  + . -:.    =       it will be useful,  but WITHOUT ANY WARRANTY;
  : ..  .:,   . . .    without even the implied warranty of
  =_    +   =;=|`    MERCHANTABILITY or FITNESS FOR A
 _.=:.    :  :=>`:     PARTICULAR PURPOSE. See the GNU
 ..}^=.=    =    ;      Library General Public License for more
 ++=  -.   .`   .:       details.
 :   = ...= . :.=-
 -.  .:....=;==+<;          You should have received a copy of the GNU
 -_. . .  )=. =           Library General Public License along with
  --    :-=`           this library; see the file COPYING.LIB.
                             If not, write to the Free Software Foundation,
                             Inc., 59 Temple Place - Suite 330,
                             Boston, MA 02111-1307, USA.
 */
 #include "xinevideowidget.h"
 #include "lib.h"
 /* OPIE */
 #include <opie2/odebug.h>
 #include <qpe/global.h>
 /* QT */
 #include <qtextstream.h>
 #include <qdir.h>
 #include <qgfx_qws.h>
 /* STD */
 #include <assert.h>
 #include <unistd.h>
 typedef void (*display_xine_frame_t) (void *user_data, uint8_t* frame,
                      int  width, int height,int bytes );
+typedef void (*vo_scale_cb) (void*, int, int, double,
+                             int*, int*, int*, int*, double*, int*, int* );
+typedef void (*dest_size_cb) (void*, int, int, double, int*, int*, double*);
 extern "C" {
-    xine_vo_driver_t* init_video_out_plugin( xine_t *xine, void* video, display_xine_frame_t, void * );
+    xine_vo_driver_t* init_video_out_plugin( xine_t *xine, void* video, display_xine_frame_t, void *, vo_scale_cb,  dest_size_cb );
    int null_is_showing_video( const xine_vo_driver_t* self );
    void null_set_show_video( const xine_vo_driver_t* self, int show );
-    int null_is_fullscreen( const xine_vo_driver_t* self );
-    void null_set_fullscreen( const xine_vo_driver_t* self, int screen );
-    int null_is_scaling( const xine_vo_driver_t* self );
-    void null_set_scaling( const xine_vo_driver_t* self, int scale );
-    void null_set_gui_width( const xine_vo_driver_t* self, int width );
-    void null_set_gui_height( const xine_vo_driver_t* self, int height );
    void null_set_mode( const xine_vo_driver_t* self, int depth,  int rgb  );
-    void null_set_videoGamma( const  xine_vo_driver_t* self , int value );
    void null_display_handler( const xine_vo_driver_t* self, display_xine_frame_t t, void* user_data );
-    void null_preload_decoders( xine_stream_t *stream );
 }
 using namespace XINE;
 Lib::Lib( InitializationMode initMode, XineVideoWidget* widget )
 {
    m_initialized = false;
    m_duringInitialization = false;
    m_video = false;
    m_wid = widget;
    printf("Lib");
    QString configPath = QDir::homeDirPath() + "/Settings/opiexine.cf";
    // get the configuration
    // not really OO, should be an extra class, later
    if ( !QFile::exists(configPath) ) {
        QFile f(configPath);
        f.open(IO_WriteOnly);
        QTextStream ts( &f );
        ts << "misc.memcpy_method:glibc\n";
        ts << "# uncomment if you experience double speed audio \n #audio.oss_sync_method:softsync\n";
        ts << "codec.ffmpeg_pp_quality:3\n";
        ts << "audio.num_buffers:50\n";
        ts << "audio.size_buffers:4096\n";
        ts << "video.num_buffers:20\n";
        ts << "video.size_buffers:4096\n";
        ts << "audio.out_num_audio_buf:16\n";
        ts << "audio.out_size_audio_buf:8096\n";
        ts << "audio.out_size_zero_buf:1024\n";
        ts << "audio.passthrough_offset:0\n";
        f.close();
    }
    if ( initMode == InitializeImmediately ) {
        initialize();
        m_initialized = true;
    }
    else
        start();
 }
 void Lib::run()
 {
    odebug << "Lib::run() started" << oendl;
    initialize();
    m_initialized = true;
    odebug << "Lib::run() finished" << oendl;
 }
 void Lib::initialize()
 {
    m_duringInitialization = true;
    m_xine =  xine_new( );
    QString configPath = QDir::homeDirPath() + "/Settings/opiexine.cf";
    xine_config_load( m_xine, QFile::encodeName( configPath ) );
    xine_init( m_xine );
    // allocate oss for sound
    // and fb for framebuffer
    m_audioOutput = xine_open_audio_driver( m_xine,  "oss", NULL );
-    m_videoOutput = ::init_video_out_plugin( m_xine, NULL, xine_display_frame, this );
+    m_videoOutput = ::init_video_out_plugin( m_xine, NULL,
+                                             xine_display_frame, this,
+                                             xine_vo_scale_cb,
+                                             xine_dest_cb );
    m_stream = xine_stream_new (m_xine,  m_audioOutput,  m_videoOutput );
    xine_set_param( m_stream, XINE_PARAM_AUDIO_CLOSE_DEVICE, 1);
    if (m_wid != 0 )
        setWidget( m_wid );
    m_queue = xine_event_new_queue (m_stream);
    xine_event_create_listener_thread (m_queue, xine_event_handler, this);
-    ::null_preload_decoders( m_stream );
    m_duringInitialization = false;
 }
 Lib::~Lib() {
    assert( isRunning() == false );
    assert( m_initialized );
 //    free( m_config );
    xine_close( m_stream );
    xine_event_dispose_queue( m_queue );
    xine_dispose( m_stream );
    xine_close_audio_driver(m_xine,m_audioOutput);
    xine_close_video_driver(m_xine,m_videoOutput);
    xine_exit( m_xine );
    /* FIXME either free or delete but valgrind bitches against both */
    //free( m_videoOutput );
    //delete m_audioOutput;
 }
 void Lib::resize ( const QSize &s ) {
    assert( m_initialized || m_duringInitialization );
-    if ( s. width ( ) && s. height ( ) ) {
+    if ( s. width ( ) && s. height ( ) )
-        ::null_set_gui_width( m_videoOutput,  s. width() );
+        m_videoSize = s;
-        ::null_set_gui_height( m_videoOutput,  s. height() );
-    }
 }
 int Lib::majorVersion() {
     int major, minor, sub;
     xine_get_version ( &major, &minor, &sub );
     return major;
 }
 int Lib::minorVersion() {
     int major, minor, sub;
     xine_get_version ( &major, &minor, &sub );
     return minor;
 }
 int Lib::subVersion() {
     int major, minor, sub;
     xine_get_version ( &major, &minor, &sub );
     return sub;
 }
 int Lib::setfile(const QString& fileName)
 {
    QString str = fileName.stripWhiteSpace();
    if ( !xine_open( m_stream, str.utf8().data() ) ) {
         return 0;
    }
    return 1;
 }
 int Lib::play( const QString& fileName, int startPos, int start_time ) {
    assert( m_initialized );
    QString str = fileName.stripWhiteSpace();
    if ( !xine_open( m_stream, str.utf8().data() ) ) {
         return 0;
    }
    return xine_play( m_stream, startPos, start_time);
 }
 void Lib::stop() {
    assert( m_initialized );
    xine_stop( m_stream );
    xine_set_param( m_stream, XINE_PARAM_AUDIO_CLOSE_DEVICE, 1);
 }
 void Lib::pause( bool toggle ) {
    assert( m_initialized );
    if ( toggle ) {
        xine_set_param( m_stream, XINE_PARAM_SPEED, XINE_SPEED_PAUSE );
        xine_set_param( m_stream, XINE_PARAM_AUDIO_CLOSE_DEVICE, 1);
    }
    else {
        xine_set_param( m_stream, XINE_PARAM_SPEED, XINE_SPEED_NORMAL );
    }
 }
 int Lib::speed() const {
    assert( m_initialized );
    return  xine_get_param ( m_stream, XINE_PARAM_SPEED );
 }
 void Lib::setSpeed( int speed ) {
    assert( m_initialized );
    xine_set_param ( m_stream, XINE_PARAM_SPEED, speed );
 }
 int Lib::status() const {
    assert( m_initialized );
    return xine_get_status( m_stream );
 }
 int Lib::currentPosition() const {
    assert( m_initialized );
    int pos, time, length;
    xine_get_pos_length( m_stream, &pos, &time, &length );
    return pos;
 }
 int Lib::currentTime() const {
    assert( m_initialized );
    int pos, time, length;
    pos = time = length = 0;
    if ( xine_get_pos_length( m_stream, &pos, &time, &length ) )
        return time/1000;
    else
        return 0;
 }
 int Lib::length() const {
      assert( m_initialized );
      int pos, time, length;
 /* dilb: patch to solve the wrong stream length reported to the GUI*/
      int iRetVal=0, iTestLoop=0;
      do
        {
    iRetVal = xine_get_pos_length( m_stream, &pos, &time, &length );
    if (iRetVal)
       {/* if the function didn't return 0, then pos, time and length are valid.*/
       return length/1000;
       }
    /*don't poll too much*/
    usleep(100000);
    iTestLoop++;
    }
      while ( iTestLoop < 10 ); /* if after 1s, we still don't have any
 valid stream, then return -1 (this value could be used to make the stream
 unseekable, but it should never occur!! Mr. Murphy ? :) ) */
      return -1;
 }
 /* info about current stream */
 QSize Lib::videoSize()const
 {
    if (!m_initialized||!hasVideo()) return QSize(0,0);
    int width = xine_get_stream_info(m_stream,XINE_STREAM_INFO_VIDEO_WIDTH);
    int height = xine_get_stream_info(m_stream,XINE_STREAM_INFO_VIDEO_HEIGHT);
    return QSize(width,height);
 }
 bool Lib::isSeekable() const {
    assert( m_initialized );
    return xine_get_stream_info( m_stream, XINE_STREAM_INFO_SEEKABLE );
 }
 bool Lib::hasVideo() const {
    assert( m_initialized );
    return  xine_get_stream_info( m_stream, XINE_STREAM_INFO_HAS_VIDEO);
 }
 int Lib::audioBitrate()const
 {
    if (!m_initialized) return 0;
    return  xine_get_stream_info( m_stream, XINE_STREAM_INFO_AUDIO_BITRATE);
 }
 int Lib::videoBitrate()const
 {
    if (!m_initialized||!hasVideo()) return 0;
    return  xine_get_stream_info( m_stream, XINE_STREAM_INFO_VIDEO_BITRATE);
 }
 /* end info block */
 void Lib::seekTo( int time ) {
    assert( m_initialized );
    odebug << "Seeking to second " << time << oendl;
    //Keep it paused if it was in that state
    if ( xine_get_param( m_stream, XINE_PARAM_SPEED ) ) {
        xine_play( m_stream, 0, time*1000 );
    }
    else {
        xine_play( m_stream, 0, time*1000 );
        xine_set_param( m_stream, XINE_PARAM_SPEED, XINE_SPEED_PAUSE );
    }
 }
 QString Lib::metaInfo( int number) const {
    assert( m_initialized );
    return xine_get_meta_info( m_stream, number );
 }
 int Lib::error() const {
    assert( m_initialized );
    return xine_get_error( m_stream );
 };
 void Lib::ensureInitialized()
 {
    if ( m_initialized )
        return;
    odebug << "waiting for initialization thread to finish" << oendl;
    wait();
    odebug << "initialization thread finished!" << oendl;
 }
 void Lib::setWidget( XineVideoWidget *widget )
 {
    m_wid = widget;
    if (m_wid) {
        resize ( m_wid-> size ( ) );
        ::null_set_mode( m_videoOutput, qt_screen->depth(), qt_screen->pixelType() );
    }
 }
 void Lib::receiveMessage( ThreadUtil::ChannelMessage *msg, SendType sendType )
 {
    assert( sendType == ThreadUtil::Channel::OneWay );
    handleXineEvent( msg->type(), msg->data(), msg->msg() );
    delete msg;
 }
 void Lib::handleXineEvent( const xine_event_t* t ) {
    int prog = -1; const char* name = 0;
    if ( t->type == XINE_EVENT_PROGRESS ) {
        xine_progress_data_t *pt = static_cast<xine_progress_data_t*>( t->data );
        prog = pt->percent;
        name = pt->description;
    }
    send( new ThreadUtil::ChannelMessage( t->type, prog, name ),  OneWay );
 }
 void Lib::handleXineEvent( int type, int data, const char* name ) {
    assert( m_initialized );
    if ( type == XINE_EVENT_UI_PLAYBACK_FINISHED ) {
        emit stopped();
    }else if ( type == XINE_EVENT_PROGRESS ) {
        QString str = name == 0 ? QString::null : QString::fromUtf8( name );
        Global::statusMessage( tr( "Progress: %1 %2" ).arg( name, data ) );;
    }
 }
 void Lib::setShowVideo( bool video ) {
    assert( m_initialized );
    m_video = video;
    ::null_set_show_video( m_videoOutput, video );
 }
 bool Lib::isShowingVideo() const {
    assert( m_initialized );
    return ::null_is_showing_video( m_videoOutput );
 }
 void Lib::showVideoFullScreen( bool fullScreen ) {
    assert( m_initialized );
-    ::null_set_fullscreen( m_videoOutput, fullScreen );
+    #warning use xine
 }
 bool Lib::isVideoFullScreen() const {
    assert( m_initialized );
-    return ::null_is_fullscreen( m_videoOutput );
+    #warning use xine
+    return false;
 }
 void Lib::setScaling( bool scale ) {
    assert( m_initialized );
-    ::null_set_scaling( m_videoOutput, scale );
+    xine_set_param( m_stream, XINE_PARAM_VO_ASPECT_RATIO,
+                    scale ? XINE_VO_ASPECT_AUTO : XINE_VO_ASPECT_SQUARE );
 }
 void Lib::setGamma( int value ) {
    assert( m_initialized );
+    xine_set_param( m_stream, XINE_PARAM_VO_BRIGHTNESS, value );
-   ::null_set_videoGamma( m_videoOutput, value );
 }
 bool Lib::isScaling() const {
    assert( m_initialized );
-    return ::null_is_scaling( m_videoOutput );
+    int aratio = xine_get_param( m_stream, XINE_PARAM_VO_ASPECT_RATIO );
+    return aratio == XINE_VO_ASPECT_AUTO;
 }
 void Lib::xine_event_handler( void* user_data, const xine_event_t* t ) {
    ( (Lib*)user_data)->handleXineEvent( t );
 }
 void Lib::xine_display_frame( void* user_data, uint8_t *frame,
                              int width,  int height,  int bytes ) {
    ( (Lib*)user_data)->drawFrame( frame, width, height, bytes );
 }
+void Lib::xine_vo_scale_cb( void *user_data, int video_with, int video_height,
+                            double video_pixel_aspect,
+                            int *dest_x, int *dest_y, int *dest_width,
+                            int *dest_height, double *dest_pixel_aspect,
+                            int *win_x, int *win_y ) {
+    QSize size = ((Lib*)user_data)->m_videoSize;
+    if (!size.isValid())
+        return;
+    *dest_x      = 0;
+    *dest_y      = 0;
+    *dest_width  = size.width();
+    *dest_height = size.height();
+    *win_x       = 0;
+    *win_y       = 0;
+}
+void Lib::xine_dest_cb( void* user_data, int, int, double,
+                        int *dest_width, int* dest_height, double* ) {
+    QSize size = ((Lib*)user_data)->m_videoSize;
+    if ( !size.isValid() )
+        return;
+    *dest_width  = size.width();
+    *dest_height = size.height();
+}
 void Lib::drawFrame( uint8_t* frame,  int width,  int height,  int bytes ) {
    assert( m_initialized );
-    if ( !m_video ) {
+    if ( !m_video )
        return;
-    }
-//    assert( m_wid );
    if (m_wid) m_wid-> setVideoFrame ( frame, width, height, bytes );
 }
diff --git a/noncore/multimedia/opieplayer2/lib.h b/noncore/multimedia/opieplayer2/lib.h
index 2607193..a6ac033 100644
--- a/noncore/multimedia/opieplayer2/lib.h
+++ b/noncore/multimedia/opieplayer2/lib.h
@@ -1,215 +1,219 @@
 /*
                    This file is part of the Opie Project
                      Copyright (c)  2002 Max Reiss <harlekin@handhelds.org>
                             Copyright (c)  2002 LJP <>
                             Copyright (c)  2002 Holger Freyther <zecke@handhelds.org>
              =.
            .=l.
     .>+-=
 _;:,   .>  :=|.         This program is free software; you can
 .> <`_,  > .  <=          redistribute it and/or  modify it under
 :`=1 )Y*s>-.--  :           the terms of the GNU General Public
 .="- .-=="i,   .._         License as published by the Free Software
 - .  .-<_>   .<>         Foundation; either version 2 of the License,
  ._= =}    :          or (at your option) any later version.
  .%`+i>    _;_.
  .i_,=:_.   -<s.       This program is distributed in the hope that
  + . -:.    =       it will be useful,  but WITHOUT ANY WARRANTY;
  : ..  .:,   . . .    without even the implied warranty of
  =_    +   =;=|`    MERCHANTABILITY or FITNESS FOR A
 _.=:.    :  :=>`:     PARTICULAR PURPOSE. See the GNU
 ..}^=.=    =    ;      Library General Public License for more
 ++=  -.   .`   .:       details.
 :   = ...= . :.=-
 -.  .:....=;==+<;          You should have received a copy of the GNU
 -_. . .  )=. =           Library General Public License along with
  --    :-=`           this library; see the file COPYING.LIB.
                             If not, write to the Free Software Foundation,
                             Inc., 59 Temple Place - Suite 330,
                             Boston, MA 02111-1307, USA.
 */
 #ifndef XINE_VIDEO_LIB_H
 #define XINE_VIDEO_LIB_H
 #include <xine.h>
 #include "threadutil.h"
 class XineVideoWidget;
 namespace XINE {
    /**
     * Lib wrapps the simple interface
     * of libxine for easy every day use
     * This will become a full C++ Wrapper
     * It supports playing, pausing, info,
     * stooping, seeking.
     */
    class Lib : public ThreadUtil::Channel, private ThreadUtil::Thread
    {
        Q_OBJECT
    public:
        enum InitializationMode { InitializeImmediately, InitializeInThread };
        Lib( InitializationMode initMode, XineVideoWidget* = 0);
        ~Lib();
        static int majorVersion();
        static int minorVersion();
        static int subVersion();
        void resize ( const QSize &s );
        int setfile(const QString& fileName);
        int play( const QString& fileName,
                  int startPos = 0,
                  int start_time = 0 );
        void stop();
        void pause( bool toggle );
        int speed() const;
        /**
         * Set the speed of the stream, if codec supports it
         * XINE_SPEED_PAUSE                   0
         * XINE_SPEED_SLOW_4                  1
         * XINE_SPEED_SLOW_2                  2
         * XINE_SPEED_NORMAL                  4
         * XINE_SPEED_FAST_2                  8
         *XINE_SPEED_FAST_4                  16
         */
        void setSpeed( int speed = XINE_SPEED_PAUSE );
        int status() const;
        int currentPosition()const;
        //in seconds
        int currentTime()const;
        int length() const;
        bool isSeekable()const;
        /**
         * Whether or not to show video output
         */
        void setShowVideo(bool video);
        /**
         * is we show video
         */
        bool isShowingVideo() const;
        /**
         *
         */
        void showVideoFullScreen( bool fullScreen );
        /**
         *
         */
        bool isVideoFullScreen() const;
        /**
         * Get the meta info (like author etc) from the stream
         * XINE_META_INFO_TITLE               0
         * XINE_META_INFO_COMMENT             1
         * XINE_META_INFO_ARTIST              2
         * XINE_META_INFO_GENRE               3
         * XINE_META_INFO_ALBUM               4
         * XINE_META_INFO_YEAR                5
         * XINE_META_INFO_VIDEOCODEC          6
         * XINE_META_INFO_AUDIOCODEC          7
         * XINE_META_INFO_SYSTEMLAYER         8
         * XINE_META_INFO_INPUT_PLUGIN        9
         */
        QString metaInfo( int number ) const;
        /**
         *
         */
        bool isScaling() const;
        /**
         * seek to a position
         */
        void seekTo( int time );
        /**
         *
         * @return is media stream has video
         */
        bool hasVideo() const;
        /**
         *
         */
        void setScaling( bool );
        /**
         * Set the Gamma value for video output
         * @param int the value between -100 and 100, 0 is original
         */
        void setGamma( int );
        /**
         * Returns the error code
         * XINE_ERROR_NONE                    0
         * XINE_ERROR_NO_INPUT_PLUGIN         1
         * XINE_ERROR_NO_DEMUXER_PLUGIN       2
         * XINE_ERROR_DEMUXER_FAILED          3
         */
        int error() const;
        void ensureInitialized();
        void setWidget( XineVideoWidget *widget );
        QSize videoSize()const;
        int audioBitrate()const;
        int videoBitrate()const;
    signals:
        void stopped();
        void initialized();
    protected:
        virtual void receiveMessage( ThreadUtil::ChannelMessage *msg, SendType sendType );
        virtual void run();
    private:
-        void initialize();
+        void initialize();
-        int m_bytes_per_pixel;
+        int m_bytes_per_pixel;
-        bool m_initialized:1;
+        bool m_initialized:1;
-        bool m_duringInitialization:1;
+        bool m_duringInitialization:1;
-        bool m_video:1;
+        bool m_video:1;
-        XineVideoWidget *m_wid;
+        XineVideoWidget *m_wid;
-        xine_t *m_xine;
+        QSize m_videoSize;
-    xine_stream_t *m_stream;
+        xine_t *m_xine;
-        xine_cfg_entry_t *m_config;
+        xine_stream_t *m_stream;
-        xine_vo_driver_t *m_videoOutput;
+        xine_cfg_entry_t *m_config;
-        xine_ao_driver_t* m_audioOutput;
+        xine_vo_driver_t *m_videoOutput;
-    xine_event_queue_t *m_queue;
+        xine_ao_driver_t* m_audioOutput;
+        xine_event_queue_t *m_queue;
-        void handleXineEvent( const xine_event_t* t );
-    void handleXineEvent( int type, int data, const char* name );
+        void handleXineEvent( const xine_event_t* t );
-        void drawFrame( uint8_t* frame, int width, int height, int bytes );
+        void handleXineEvent( int type, int data, const char* name );
+        void drawFrame( uint8_t* frame, int width, int height, int bytes );
        // C -> C++ bridge for the event system
        static void xine_event_handler( void* user_data, const xine_event_t* t);
        static void xine_display_frame( void* user_data, uint8_t* frame ,
-                                        int width, int height, int bytes );
+                                        int width, int height, int bytes );
+        static void xine_vo_scale_cb(void *, int, int, double,
+                                     int*,int*,int*,int*,double*,int*,int*);
+        static void xine_dest_cb(void*,int,int,double,int*,int*,double*);
    };
 };
 #endif
diff --git a/noncore/multimedia/opieplayer2/mainTest.cpp b/noncore/multimedia/opieplayer2/mainTest.cpp
deleted file mode 100644
index e374c89..0000000
--- a/noncore/multimedia/opieplayer2/mainTest.cpp
+++ b/dev/null
@@ -1,16 +0,0 @@
-#include <stdlib.h>
-#include <stdio.h>
-#include <unistd.h>
-#include "lib.h"
-int main( int argc,  char *argv[] ) {
-    printf("FixME\n");
-    //return 0;
-    XINE::Lib lib;
-    QString str = QString::fromLatin1( argv[1] );
-    lib.play( str );
-    for (;;) sleep( 60 );
-    return 0;
-}
diff --git a/noncore/multimedia/opieplayer2/nullvideo.c b/noncore/multimedia/opieplayer2/nullvideo.c
index 6769a37..99fa329 100644
--- a/noncore/multimedia/opieplayer2/nullvideo.c
+++ b/noncore/multimedia/opieplayer2/nullvideo.c
@@ -1,735 +1,695 @@
 /*
 � � � � � � � �             This file is part of the Opie Project
 � � � � � � �                Copyright (c)  2002 Max Reiss <harlekin@handhelds.org>
-                             Copyright (c)  2002 LJP <>
                             Copyright (c)  2002 Holger Freyther <zecke@handhelds.org>
                             Copyright (c)  2002-2003 Miguel Freitas of xine
              =.
            .=l.
 � � � � � �.>+-=
 �_;:, � � .> � �:=|.         This program is free software; you can
 .> <`_, � > �. � <=          redistribute it and/or  modify it under
 :`=1 )Y*s>-.-- � :           the terms of the GNU General Public
 .="- .-=="i, � � .._         License as published by the Free Software
 �- . � .-<_> � � .<>         Foundation; either version 2 of the License,
 � � �._= =} � � � :          or (at your option) any later version.
 � � .%`+i> � � � _;_.
 � � .i_,=:_. � � �-<s.       This program is distributed in the hope that
 � � �+ �. �-:. � � � =       it will be useful,  but WITHOUT ANY WARRANTY;
 � � : .. � �.:, � � . . .    without even the implied warranty of
 � � =_ � � � �+ � � =;=|`    MERCHANTABILITY or FITNESS FOR A
 � _.=:. � � � : � �:=>`:     PARTICULAR PURPOSE. See the GNU
 ..}^=.= � � � = � � � ;      Library General Public License for more
 ++= � -. � � .` � � .:       details.
 �: � � = �...= . :.=-
 �-. � .:....=;==+<;          You should have received a copy of the GNU
 � -_. . . � )=. �=           Library General Public License along with
 � � -- � � � �:-=`           this library; see the file COPYING.LIB.
                             If not, write to the Free Software Foundation,
                             Inc., 59 Temple Place - Suite 330,
                             Boston, MA 02111-1307, USA.
 */
 #include <stdlib.h>
 #include <stdio.h>
 #include <math.h>
 #include <xine.h>
 #include <xine/video_out.h>
 #include <xine/xine_internal.h>
-//#include <xine/xineutils.h>
 #include <xine/vo_scale.h>
 #include <xine/buffer.h>
 #include <pthread.h>
 #include "alphablend.h"
 #include "yuv2rgb.h"
 #define printf(x,...)
 /*
-#define LOG
+ * #define LOG
-*/
+ */
 /* the caller for our event draw handler */
 typedef void (*display_xine_frame_t) (void *user_data, uint8_t* frame,
-              int  width, int height,int bytes );
+                                      int  width, int height,int bytes );
+typedef void (*vo_scale_cb) (void*, int, int, double,
+                             int*, int*, int*, double*, int*, int* );
+typedef void (*dest_size_cb) (void*, int, int, double, int*, int*, double*);
 typedef struct null_driver_s null_driver_t;
 struct null_driver_s {
  vo_driver_t     vo_driver;
-  uint32_t             m_capabilities;
  int                  m_show_video;
  int                  m_video_fullscreen;
-  int                  m_is_scaling;
  int                  depth, bpp, bytes_per_pixel;
  int                  yuv2rgb_mode;
  int                  yuv2rgb_swap;
-  int                  yuv2rgb_gamma;
+  int                  yuv2rgb_brightness;
  uint8_t             *yuv2rgb_cmap;
  yuv2rgb_factory_t   *yuv2rgb_factory;
  vo_overlay_t        *overlay;
-  vo_scale_t           sc;  
+  vo_scale_t           sc;
-  int                  gui_width;
-  int                  gui_height;
-  int                  gui_changed;
-  double               display_ratio;
+  /*
-  void*                caller;
+   * DISPLAY to widget...
+   */
  display_xine_frame_t frameDis;
+  void *userData;
+  xine_t              *xine;
+  alphablend_t         alphablend_extra_data;
 };
 typedef struct opie_frame_s opie_frame_t;
 struct opie_frame_s {
  vo_frame_t         frame;
  int                format;
  int                flags;
  vo_scale_t         sc;
  uint8_t           *chunk[3];
  uint8_t           *data; /* rgb */
  int                bytes_per_line;
  yuv2rgb_t         *yuv2rgb;
  uint8_t           *rgb_dst;
  int                yuv_stride;
  int                stripe_height, stripe_inc;
- 
  null_driver_t     *output;
 };
 static uint32_t null_get_capabilities( vo_driver_t *self ){
-  null_driver_t* this = (null_driver_t*)self;
+    self = self;
-  return this->m_capabilities;
+    return VO_CAP_YUY2 | VO_CAP_YV12;
 }
 static void null_frame_proc_slice (vo_frame_t *vo_img, uint8_t **src) {
  opie_frame_t  *frame = (opie_frame_t *) vo_img ;
  vo_img->proc_called = 1;
-  if (!frame->output->m_show_video) {
+  /*
-    /* printf("nullvideo: no video\n");  */
+   * drop hard if we don't show the video
+   */
+  if (!frame->output->m_show_video)
+    return;
+  if( frame->frame.crop_left  || frame->frame.crop_top ||
+      frame->frame.crop_right || frame->frame.crop_bottom )
+  {
+    /* we don't support crop, so don't even waste cpu cycles.
+     * cropping will be performed by video_out.c
+     */
    return;
  }
  if (frame->format == XINE_IMGFMT_YV12) {
    frame->yuv2rgb->yuv2rgb_fun (frame->yuv2rgb, frame->rgb_dst,
                                 src[0], src[1], src[2]);
  } else {
    frame->yuv2rgb->yuy22rgb_fun (frame->yuv2rgb, frame->rgb_dst,
                                  src[0]);
  }
  frame->rgb_dst += frame->stripe_inc;
 }
 static void null_frame_field (vo_frame_t *vo_img, int which_field) {
  opie_frame_t  *frame = (opie_frame_t *) vo_img ;
  switch (which_field) {
  case VO_TOP_FIELD:
-    frame->rgb_dst    = (uint8_t *)frame->data;
+    frame->rgb_dst    = frame->data;
    frame->stripe_inc = 2*frame->stripe_height * frame->bytes_per_line;
    break;
  case VO_BOTTOM_FIELD:
-    frame->rgb_dst    = (uint8_t *)frame->data + frame->bytes_per_line ;
+    frame->rgb_dst    = frame->data + frame->bytes_per_line ;
    frame->stripe_inc = 2*frame->stripe_height * frame->bytes_per_line;
    break;
  case VO_BOTH_FIELDS:
-    frame->rgb_dst    = (uint8_t *)frame->data;
+    frame->rgb_dst    = frame->data;
    break;
  }
 }
 /* take care of the frame*/
 static void null_frame_dispose( vo_frame_t* vo_img){
  opie_frame_t* frame = (opie_frame_t*)vo_img;
  if (frame->data)
    free( frame->data );
  free (frame);
 }
 /* end take care of frames*/
 static vo_frame_t* null_alloc_frame( vo_driver_t* self ){
  null_driver_t* this = (null_driver_t*)self;
  opie_frame_t* frame;
 #ifdef LOG
  fprintf (stderr, "nullvideo: alloc_frame\n");
 #endif
  frame = (opie_frame_t*)xine_xmalloc ( sizeof(opie_frame_t) );
+  if(!frame)
+      return NULL;
  memcpy (&frame->sc, &this->sc, sizeof(vo_scale_t));
  pthread_mutex_init (&frame->frame.mutex, NULL);
  frame->output = this;
  /* initialize the frame*/
  frame->frame.driver = self;
  frame->frame.proc_slice = null_frame_proc_slice;
+  frame->frame.proc_frame = NULL;
  frame->frame.field = null_frame_field;
  frame->frame.dispose = null_frame_dispose;
  /*
   *    colorspace converter for this frame
   */
  frame->yuv2rgb = this->yuv2rgb_factory->create_converter (this->yuv2rgb_factory);
  return (vo_frame_t*) frame;
 }
-static void null_frame_compute_ideal_size( null_driver_t *this, 
+static void null_frame_compute_ideal_size( null_driver_t *this,
                                           opie_frame_t *frame ) {
    this = this;
    _x_vo_scale_compute_ideal_size(&frame->sc);
 }
 static void null_frame_compute_rgb_size( null_driver_t *this,
                                         opie_frame_t  *frame ){
    this = this;
    _x_vo_scale_compute_output_size(&frame->sc);
    /* avoid problems in yuv2rgb */
    if(frame->sc.output_height < (frame->sc.delivered_height+15) >> 4)
        frame->sc.output_height = (frame->sc.delivered_height+15) >> 4;
    if (frame->sc.output_width < 8)
        frame->sc.output_width = 8;
    /* yuv2rgb_mlib needs an even YUV2 width */
    if (frame->sc.output_width & 1)
        frame->sc.output_width++;
 }
 static void null_frame_reallocate( null_driver_t *this, opie_frame_t *frame,
                                   uint32_t width, uint32_t height, int format){
    /*
     * (re-) allocate
     */
-    if( frame->data ) {
+    if( frame->chunk[0] ){
-      if( frame->chunk[0] ){
+        free( frame->chunk[0] );
-          free( frame->chunk[0] );
+        frame->chunk[0] = NULL;
-          frame->chunk[0] = NULL;
+    }
-      }
+    if( frame->chunk[1] ){
-      if( frame->chunk[1] ){
+        free ( frame->chunk[1] );
-          free ( frame->chunk[1] );
+        frame->chunk[1] = NULL;
-          frame->chunk[1] = NULL;
-      }
-      if( frame->chunk[2] ){
-          free ( frame->chunk[2] );
-          frame->chunk[2] = NULL;
-      }
-      free ( frame->data );
    }
+    if( frame->chunk[2] ){
+        free ( frame->chunk[2] );
+        frame->chunk[2] = NULL;
+    }
+    if(frame->data)
+        free ( frame->data );
-      frame->data = xine_xmalloc (frame->sc.output_width
+    frame->data = xine_xmalloc (frame->sc.output_width
                                * frame->sc.output_height
                                * this->bytes_per_pixel );
    if( format == XINE_IMGFMT_YV12 ) {
      frame->frame.pitches[0] = 8*((width + 7) / 8);
      frame->frame.pitches[1] = 8*((width + 15) / 16);
      frame->frame.pitches[2] = 8*((width + 15) / 16);
      frame->frame.base[0] = xine_xmalloc_aligned (16, frame->frame.pitches[0] * height,(void **)&frame->chunk[0]);
      frame->frame.base[1] = xine_xmalloc_aligned (16, frame->frame.pitches[1] * ((height+ 1)/2), (void **)&frame->chunk[1]);
      frame->frame.base[2] = xine_xmalloc_aligned (16, frame->frame.pitches[2] * ((height+ 1)/2), (void **)&frame->chunk[2]);
    }else{
      frame->frame.pitches[0] = 8*((width + 3) / 4);
      frame->frame.base[0] = xine_xmalloc_aligned (16, frame->frame.pitches[0] * height,
                                                   (void **)&frame->chunk[0]);
      frame->chunk[1] = NULL;
      frame->chunk[2] = NULL;
    }
 }
 static void null_setup_colorspace_converter(opie_frame_t *frame, int flags ) {
    switch (flags) {
        case VO_TOP_FIELD:
        case VO_BOTTOM_FIELD:
            frame->yuv2rgb->configure (frame->yuv2rgb,
                                       frame->sc.delivered_width,
                                       16,
                                       2*frame->frame.pitches[0],
                                       2*frame->frame.pitches[1],
                                       frame->sc.output_width,
                                       frame->stripe_height,
                                       frame->bytes_per_line*2);
            frame->yuv_stride = frame->bytes_per_line*2;
            break;
        case VO_BOTH_FIELDS:
            frame->yuv2rgb->configure (frame->yuv2rgb,
                                       frame->sc.delivered_width,
                                       16,
                                       frame->frame.pitches[0],
                                       frame->frame.pitches[1],
                                       frame->sc.output_width,
                                       frame->stripe_height,
                                       frame->bytes_per_line);
            frame->yuv_stride = frame->bytes_per_line;
            break;
    }
 #ifdef LOG
    fprintf (stderr, "nullvideo: colorspace converter configured.\n");
 #endif
 }
 static void null_update_frame_format( vo_driver_t* self, vo_frame_t* img,
                                      uint32_t width, uint32_t height,
-                                      double ratio_code,  int format, 
+                                      double ratio_code,  int format,
                                      int flags ){
  null_driver_t* this = (null_driver_t*) self;
  opie_frame_t*  frame = (opie_frame_t*)img;
 #ifdef LOG
  fprintf (stderr, "nullvideo: update_frame_format\n");
 #endif
+  int gui_width  = 0;
+  int gui_height = 0;
+  double gui_pixel_aspect = 0.0;
  flags &= VO_BOTH_FIELDS;
-  /* find out if we need to adapt this frame */
+  frame->sc.dest_size_cb(frame->sc.user_data, width, height,
+                         frame->sc.video_pixel_aspect,
+                         &gui_width, &gui_height, &gui_pixel_aspect);
+  /* find out if we need to adapt this frame */
  if ((width != frame->sc.delivered_width)
      || (height != frame->sc.delivered_height)
      || (ratio_code != frame->sc.delivered_ratio)
      || (flags != frame->flags)
      || (format != frame->format)
      || (this->sc.user_ratio != frame->sc.user_ratio)
-      || (this->gui_width != frame->sc.gui_width)
+      || (gui_width  != frame->sc.gui_width)
-      || (this->gui_height != frame->sc.gui_height)) {
+      || (gui_height != frame->sc.gui_height)) {
    frame->sc.delivered_width      = width;
    frame->sc.delivered_height     = height;
    frame->sc.delivered_ratio      = ratio_code;
    frame->flags                   = flags;
    frame->format                  = format;
    frame->sc.user_ratio           = this->sc.user_ratio;
-    frame->sc.gui_width            = this->gui_width;
+    frame->sc.gui_width  = gui_width;
-    frame->sc.gui_height           = this->gui_height;
+    frame->sc.gui_height = gui_height;
-    frame->sc.gui_pixel_aspect     = 1.0;
    null_frame_compute_ideal_size(this, frame);
    null_frame_compute_rgb_size(this, frame);
    null_frame_reallocate(this, frame, width, height, format);
 #ifdef LOG
    fprintf (stderr, "nullvideo: gui %dx%d delivered %dx%d output %dx%d\n",
       frame->sc.gui_width, frame->sc.gui_height,
       frame->sc.delivered_width, frame->sc.delivered_height,
       frame->sc.output_width, frame->sc.output_height);
 #endif
    frame->stripe_height = 16 * frame->sc.output_height / frame->sc.delivered_height;
    frame->bytes_per_line = frame->sc.output_width * this->bytes_per_pixel;
    /*
     * set up colorspace converter
     */
    null_setup_colorspace_converter(frame, flags);
  }
  /*
   * reset dest pointers
   */
    if (frame->data) {
        switch (flags) {
            case VO_TOP_FIELD:
-                frame->rgb_dst    = (uint8_t *)frame->data;
+                frame->rgb_dst    = frame->data;
                frame->stripe_inc = 2 * frame->stripe_height * frame->bytes_per_line;
                break;
            case VO_BOTTOM_FIELD:
-                frame->rgb_dst    = (uint8_t *)frame->data + frame->bytes_per_line ;
+                frame->rgb_dst    = frame->data + frame->bytes_per_line ;
                frame->stripe_inc = 2 * frame->stripe_height * frame->bytes_per_line;
                break;
            case VO_BOTH_FIELDS:
-                frame->rgb_dst    = (uint8_t *)frame->data;
+                frame->rgb_dst    = frame->data;
                frame->stripe_inc = frame->stripe_height * frame->bytes_per_line;
                break;
        }
    }
 }
 static void null_display_frame( vo_driver_t* self, vo_frame_t *frame_gen ){
  null_driver_t* this = (null_driver_t*) self;
  opie_frame_t* frame = (opie_frame_t*)frame_gen;
  display_xine_frame_t display = this->frameDis;
  if (!this->m_show_video)
    return;
  if( display != NULL ) {
-    (*display)(this->caller, frame->data,
+    (*display)(this->userData, frame->data,
               frame->sc.output_width, frame->sc.output_height,
               frame->bytes_per_line );
  }
  frame->frame.free(&frame->frame);
 }
 /* blending related */
 static void null_overlay_clut_yuv2rgb (null_driver_t  *this,
                                       vo_overlay_t *overlay,
                                       opie_frame_t *frame) {
  this = this;
  int i;
  clut_t* clut = (clut_t*) overlay->color;
  if (!overlay->rgb_clut) {
    for (i = 0; i < sizeof(overlay->color)/sizeof(overlay->color[0]); i++) {
      *((uint32_t *)&clut[i]) =
          frame->yuv2rgb->
          yuv2rgb_single_pixel_fun (frame->yuv2rgb,
                                    clut[i].y, clut[i].cb,
                                    clut[i].cr);
    }
    overlay->rgb_clut++;
  }
  if (!overlay->clip_rgb_clut) {
    clut = (clut_t*) overlay->clip_color;
    for (i = 0; i < sizeof(overlay->color)/sizeof(overlay->color[0]); i++) {
      *((uint32_t *)&clut[i]) =
  frame->yuv2rgb->yuv2rgb_single_pixel_fun(frame->yuv2rgb,
                                           clut[i].y, clut[i].cb, clut[i].cr);
    }
    overlay->clip_rgb_clut++;
  }
 }
 static void null_overlay_blend ( vo_driver_t *this_gen, vo_frame_t *frame_gen,
                                 vo_overlay_t *overlay) {
  null_driver_t  *this = (null_driver_t *) this_gen;
  opie_frame_t   *frame = (opie_frame_t *) frame_gen;
  if(!this->m_show_video || frame->sc.output_width == 0
     || frame->sc.output_height== 0)
    return;
  /* Alpha Blend here */
  if (overlay->rle) {
    if( !overlay->rgb_clut || !overlay->clip_rgb_clut)
      null_overlay_clut_yuv2rgb(this,overlay,frame);
    switch(this->bpp) {
        case 16:
-            blend_rgb16((uint8_t *)frame->data,
+            blend_rgb16(frame->data,
                        overlay,
                        frame->sc.output_width,
                        frame->sc.output_height,
                        frame->sc.delivered_width,
-                        frame->sc.delivered_height);
+                        frame->sc.delivered_height,
+                        &this->alphablend_extra_data);
        break;
        case 24:
-            blend_rgb24((uint8_t *)frame->data,
+            blend_rgb24(frame->data,
                        overlay,
                        frame->sc.output_width,
                        frame->sc.output_height,
                        frame->sc.delivered_width,
-                        frame->sc.delivered_height);
+                        frame->sc.delivered_height,
+                        &this->alphablend_extra_data);
        break;
        case 32:
-            blend_rgb32((uint8_t *)frame->data,
+            blend_rgb32(frame->data,
                        overlay,
                        frame->sc.output_width,
                        frame->sc.output_height,
                        frame->sc.delivered_width,
-                        frame->sc.delivered_height);
+                        frame->sc.delivered_height,
+                        &this->alphablend_extra_data);
        break;
        default:
        /* It should never get here */
            break;
    }
  }
 }
 static int null_get_property( vo_driver_t* self, int property ){
-#if 0
  null_driver_t *this = (null_driver_t *)self;
  switch(property)
  {
      case VO_PROP_ASPECT_RATIO:
          return this->sc.user_ratio;
      case VO_PROP_BRIGHTNESS:
          return this->yuv2rgb_brightness;
      case VO_PROP_WINDOW_WIDTH:
          return this->sc.gui_width;
      case VO_PROP_WINDOW_HEIGHT:
          return this->sc.gui_height;
    default:
        break;
  }
-#else
-  property = property;
-  self = self;
-#endif
  return 0;
 }
 static int null_set_property( vo_driver_t* self, int property,
                              int value ){
-#if 0
  null_driver_t *this = (null_driver_t *)self;
  switch(property)
  {
      case VO_PROP_ASPECT_RATIO:
          if(value>=XINE_VO_ASPECT_NUM_RATIOS)
              value = XINE_VO_ASPECT_AUTO;
          this->sc.user_ratio = value;
          break;
      case VO_PROP_BRIGHTNESS:
          this->yuv2rgb_brightness = value;
          this->yuv2rgb_factory->
              set_csc_levels(this->yuv2rgb_factory, value, 128, 128);
          break;
      default:
          break;
  }
-#else
-  self = self;
-  property = property;
-#endif
  return value;
 }
 static void null_get_property_min_max( vo_driver_t* self,
                                       int property, int *min,
                                       int *max ){
-  self = self;
+ if(property == VO_PROP_BRIGHTNESS) {
-  property = property;
+     *min = -100;
+     *max = +100;
-  *max = 0;
+ }else {
-  *min = 0;
+     *min = 0;
+     *max = 0;
+ }
 }
 static int null_gui_data_exchange( vo_driver_t* self,
                                   int data_type,
                                   void *data ){
-  self = self;
-  data_type = data_type;
-  data = data;
  return 0;
 }
 static void null_dispose ( vo_driver_t* self ){
  null_driver_t* this = (null_driver_t*)self;
+  _x_alphablend_free(&this->alphablend_extra_data);
  free ( this );
 }
 static int null_redraw_needed( vo_driver_t* self ){
-    self = self;
+    null_driver_t *this = (null_driver_t*)self;
+    return _x_vo_scale_redraw_needed(&this->sc);
-    return 0;
 }
 xine_video_port_t* init_video_out_plugin( xine_t *xine,
-                                         void* video,
+                                          void* video,
-                                         display_xine_frame_t frameDisplayFunc,
+                                          display_xine_frame_t frameDisplayFunc,
-                                         void *userData ){
+                                          void *userData, vo_scale_cb frame_cb,
-  video = video;
+                                          dest_size_cb dest_cb) {
  null_driver_t *vo;
-  vo = (null_driver_t*)malloc( sizeof(null_driver_t ) );
+  vo = (null_driver_t*)xine_xmalloc(sizeof(null_driver_t ));
+  vo->xine = xine;
-  /* memset? */
-  memset(vo,0, sizeof(null_driver_t ) );
+  _x_alphablend_init(&vo->alphablend_extra_data, xine);
  _x_vo_scale_init (&vo->sc, 0, 0, xine->config);
+  vo->sc.gui_width  = 18;
+  vo->sc.gui_height = 6;
+  vo->sc.user_ratio = XINE_VO_ASPECT_AUTO;
+  vo->sc.user_data  = userData;
+  vo->sc.frame_output_cb = frame_cb;
+  vo->sc.dest_size_cb    = dest_cb;
-  vo->sc.gui_pixel_aspect = 1.0;
  vo->m_show_video = 0; // false
-  vo->m_video_fullscreen = 0;
-  vo->m_is_scaling = 0;
-  vo->display_ratio = 1.0;
-  vo->gui_width = 16;
-  vo->gui_height = 8;
-  vo->frameDis = NULL;
  /* install callback handlers*/
-  vo->vo_driver.get_capabilities      = null_get_capabilities;
+  vo->vo_driver.get_capabilities    = null_get_capabilities;
-  vo->vo_driver.alloc_frame           = null_alloc_frame;
+  vo->vo_driver.alloc_frame         = null_alloc_frame;
-  vo->vo_driver.update_frame_format   = null_update_frame_format;
+  vo->vo_driver.update_frame_format = null_update_frame_format;
-  vo->vo_driver.display_frame         = null_display_frame;
+  vo->vo_driver.display_frame       = null_display_frame;
-  vo->vo_driver.overlay_blend         = null_overlay_blend;
+  vo->vo_driver.overlay_begin       = 0;
-  vo->vo_driver.get_property          = null_get_property;
+  vo->vo_driver.overlay_blend       = null_overlay_blend;
-  vo->vo_driver.set_property          = null_set_property;
+  vo->vo_driver.overlay_end         = 0;
-  vo->vo_driver.get_property_min_max  = null_get_property_min_max;
+  vo->vo_driver.get_property        = null_get_property;
-  vo->vo_driver.gui_data_exchange     = null_gui_data_exchange;
+  vo->vo_driver.set_property        = null_set_property;
-  vo->vo_driver.dispose               = null_dispose;
+  vo->vo_driver.get_property_min_max= null_get_property_min_max;
-  vo->vo_driver.redraw_needed         = null_redraw_needed;
+  vo->vo_driver.gui_data_exchange   = null_gui_data_exchange;
-    
+  vo->vo_driver.dispose             = null_dispose;
+  vo->vo_driver.redraw_needed       = null_redraw_needed;
  /* capabilities */
-  vo->m_capabilities = VO_CAP_YUY2 | VO_CAP_YV12;
+  vo->yuv2rgb_mode       = MODE_16_RGB;
-  vo->yuv2rgb_factory = yuv2rgb_factory_init (MODE_16_RGB, vo->yuv2rgb_swap,
+  vo->yuv2rgb_brightness = 0;
+  vo->yuv2rgb_factory = yuv2rgb_factory_init (vo->yuv2rgb_mode,
+                                              vo->yuv2rgb_swap,
                                              vo->yuv2rgb_cmap);
+  vo->yuv2rgb_factory->set_csc_levels(vo->yuv2rgb_factory,
+                                      vo->yuv2rgb_brightness,
+                                      128,128);
-  vo->caller = userData;
+  vo->userData = userData;
  vo->frameDis = frameDisplayFunc;
  return _x_vo_new_port(xine, &vo->vo_driver, 0);
 }
 /* this is special for this device */
 /**
 * We know that we will be controled by the XINE LIB++
 */
 /**
 *
 */
 int null_is_showing_video( xine_vo_driver_t* self ){
  null_driver_t* this = (null_driver_t*)self->driver;
  return this->m_show_video;
 }
 void null_set_show_video( xine_vo_driver_t* self, int show ) {
  ((null_driver_t*)self->driver)->m_show_video = show;
 }
-int null_is_fullscreen( xine_vo_driver_t* self ){
-  return ((null_driver_t*)self->driver)->m_video_fullscreen;
-}
-void null_set_fullscreen( xine_vo_driver_t* self, int screen ){
-  ((null_driver_t*)self->driver)->m_video_fullscreen = screen;
-}
-int null_is_scaling( xine_vo_driver_t* self ){
-  return ((null_driver_t*)self->driver)->m_is_scaling;
-}
-void null_set_videoGamma( xine_vo_driver_t* self , int value ) {
-  ((null_driver_t*) self->driver) ->yuv2rgb_gamma = value;
-  ((null_driver_t*) self->driver) ->yuv2rgb_factory->set_gamma( ((null_driver_t*) self->driver) ->yuv2rgb_factory, value );
-}
-void null_set_scaling( xine_vo_driver_t* self, int scale ) {
-  ((null_driver_t*)self->driver)->m_is_scaling = scale;
-}
-void null_set_gui_width( xine_vo_driver_t* self, int width ) {
-  ((null_driver_t*)self->driver)->gui_width = width;
-}
-void null_set_gui_height( xine_vo_driver_t* self, int height ) {
-  ((null_driver_t*)self->driver)->gui_height = height;
-}
 void null_set_mode( xine_vo_driver_t* self, int depth,  int rgb  ) {
  null_driver_t* this = (null_driver_t*)self->driver;
  this->bytes_per_pixel = (depth + 7 ) / 8;
  this->bpp = this->bytes_per_pixel * 8;
  this->depth = depth;
- 
  switch ( this->depth ) {
  case 32:
    if( rgb == 0 )
      this->yuv2rgb_mode = MODE_32_RGB;
    else
      this->yuv2rgb_mode = MODE_32_BGR;
  case 24:
    if( this->bpp == 32 ) {
      if( rgb == 0 ) {
  this->yuv2rgb_mode = MODE_32_RGB;
      } else {
  this->yuv2rgb_mode = MODE_32_BGR;
      }
    }else{
      if( rgb == 0 )
  this->yuv2rgb_mode = MODE_24_RGB;
      else
  this->yuv2rgb_mode = MODE_24_BGR;
    };
    break;
  case 16:
    if( rgb == 0 ) {
      this->yuv2rgb_mode = MODE_16_RGB;
    } else {
      this->yuv2rgb_mode = MODE_16_BGR;
    }
    break;
  case 15:
    if( rgb == 0 ) {
      this->yuv2rgb_mode = MODE_15_RGB;
    } else {
      this->yuv2rgb_mode = MODE_15_BGR;
    }
    break;
  case 8:
    if( rgb == 0 ) {
      this->yuv2rgb_mode = MODE_8_RGB;
    } else {
      this->yuv2rgb_mode = MODE_8_BGR;
    }
    break;
  };
-  //free(this->yuv2rgb_factory );
-  // this->yuv2rgb_factory = yuv2rgb_factory_init (this->yuv2rgb_mode, this->yuv2rgb_swap, 
-  //            this->yuv2rgb_cmap);
 };
-void null_display_handler( xine_vo_driver_t* self, display_xine_frame_t t, 
+void null_display_handler( xine_vo_driver_t* self, display_xine_frame_t t,
-         void* user_data ) {
+                           void* user_data ) {
  null_driver_t* this = (null_driver_t*) self->driver;
-  this->caller = user_data;
+  this->userData = user_data;
  this->frameDis = t;
 }
-void null_preload_decoders( xine_stream_t *stream )
-{
-    static const uint32_t preloadedAudioDecoders[] = { BUF_AUDIO_MPEG, BUF_AUDIO_VORBIS };
-    static const uint8_t preloadedAudioDecoderCount = sizeof( preloadedAudioDecoders ) / sizeof( preloadedAudioDecoders[ 0 ] );
-    static const uint32_t preloadedVideoDecoders[] = { BUF_VIDEO_MPEG, BUF_VIDEO_MPEG4, BUF_VIDEO_DIVX5 };
-    static const uint8_t preloadedVideoDecoderCount = sizeof( preloadedVideoDecoders ) / sizeof( preloadedVideoDecoders[ 0 ] );
-    uint8_t i;
-#if 0
-    for ( i = 0; i < preloadedAudioDecoderCount; ++i ) {
-        audio_decoder_t *decoder = get_audio_decoder( stream, ( preloadedAudioDecoders[ i ] >> 16 ) & 0xff );
-        decoder = decoder;
-/*        free_audio_decoder( stream, decoder ); */
-    }
-    for ( i = 0; i < preloadedVideoDecoderCount; ++i ) {
-        video_decoder_t *decoder = get_video_decoder( stream, ( preloadedVideoDecoders[ i ] >> 16 ) & 0xff );
-         decoder = decoder;
-/*         free_video_decoder( stream, decoder ); */
-    }
-#endif
-}
diff --git a/noncore/multimedia/opieplayer2/yuv2rgb.c b/noncore/multimedia/opieplayer2/yuv2rgb.c
index 8e34052..487ed20 100644
--- a/noncore/multimedia/opieplayer2/yuv2rgb.c
+++ b/noncore/multimedia/opieplayer2/yuv2rgb.c
@@ -1,3167 +1,3277 @@
 /*
 * yuv2rgb.c
 *
- * This file is part of xine, a unix video player.
+ * Copyright (C) 2003-2004 the xine project
+ * This file is part of xine, a free video player.
 *
 * based on work from mpeg2dec:
 * Copyright (C) 1999-2001 Aaron Holtzman <aholtzma@ess.engr.uvic.ca>
 *
 * This file is part of mpeg2dec, a free MPEG-2 video stream decoder.
 *
 * mpeg2dec 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.
 *
 * mpeg2dec 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$
 */
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 #include <inttypes.h>
 #include "yuv2rgb.h"
-#include <xine/xineutils.h>
+#define LOG_MODULE "yuv2rgb"
+#define LOG_VERBOSE
+/*
+#define LOG
+*/
+#include <xine/xineutils.h>
 static int prof_scale_line = -1;
 static scale_line_func_t find_scale_line_func(int step);
 const int32_t Inverse_Table_6_9[8][4] = {
  {117504, 138453, 13954, 34903}, /* no sequence_display_extension */
  {117504, 138453, 13954, 34903}, /* ITU-R Rec. 709 (1990) */
  {104597, 132201, 25675, 53279}, /* unspecified */
  {104597, 132201, 25675, 53279}, /* reserved */
  {104448, 132798, 24759, 53109}, /* FCC */
  {104597, 132201, 25675, 53279}, /* ITU-R Rec. 624-4 System B, G */
  {104597, 132201, 25675, 53279}, /* SMPTE 170M */
  {117579, 136230, 16907, 35559}  /* SMPTE 240M (1987) */
 };
-static void *my_malloc_aligned (size_t alignment, size_t size, void **chunk) {
+static void *my_malloc_aligned (size_t alignment, size_t size, void **chunk)
+{
  char *pMem;
  pMem = xine_xmalloc (size+alignment);
  *chunk = pMem;
-  while ((int) pMem % alignment)
+  while ((uintptr_t) pMem % alignment)
    pMem++;
  return pMem;
 }
+static int yuv2rgb_next_slice (yuv2rgb_t *this, uint8_t **dest)
+{
+  int y0, y1;
+  if (dest == NULL) {
+    this->slice_offset = 0;
+    this->slice_height = 16;
+    return 0;
+  }
+  if (this->slice_height == this->source_height) {
+    return this->dest_height;
+  }
+  y0 = (this->slice_offset * this->dest_height) / this->source_height;
+  y1 = ((this->slice_offset + this->slice_height) * this->dest_height) / this->source_height;
+  *dest += (this->rgb_stride * y0);
+  if ((this->slice_offset + this->slice_height) >= this->source_height) {
+    this->slice_offset = 0;
+    return (this->dest_height - y0);
+  } else {
+    this->slice_offset += this->slice_height;
+    return (y1 - y0);
+  }
+}
+static void yuv2rgb_dispose (yuv2rgb_t *this)
+{
+  free (this->y_chunk);
+  free (this->u_chunk);
+  free (this->v_chunk);
+#ifdef HAVE_MLIB
+  free (this->mlib_chunk);
+#endif
+  free (this);
+}
 static int yuv2rgb_configure (yuv2rgb_t *this, 
                              int source_width, int source_height,
                              int y_stride, int uv_stride,
                              int dest_width, int dest_height,
                              int rgb_stride) {
-  /*
+/*  
  printf ("yuv2rgb setup (%d x %d => %d x %d)\n", source_width, source_height,
          dest_width, dest_height);
-          */
+        */  
  if (prof_scale_line == -1)
    prof_scale_line = xine_profiler_allocate_slot("xshm scale line");
  this->source_width  = source_width;
  this->source_height = source_height;
  this->y_stride      = y_stride;
  this->uv_stride     = uv_stride;
  this->dest_width    = dest_width;
  this->dest_height   = dest_height;
  this->rgb_stride    = rgb_stride;
-  
+  this->slice_height  = source_height;
+  this->slice_offset  = 0;
  if (this->y_chunk) {
    free (this->y_chunk);
    this->y_buffer = this->y_chunk = NULL;
  }
  if (this->u_chunk) {
    free (this->u_chunk);
    this->u_buffer = this->u_chunk = NULL;
  }
  if (this->v_chunk) {
    free (this->v_chunk);
    this->v_buffer = this->v_chunk = NULL;
  }
-  
+#ifdef HAVE_MLIB
+  if (this->mlib_chunk) {
+    free (this->mlib_chunk);
+    this->mlib_buffer = this->mlib_chunk = NULL;
+  }
+  if (this->mlib_resize_chunk) {
+    free (this->mlib_resize_chunk);
+    this->mlib_resize_buffer = this->mlib_resize_chunk = NULL;
+  }
+#endif
  this->step_dx = source_width  * 32768 / dest_width;
  this->step_dy = source_height * 32768 / dest_height;
-    
+/*
+  printf("yuv2rgb config: src_ht=%i, dst_ht=%i\n",source_height, dest_height);
+  printf("yuv2rgb config: step_dy=%i %f\n",this->step_dy, (float)this->step_dy / 32768.0);
+*/    
  this->scale_line = find_scale_line_func(this->step_dx);
  if ((source_width == dest_width) && (source_height == dest_height)) {
    this->do_scale = 0;
    /*
     * space for two y-lines (for yuv2rgb_mlib)
     * u,v subsampled 2:1
     */
    this->y_buffer = my_malloc_aligned (16, 2*dest_width, &this->y_chunk);
    if (!this->y_buffer)
      return 0;
    this->u_buffer = my_malloc_aligned (16, (dest_width+1)/2, &this->u_chunk);
    if (!this->u_buffer)
      return 0;
    this->v_buffer = my_malloc_aligned (16, (dest_width+1)/2, &this->v_chunk);
    if (!this->v_buffer)
      return 0;
  } else {
    this->do_scale = 1;
    
    /*
     * space for two y-lines (for yuv2rgb_mlib)
     * u,v subsampled 2:1
     */
    this->y_buffer = my_malloc_aligned (16, 2*dest_width, &this->y_chunk);
    if (!this->y_buffer)
      return 0;
    this->u_buffer = my_malloc_aligned (16, (dest_width+1)/2, &this->u_chunk);
    if (!this->u_buffer)
      return 0;
    this->v_buffer = my_malloc_aligned (16, (dest_width+1)/2, &this->v_chunk);
    if (!this->v_buffer)
      return 0;
+#if HAVE_MLIB
+    /* Only need these if we are resizing and in mlib code */
+    this->mlib_buffer = my_malloc_aligned (16, source_width*source_height*4, &this->mlib_chunk);
+    if (!this->mlib_buffer)
+      return 0;
+    /* Only need this one if we are 24 bit */
+    if((rgb_stride / dest_width) == 3) {
+      this->mlib_resize_buffer = my_malloc_aligned (16, dest_width*dest_height*4, &this->mlib_resize_chunk);
+      if (!this->mlib_resize_buffer)
+      return 0;
+    }
+        #endif
  }
  return 1;
 }
 static void scale_line_gen (uint8_t *source, uint8_t *dest,
                            int width, int step) {
  /*
   * scales a yuv source row to a dest row, with interpolation
   * (good quality, but slow)
   */
  int p1;
  int p2;
  int dx;
  xine_profiler_start_count(prof_scale_line);
  p1 = *source++;
  p2 = *source++;
  dx = 0;
  /*
   * the following code has been optimized by Scott Smith <ssmith@akamai.com>:
   *
   * ok now I have a meaningful optimization for yuv2rgb.c:scale_line_gen.
   * it removes the loop from within the while() loop by separating it out
   * into 3 cases: where you are enlarging the line (<32768), where you are
   * between 50% and 100% of the original line (<=65536), and where you are
   * shrinking it by a lot.  anyways, I went from 200 delivered / 100+
   * skipped to 200 delivered / 80 skipped for the enlarging case.  I
   * noticed when looking at the assembly that the compiler was able to
   * unroll these while(width) loops, whereas before it was trying to
   * unroll the while(dx>32768) loops.  so the compiler is better able to
   * deal with this code.
   */
  if (step < 32768) {
    while (width) {
      *dest = p1 + (((p2-p1) * dx)>>15);
      dx += step;
      if (dx > 32768) {
        dx -= 32768;
        p1 = p2;
        p2 = *source++;
      }
      
      dest ++;
      width --;
    }
  } else if (step <= 65536) {
    while (width) {
      *dest = p1 + (((p2-p1) * dx)>>15);
      dx += step;
      if (dx > 65536) {
        dx -= 65536;
        p1 = *source++;
        p2 = *source++;
      } else {
        dx -= 32768;
        p1 = p2;
        p2 = *source++;
      }
      
      dest ++;
      width --;
    }
  } else {
    while (width) {
      int offs;
      *dest = p1 + (((p2-p1) * dx)>>15);
      dx += step;
      offs=((dx-1)>>15);
      dx-=offs<<15;
      source+=offs-2;
      p1=*source++;
      p2=*source++;
      dest ++;
      width --;
    }
  }
  xine_profiler_stop_count(prof_scale_line);
 }
 /*
 * Interpolates 16 output pixels from 15 source pixels using shifts.
 * Useful for scaling a PAL mpeg2 dvd input source to 4:3 format on
 * a monitor using square pixels.
 * (720 x 576 ==> 768 x 576)
 */
 static void scale_line_15_16 (uint8_t *source, uint8_t *dest,
                              int width, int step) {
  int p1, p2;
  xine_profiler_start_count(prof_scale_line);
  while ((width -= 16) >= 0) {
    p1 = source[0];
    dest[0] = p1;
    p2 = source[1];
    dest[1] = (1*p1 + 7*p2) >> 3;
    p1 = source[2];
    dest[2] = (1*p2 + 7*p1) >> 3;
    p2 = source[3];
    dest[3] = (1*p1 + 3*p2) >> 2;
    p1 = source[4];
    dest[4] = (1*p2 + 3*p1) >> 2;
    p2 = source[5];
    dest[5] = (3*p1 + 5*p2) >> 3;
    p1 = source[6];
    dest[6] = (3*p2 + 5*p1) >> 3;
    p2 = source[7];
    dest[7] = (1*p1 + 1*p1) >> 1;
    p1 = source[8];
    dest[8] = (1*p2 + 1*p1) >> 1;
    p2 = source[9];
    dest[9] = (5*p1 + 3*p2) >> 3;
    p1 = source[10];
    dest[10] = (5*p2 + 3*p1) >> 3;
    p2 = source[11];
    dest[11] = (3*p1 + 1*p2) >> 2;
    p1 = source[12];
    dest[12] = (3*p2 + 1*p1) >> 2;
    p2 = source[13];
    dest[13] = (7*p1 + 1*p2) >> 3;
    p1 = source[14];
    dest[14] = (7*p2 + 1*p1) >> 3;
    dest[15] = p1;
    source += 15;
    dest += 16;
  }
  if ((width += 16) <= 0) goto done;
  *dest++ = source[0];
  if (--width <= 0) goto done;
  *dest++ = (1*source[0] + 7*source[1]) >> 3;
  if (--width <= 0) goto done;
  *dest++ = (1*source[1] + 7*source[2]) >> 3;
  if (--width <= 0) goto done;
  *dest++ = (1*source[2] + 3*source[3]) >> 2;
  if (--width <= 0) goto done;
  *dest++ = (1*source[3] + 3*source[4]) >> 2;
  if (--width <= 0) goto done;
  *dest++ = (3*source[4] + 5*source[5]) >> 3;
  if (--width <= 0) goto done;
  *dest++ = (3*source[5] + 5*source[6]) >> 3;
  if (--width <= 0) goto done;
  *dest++ = (1*source[6] + 1*source[7]) >> 1;
  if (--width <= 0) goto done;
  *dest++ = (1*source[7] + 1*source[8]) >> 1;
  if (--width <= 0) goto done;
  *dest++ = (5*source[8] + 3*source[9]) >> 3;
  if (--width <= 0) goto done;
  *dest++ = (5*source[9] + 3*source[10]) >> 3;
  if (--width <= 0) goto done;
  *dest++ = (3*source[10] + 1*source[11]) >> 2;
  if (--width <= 0) goto done;
  *dest++ = (3*source[11] + 1*source[12]) >> 2;
  if (--width <= 0) goto done;
  *dest++ = (7*source[12] + 1*source[13]) >> 3;
  if (--width <= 0) goto done;
  *dest++ = (7*source[13] + 1*source[14]) >> 3;
 done:
  xine_profiler_stop_count(prof_scale_line);
 }
 /*
 * Interpolates 53 output pixels from 45 source pixels using shifts.
 * Useful for scaling a NTSC mpeg2 dvd input source to 16:9 display
 * resulution
 * fullscreen resolution, or to 16:9 format on a monitor using square
 * pixels.
 * (720 x 480 ==> 848 x 480)
 */
 static void scale_line_45_53 (uint8_t *source, uint8_t *dest,
                              int width, int step) {
  int p1, p2;
  xine_profiler_start_count(prof_scale_line);
  while ((width -= 53) >= 0) {
    p1 = source[0];
    p2 = source[1];
    dest[0] = p1;
    dest[1] = (1*p1 + 7*p2) >> 3;
    p1 = source[2];
    dest[2] = (1*p2 + 3*p1) >> 2;
    p2 = source[3];
    dest[3] = (1*p1 + 1*p2) >> 1;
    p1 = source[4];
    dest[4] = (5*p2 + 3*p1) >> 3;
    p2 = source[5];
    dest[5] = (3*p1 + 1*p2) >> 2;
    p1 = source[6];
    dest[6] = (7*p2 + 1*p1) >> 3;
    dest[7] = p1;
    p2 = source[7];
    dest[8] = (1*p1 + 3*p2) >> 2;
    p1 = source[8];
    dest[9] = (3*p2 + 5*p1) >> 3;
    p2 = source[9];
    dest[10] = (1*p1 + 1*p2) >> 1;
    p1 = source[10];
    dest[11] = (5*p2 + 3*p1) >> 3;
    p2 = source[11];
    dest[12] = (3*p1 + 1*p2) >> 2;
    p1 = source[12];
    dest[13] = p2;
    dest[14] = (1*p2 + 7*p1) >> 3;
    p2 = source[13];
    dest[15] = (1*p1 + 3*p2) >> 2;
    p1 = source[14];
    dest[16] = (3*p2 + 5*p1) >> 3;
    p2 = source[15];
    dest[17] = (5*p1 + 3*p2) >> 3;
    p1 = source[16];
    dest[18] = (3*p2 + 1*p1) >> 2;
    p2 = source[17];
    dest[19] = (7*p1 + 1*p2) >> 3;
    dest[20] = p2;
    p1 = source[18];
    dest[21] = (1*p2 + 7*p1) >> 3;
    p2 = source[19];
    dest[22] = (3*p1 + 5*p2) >> 3;
    p1 = source[20];
    dest[23] = (1*p2 + 1*p1) >> 1;
    p2 = source[21];
    dest[24] = (5*p1 + 3*p2) >> 3;
    p1 = source[22];
    dest[25] = (3*p2 + 1*p1) >> 2;
    p2 = source[23];
    dest[26] = (7*p1 + 1*p2) >> 3;
    dest[27] = (1*p1 + 7*p2) >> 3;
    p1 = source[24];
    dest[28] = (1*p2 + 3*p1) >> 2;
    p2 = source[25];
    dest[29] = (3*p1 + 5*p2) >> 3;
    p1 = source[26];
    dest[30] = (1*p2 + 1*p1) >> 1;
    p2 = source[27];
    dest[31] = (5*p1 + 3*p2) >> 3;
    p1 = source[28];
    dest[32] = (7*p2 + 1*p1) >> 3;
    p2 = source[29];
    dest[33] = p1;
    dest[34] = (1*p1 + 7*p2) >> 3;
    p1 = source[30];
    dest[35] = (1*p2 + 3*p1) >> 2;
    p2 = source[31];
    dest[36] = (3*p1 + 5*p2) >> 3;
    p1 = source[32];
    dest[37] = (5*p2 + 3*p1) >> 3;
    p2 = source[33];
    dest[38] = (3*p1 + 1*p2) >> 2;
    p1 = source[34];
    dest[39] = (7*p2 + 1*p1) >> 3;
    dest[40] = p1;
    p2 = source[35];
    dest[41] = (1*p1 + 3*p2) >> 2;
    p1 = source[36];
    dest[42] = (3*p2 + 5*p1) >> 3;
    p2 = source[37];
    dest[43] = (1*p1 + 1*p2) >> 1;
    p1 = source[38];
    dest[44] = (5*p2 + 3*p1) >> 3;
    p2 = source[39];
    dest[45] = (3*p1 + 1*p2) >> 2;
    p1 = source[40];
    dest[46] = p2;
    dest[47] = (1*p2 + 7*p1) >> 3;
    p2 = source[41];
    dest[48] = (1*p1 + 3*p2) >> 2;
    p1 = source[42];
    dest[49] = (3*p2 + 5*p1) >> 3;
    p2 = source[43];
    dest[50] = (1*p1 + 1*p2) >> 1;
    p1 = source[44];
    dest[51] = (3*p2 + 1*p1) >> 2;
    p2 = source[45];
    dest[52] = (7*p1 + 1*p2) >> 3;
    source += 45;
    dest += 53;
  }
  if ((width += 53) <= 0) goto done;
  *dest++ = source[0];
  if (--width <= 0) goto done;
  *dest++ = (1*source[0] + 7*source[1]) >> 3;
  if (--width <= 0) goto done;
  *dest++ = (1*source[1] + 3*source[2]) >> 2;
  if (--width <= 0) goto done;
  *dest++ = (1*source[2] + 1*source[3]) >> 1;
  if (--width <= 0) goto done;
  *dest++ = (5*source[3] + 3*source[4]) >> 3;
  if (--width <= 0) goto done;
  *dest++ = (3*source[4] + 1*source[5]) >> 2;
  if (--width <= 0) goto done;
  *dest++ = (7*source[5] + 1*source[6]) >> 3;
  if (--width <= 0) goto done;
  *dest++ = source[6];
  if (--width <= 0) goto done;
  *dest++ = (1*source[6] + 3*source[7]) >> 2;
  if (--width <= 0) goto done;
  *dest++ = (3*source[7] + 5*source[8]) >> 3;
  if (--width <= 0) goto done;
  *dest++ = (1*source[8] + 1*source[9]) >> 1;
  if (--width <= 0) goto done;
  *dest++ = (5*source[9] + 3*source[10]) >> 3;
  if (--width <= 0) goto done;
  *dest++ = (3*source[10] + 1*source[11]) >> 2;
  if (--width <= 0) goto done;
  *dest++ = source[11];
  if (--width <= 0) goto done;
  *dest++ = (1*source[11] + 7*source[12]) >> 3;
  if (--width <= 0) goto done;
  *dest++ = (1*source[12] + 3*source[13]) >> 2;
  if (--width <= 0) goto done;
  *dest++ = (3*source[13] + 5*source[14]) >> 3;
  if (--width <= 0) goto done;
  *dest++ = (5*source[14] + 3*source[15]) >> 3;
  if (--width <= 0) goto done;
  *dest++ = (3*source[15] + 1*source[16]) >> 2;
  if (--width <= 0) goto done;
  *dest++ = (7*source[16] + 1*source[17]) >> 3;
  if (--width <= 0) goto done;
  *dest++ = source[17];
  if (--width <= 0) goto done;
  *dest++ = (1*source[17] + 7*source[18]) >> 3;
  if (--width <= 0) goto done;
  *dest++ = (3*source[18] + 5*source[19]) >> 3;
  if (--width <= 0) goto done;
  *dest++ = (1*source[19] + 1*source[20]) >> 1;
  if (--width <= 0) goto done;
  *dest++ = (5*source[20] + 3*source[21]) >> 3;
  if (--width <= 0) goto done;
  *dest++ = (3*source[21] + 1*source[22]) >> 2;
  if (--width <= 0) goto done;
  *dest++ = (7*source[22] + 1*source[23]) >> 3;
  if (--width <= 0) goto done;
  *dest++ = (1*source[22] + 7*source[23]) >> 3;
  if (--width <= 0) goto done;
  *dest++ = (1*source[23] + 3*source[24]) >> 2;
  if (--width <= 0) goto done;
  *dest++ = (3*source[24] + 5*source[25]) >> 3;
  if (--width <= 0) goto done;
  *dest++ = (1*source[25] + 1*source[26]) >> 1;
  if (--width <= 0) goto done;
  *dest++ = (5*source[26] + 3*source[27]) >> 3;
  if (--width <= 0) goto done;
  *dest++ = (7*source[27] + 1*source[28]) >> 3;
  if (--width <= 0) goto done;
  *dest++ = source[28];
  if (--width <= 0) goto done;
  *dest++ = (1*source[28] + 7*source[29]) >> 3;
  if (--width <= 0) goto done;
  *dest++ = (1*source[29] + 3*source[30]) >> 2;
  if (--width <= 0) goto done;
  *dest++ = (3*source[30] + 5*source[31]) >> 3;
  if (--width <= 0) goto done;
  *dest++ = (5*source[31] + 3*source[32]) >> 3;
  if (--width <= 0) goto done;
  *dest++ = (3*source[32] + 1*source[33]) >> 2;
  if (--width <= 0) goto done;
  *dest++ = (7*source[33] + 1*source[34]) >> 3;
  if (--width <= 0) goto done;
  *dest++ = source[34];
  if (--width <= 0) goto done;
  *dest++ = (1*source[34] + 3*source[35]) >> 2;
  if (--width <= 0) goto done;
  *dest++ = (3*source[35] + 5*source[36]) >> 3;
  if (--width <= 0) goto done;
  *dest++ = (1*source[36] + 1*source[37]) >> 1;
  if (--width <= 0) goto done;
  *dest++ = (5*source[37] + 3*source[38]) >> 3;
  if (--width <= 0) goto done;
  *dest++ = (3*source[38] + 1*source[39]) >> 2;
  if (--width <= 0) goto done;
  *dest++ = source[39];
  if (--width <= 0) goto done;
  *dest++ = (1*source[39] + 7*source[40]) >> 3;
  if (--width <= 0) goto done;
  *dest++ = (1*source[40] + 3*source[41]) >> 2;
  if (--width <= 0) goto done;
  *dest++ = (3*source[41] + 5*source[42]) >> 3;
  if (--width <= 0) goto done;
  *dest++ = (1*source[42] + 1*source[43]) >> 1;
  if (--width <= 0) goto done;
  *dest++ = (3*source[43] + 1*source[44]) >> 2;
 done:
  xine_profiler_stop_count(prof_scale_line);
 }
 /*
 * Interpolates 64 output pixels from 45 source pixels using shifts.
 * Useful for scaling a PAL mpeg2 dvd input source to 1024x768
 * fullscreen resolution, or to 16:9 format on a monitor using square
 * pixels.
 * (720 x 576 ==> 1024 x 576)
 */
 static void scale_line_45_64 (uint8_t *source, uint8_t *dest,
                             int width, int step) {
  int p1, p2;
  xine_profiler_start_count(prof_scale_line);
  while ((width -= 64) >= 0) {
    p1 = source[0];
    p2 = source[1];
    dest[0] = p1;
    dest[1] = (1*p1 + 3*p2) >> 2;
    p1 = source[2];
    dest[2] = (5*p2 + 3*p1) >> 3;
    p2 = source[3];
    dest[3] = (7*p1 + 1*p2) >> 3;
    dest[4] = (1*p1 + 3*p2) >> 2;
    p1 = source[4];
    dest[5] = (1*p2 + 1*p1) >> 1;
    p2 = source[5];
    dest[6] = (3*p1 + 1*p2) >> 2;
    dest[7] = (1*p1 + 7*p2) >> 3;
    p1 = source[6];
    dest[8] = (3*p2 + 5*p1) >> 3;
    p2 = source[7];
    dest[9] = (5*p1 + 3*p2) >> 3;
    p1 = source[8];
    dest[10] = p2;
    dest[11] = (1*p2 + 3*p1) >> 2;
    p2 = source[9];
    dest[12] = (5*p1 + 3*p2) >> 3;
    p1 = source[10];
    dest[13] = (7*p2 + 1*p1) >> 3;
    dest[14] = (1*p2 + 7*p1) >> 3;
    p2 = source[11];
    dest[15] = (1*p1 + 1*p2) >> 1;
    p1 = source[12];
    dest[16] = (3*p2 + 1*p1) >> 2;
    dest[17] = p1;
    p2 = source[13];
    dest[18] = (3*p1 + 5*p2) >> 3;
    p1 = source[14];
    dest[19] = (5*p2 + 3*p1) >> 3;
    p2 = source[15];
    dest[20] = p1;
    dest[21] = (1*p1 + 3*p2) >> 2;
    p1 = source[16];
    dest[22] = (1*p2 + 1*p1) >> 1;
    p2 = source[17];
    dest[23] = (7*p1 + 1*p2) >> 3;
    dest[24] = (1*p1 + 7*p2) >> 3;
    p1 = source[18];
    dest[25] = (3*p2 + 5*p1) >> 3;
    p2 = source[19];
    dest[26] = (3*p1 + 1*p2) >> 2;
    dest[27] = p2;
    p1 = source[20];
    dest[28] = (3*p2 + 5*p1) >> 3;
    p2 = source[21];
    dest[29] = (5*p1 + 3*p2) >> 3;
    p1 = source[22];
    dest[30] = (7*p2 + 1*p1) >> 3;
    dest[31] = (1*p2 + 3*p1) >> 2;
    p2 = source[23];
    dest[32] = (1*p1 + 1*p2) >> 1;
    p1 = source[24];
    dest[33] = (3*p2 + 1*p1) >> 2;
    dest[34] = (1*p2 + 7*p1) >> 3;
    p2 = source[25];
    dest[35] = (3*p1 + 5*p2) >> 3;
    p1 = source[26];
    dest[36] = (3*p2 + 1*p1) >> 2;
    p2 = source[27];
    dest[37] = p1;
    dest[38] = (1*p1 + 3*p2) >> 2;
    p1 = source[28];
    dest[39] = (5*p2 + 3*p1) >> 3;
    p2 = source[29];
    dest[40] = (7*p1 + 1*p2) >> 3;
    dest[41] = (1*p1 + 7*p2) >> 3;
    p1 = source[30];
    dest[42] = (1*p2 + 1*p1) >> 1;
    p2 = source[31];
    dest[43] = (3*p1 + 1*p2) >> 2;
    dest[44] = (1*p1 + 7*p2) >> 3;
    p1 = source[32];
    dest[45] = (3*p2 + 5*p1) >> 3;
    p2 = source[33];
    dest[46] = (5*p1 + 3*p2) >> 3;
    p1 = source[34];
    dest[47] = p2;
    dest[48] = (1*p2 + 3*p1) >> 2;
    p2 = source[35];
    dest[49] = (1*p1 + 1*p2) >> 1;
    p1 = source[36];
    dest[50] = (7*p2 + 1*p1) >> 3;
    dest[51] = (1*p2 + 7*p1) >> 3;
    p2 = source[37];
    dest[52] = (1*p1 + 1*p2) >> 1;
    p1 = source[38];
    dest[53] = (3*p2 + 1*p1) >> 2;
    dest[54] = p1;
    p2 = source[39];
    dest[55] = (3*p1 + 5*p2) >> 3;
    p1 = source[40];
    dest[56] = (5*p2 + 3*p1) >> 3;
    p2 = source[41];
    dest[57] = (7*p1 + 1*p2) >> 3;
    dest[58] = (1*p1 + 3*p2) >> 2;
    p1 = source[42];
    dest[59] = (1*p2 + 1*p1) >> 1;
    p2 = source[43];
    dest[60] = (7*p1 + 1*p2) >> 3;
    dest[61] = (1*p1 + 7*p2) >> 3;
    p1 = source[44];
    dest[62] = (3*p2 + 5*p1) >> 3;
    p2 = source[45];
    dest[63] = (3*p1 + 1*p2) >> 2;
    source += 45;
    dest += 64;
  }
  if ((width += 64) <= 0) goto done;
  *dest++ = source[0];
  if (--width <= 0) goto done;
  *dest++ = (1*source[0] + 3*source[1]) >> 2;
  if (--width <= 0) goto done;
  *dest++ = (5*source[1] + 3*source[2]) >> 3;
  if (--width <= 0) goto done;
  *dest++ = (7*source[2] + 1*source[3]) >> 3;
  if (--width <= 0) goto done;
  *dest++ = (1*source[2] + 3*source[3]) >> 2;
  if (--width <= 0) goto done;
  *dest++ = (1*source[3] + 1*source[4]) >> 1;
  if (--width <= 0) goto done;
  *dest++ = (3*source[4] + 1*source[5]) >> 2;
  if (--width <= 0) goto done;
  *dest++ = (1*source[4] + 7*source[5]) >> 3;
  if (--width <= 0) goto done;
  *dest++ = (3*source[5] + 5*source[6]) >> 3;
  if (--width <= 0) goto done;
  *dest++ = (5*source[6] + 3*source[7]) >> 3;
  if (--width <= 0) goto done;
  *dest++ = source[7];
  if (--width <= 0) goto done;
  *dest++ = (1*source[7] + 3*source[8]) >> 2;
  if (--width <= 0) goto done;
  *dest++ = (5*source[8] + 3*source[9]) >> 3;
  if (--width <= 0) goto done;
  *dest++ = (7*source[9] + 1*source[10]) >> 3;
  if (--width <= 0) goto done;
  *dest++ = (1*source[9] + 7*source[10]) >> 3;
  if (--width <= 0) goto done;
  *dest++ = (1*source[10] + 1*source[11]) >> 1;
  if (--width <= 0) goto done;
  *dest++ = (3*source[11] + 1*source[12]) >> 2;
  if (--width <= 0) goto done;
  *dest++ = source[12];
  if (--width <= 0) goto done;
  *dest++ = (3*source[12] + 5*source[13]) >> 3;
  if (--width <= 0) goto done;
  *dest++ = (5*source[13] + 3*source[14]) >> 3;
  if (--width <= 0) goto done;
  *dest++ = source[14];
  if (--width <= 0) goto done;
  *dest++ = (1*source[14] + 3*source[15]) >> 2;
  if (--width <= 0) goto done;
  *dest++ = (1*source[15] + 1*source[16]) >> 1;
  if (--width <= 0) goto done;
  *dest++ = (7*source[16] + 1*source[17]) >> 3;
  if (--width <= 0) goto done;
  *dest++ = (1*source[16] + 7*source[17]) >> 3;
  if (--width <= 0) goto done;
  *dest++ = (3*source[17] + 5*source[18]) >> 3;
  if (--width <= 0) goto done;
  *dest++ = (3*source[18] + 1*source[19]) >> 2;
  if (--width <= 0) goto done;
  *dest++ = source[19];
  if (--width <= 0) goto done;
  *dest++ = (3*source[19] + 5*source[20]) >> 3;
  if (--width <= 0) goto done;
  *dest++ = (5*source[20] + 3*source[21]) >> 3;
  if (--width <= 0) goto done;
  *dest++ = (7*source[21] + 1*source[22]) >> 3;
  if (--width <= 0) goto done;
  *dest++ = (1*source[21] + 3*source[22]) >> 2;
  if (--width <= 0) goto done;
  *dest++ = (1*source[22] + 1*source[23]) >> 1;
  if (--width <= 0) goto done;
  *dest++ = (3*source[23] + 1*source[24]) >> 2;
  if (--width <= 0) goto done;
  *dest++ = (1*source[23] + 7*source[24]) >> 3;
  if (--width <= 0) goto done;
  *dest++ = (3*source[24] + 5*source[25]) >> 3;
  if (--width <= 0) goto done;
  *dest++ = (3*source[25] + 1*source[26]) >> 2;
  if (--width <= 0) goto done;
  *dest++ = source[26];
  if (--width <= 0) goto done;
  *dest++ = (1*source[26] + 3*source[27]) >> 2;
  if (--width <= 0) goto done;
  *dest++ = (5*source[27] + 3*source[28]) >> 3;
  if (--width <= 0) goto done;
  *dest++ = (7*source[28] + 1*source[29]) >> 3;
  if (--width <= 0) goto done;
  *dest++ = (1*source[28] + 7*source[29]) >> 3;
  if (--width <= 0) goto done;
  *dest++ = (1*source[29] + 1*source[30]) >> 1;
  if (--width <= 0) goto done;
  *dest++ = (3*source[30] + 1*source[31]) >> 2;
  if (--width <= 0) goto done;
  *dest++ = (1*source[30] + 7*source[31]) >> 3;
  if (--width <= 0) goto done;
  *dest++ = (3*source[31] + 5*source[32]) >> 3;
  if (--width <= 0) goto done;
  *dest++ = (5*source[32] + 3*source[33]) >> 3;
  if (--width <= 0) goto done;
  *dest++ = source[33];
  if (--width <= 0) goto done;
  *dest++ = (1*source[33] + 3*source[34]) >> 2;
  if (--width <= 0) goto done;
  *dest++ = (1*source[34] + 1*source[35]) >> 1;
  if (--width <= 0) goto done;
  *dest++ = (7*source[35] + 1*source[36]) >> 3;
  if (--width <= 0) goto done;
  *dest++ = (1*source[35] + 7*source[36]) >> 3;
  if (--width <= 0) goto done;
  *dest++ = (1*source[36] + 1*source[37]) >> 1;
  if (--width <= 0) goto done;
  *dest++ = (3*source[37] + 1*source[38]) >> 2;
  if (--width <= 0) goto done;
  *dest++ = source[38];
  if (--width <= 0) goto done;
  *dest++ = (3*source[38] + 5*source[39]) >> 3;
  if (--width <= 0) goto done;
  *dest++ = (5*source[39] + 3*source[40]) >> 3;
  if (--width <= 0) goto done;
  *dest++ = (7*source[40] + 1*source[41]) >> 3;
  if (--width <= 0) goto done;
  *dest++ = (1*source[40] + 3*source[41]) >> 2;
  if (--width <= 0) goto done;
  *dest++ = (1*source[41] + 1*source[42]) >> 1;
  if (--width <= 0) goto done;
  *dest++ = (7*source[42] + 1*source[43]) >> 3;
  if (--width <= 0) goto done;
  *dest++ = (1*source[42] + 7*source[43]) >> 3;
  if (--width <= 0) goto done;
  *dest++ = (3*source[43] + 5*source[44]) >> 3;
 done:
  xine_profiler_stop_count(prof_scale_line);
 }
 /*
 * Interpolates 16 output pixels from 9 source pixels using shifts.
 * Useful for scaling a PAL mpeg2 dvd input source to 1280x1024 fullscreen
 * (720 x 576 ==> 1280 x XXX)
 */
 static void scale_line_9_16 (uint8_t *source, uint8_t *dest,
                             int width, int step) {
  int p1, p2;
  xine_profiler_start_count(prof_scale_line);
  while ((width -= 16) >= 0) {
    p1 = source[0];
    p2 = source[1];
    dest[0] = p1;
    dest[1] = (1*p1 + 1*p2) >> 1;
    p1 = source[2];
    dest[2] = (7*p2 + 1*p1) >> 3;
    dest[3] = (3*p2 + 5*p1) >> 3;
    p2 = source[3];
    dest[4] = (3*p1 + 1*p2) >> 2;
    dest[5] = (1*p1 + 3*p2) >> 2;
    p1 = source[4];
    dest[6] = (5*p2 + 3*p1) >> 3;
    dest[7] = (1*p2 + 7*p1) >> 3;
    p2 = source[5];
    dest[8] = (1*p1 + 1*p2) >> 1;
    p1 = source[6];
    dest[9] = p2;
    dest[10] = (3*p2 + 5*p1) >> 3;
    p2 = source[7];
    dest[11] = (7*p1 + 1*p2) >> 3;
    dest[12] = (1*p1 + 3*p2) >> 2;
    p1 = source[8];
    dest[13] = (3*p2 + 1*p1) >> 2;
    dest[14] = (1*p2 + 7*p1) >> 3;
    p2 = source[9];
    dest[15] = (5*p1 + 3*p2) >> 3;
    source += 9;
    dest += 16;
  }
  if ((width += 16) <= 0) goto done;
  *dest++ = source[0];
  if (--width <= 0) goto done;
  *dest++ = (1*source[0] + 1*source[1]) >> 1;
  if (--width <= 0) goto done;
  *dest++ = (7*source[1] + 1*source[2]) >> 3;
  if (--width <= 0) goto done;
  *dest++ = (3*source[1] + 5*source[2]) >> 3;
  if (--width <= 0) goto done;
  *dest++ = (3*source[2] + 1*source[3]) >> 2;
  if (--width <= 0) goto done;
  *dest++ = (1*source[2] + 3*source[3]) >> 2;
  if (--width <= 0) goto done;
  *dest++ = (5*source[3] + 3*source[4]) >> 3;
  if (--width <= 0) goto done;
  *dest++ = (1*source[3] + 7*source[4]) >> 3;
  if (--width <= 0) goto done;
  *dest++ = (1*source[4] + 1*source[5]) >> 1;
  if (--width <= 0) goto done;
  *dest++ = source[5];
  if (--width <= 0) goto done;
  *dest++ = (3*source[5] + 5*source[6]) >> 3;
  if (--width <= 0) goto done;
  *dest++ = (7*source[6] + 1*source[7]) >> 3;
  if (--width <= 0) goto done;
  *dest++ = (1*source[6] + 3*source[7]) >> 2;
  if (--width <= 0) goto done;
  *dest++ = (3*source[7] + 1*source[8]) >> 2;
  if (--width <= 0) goto done;
  *dest++ = (1*source[7] + 7*source[8]) >> 3;
 done:
  xine_profiler_stop_count(prof_scale_line);
 }
 /*
 * Interpolates 12 output pixels from 11 source pixels using shifts.
 * Useful for scaling a PAL vcd input source to 4:3 display format.
 */
 static void scale_line_11_12 (uint8_t *source, uint8_t *dest,
                             int width, int step) {
  int p1, p2;
  xine_profiler_start_count(prof_scale_line);
  while ((width -= 12) >= 0) {
    p1 = source[0];
    p2 = source[1];
    dest[0] = p1;
    dest[1] = (1*p1 + 7*p2) >> 3;
    p1 = source[2];
    dest[2] = (1*p2 + 7*p1) >> 3;
    p2 = source[3];
    dest[3] = (1*p1 + 3*p2) >> 2;
    p1 = source[4];
    dest[4] = (3*p2 + 5*p1) >> 3;
    p2 = source[5];
    dest[5] = (3*p1 + 5*p2) >> 3;
    p1 = source[6];
    dest[6] = (1*p2 + 1*p1) >> 1;
    p2 = source[7];
    dest[7] = (5*p1 + 3*p2) >> 3;
    p1 = source[8];
    dest[8] = (5*p2 + 3*p1) >> 3;
    p2 = source[9];
    dest[9] = (3*p1 + 1*p2) >> 2;
    p1 = source[10];
    dest[10] = (7*p2 + 1*p1) >> 3;
    p2 = source[11];
    dest[11] = (7*p1 + 1*p2) >> 3;
    source += 11;
    dest += 12;
  }
  if ((width += 12) <= 0) goto done;
  *dest++ = source[0];
  if (--width <= 0) goto done;
  *dest++ = (1*source[0] + 7*source[1]) >> 3;
  if (--width <= 0) goto done;
  *dest++ = (1*source[1] + 7*source[2]) >> 3;
  if (--width <= 0) goto done;
  *dest++ = (1*source[2] + 3*source[3]) >> 2;
  if (--width <= 0) goto done;
  *dest++ = (3*source[3] + 5*source[4]) >> 3;
  if (--width <= 0) goto done;
  *dest++ = (3*source[4] + 5*source[5]) >> 3;
  if (--width <= 0) goto done;
  *dest++ = (1*source[5] + 1*source[6]) >> 1;
  if (--width <= 0) goto done;
  *dest++ = (5*source[6] + 3*source[7]) >> 3;
  if (--width <= 0) goto done;
  *dest++ = (5*source[7] + 3*source[8]) >> 3;
  if (--width <= 0) goto done;
  *dest++ = (3*source[8] + 1*source[9]) >> 2;
  if (--width <= 0) goto done;
  *dest++ = (7*source[9] + 1*source[10]) >> 3;
 done:
  xine_profiler_stop_count(prof_scale_line);
 }
 /*
 * Interpolates 24 output pixels from 11 source pixels using shifts.
 * Useful for scaling a PAL vcd input source to 4:3 display format
 * at 2*zoom.
 */
 static void scale_line_11_24 (uint8_t *source, uint8_t *dest,
                             int width, int step) {
  int p1, p2;
  xine_profiler_start_count(prof_scale_line);
  while ((width -= 24) >= 0) {
    p1 = source[0];
    p2 = source[1];
    dest[0] = p1;
    dest[1] = (1*p1 + 1*p2) >> 1;
    dest[2] = (1*p1 + 7*p2) >> 3;
    p1 = source[2];
    dest[3] = (5*p2 + 3*p1) >> 3;
    dest[4] = (1*p2 + 7*p1) >> 3;
    p2 = source[3];
    dest[5] = (3*p1 + 1*p2) >> 2;
    dest[6] = (1*p1 + 3*p2) >> 2;
    p1 = source[4];
    dest[7] = (3*p2 + 1*p1) >> 2;
    dest[8] = (3*p2 + 5*p1) >> 3;
    p2 = source[5];
    dest[9] = (7*p1 + 1*p2) >> 3;
    dest[10] = (3*p1 + 5*p2) >> 3;
    p1 = source[6];
    dest[11] = p2;
    dest[12] = (1*p2 + 1*p1) >> 1;
    dest[13] = p1;
    p2 = source[7];
    dest[14] = (5*p1 + 3*p2) >> 3;
    dest[15] = (1*p1 + 7*p2) >> 3;
    p1 = source[8];
    dest[16] = (5*p2 + 3*p1) >> 3;
    dest[17] = (1*p2 + 3*p1) >> 2;
    p2 = source[9];
    dest[18] = (3*p1 + 1*p2) >> 2;
    dest[19] = (1*p1 + 3*p2) >> 2;
    p1 = source[10];
    dest[20] = (7*p2 + 1*p1) >> 3;
    dest[21] = (3*p2 + 5*p1) >> 3;
    p2 = source[11];
    dest[22] = (7*p1 + 1*p2) >> 3;
    dest[23] = (1*p1 + 1*p2) >> 1;
    source += 11;
    dest += 24;
  }
  if ((width += 24) <= 0) goto done;
  *dest++ = source[0];
  if (--width <= 0) goto done;
  *dest++ = (1*source[0] + 1*source[1]) >> 1;
  if (--width <= 0) goto done;
  *dest++ = (1*source[0] + 7*source[1]) >> 3;
  if (--width <= 0) goto done;
  *dest++ = (5*source[1] + 3*source[2]) >> 3;
  if (--width <= 0) goto done;
  *dest++ = (1*source[1] + 7*source[2]) >> 3;
  if (--width <= 0) goto done;
  *dest++ = (3*source[2] + 1*source[3]) >> 2;
  if (--width <= 0) goto done;
  *dest++ = (1*source[2] + 3*source[3]) >> 2;
  if (--width <= 0) goto done;
  *dest++ = (3*source[3] + 1*source[4]) >> 2;
  if (--width <= 0) goto done;
  *dest++ = (3*source[3] + 5*source[4]) >> 3;
  if (--width <= 0) goto done;
  *dest++ = (7*source[4] + 1*source[5]) >> 3;
  if (--width <= 0) goto done;
  *dest++ = (3*source[4] + 5*source[5]) >> 3;
  if (--width <= 0) goto done;
  *dest++ = source[5];
  if (--width <= 0) goto done;
  *dest++ = (1*source[5] + 1*source[6]) >> 1;
  if (--width <= 0) goto done;
  *dest++ = source[6];
  if (--width <= 0) goto done;
  *dest++ = (5*source[6] + 3*source[7]) >> 3;
  if (--width <= 0) goto done;
  *dest++ = (1*source[6] + 7*source[7]) >> 3;
  if (--width <= 0) goto done;
  *dest++ = (5*source[7] + 3*source[8]) >> 3;
  if (--width <= 0) goto done;
  *dest++ = (1*source[7] + 3*source[8]) >> 2;
  if (--width <= 0) goto done;
  *dest++ = (3*source[8] + 1*source[9]) >> 2;
  if (--width <= 0) goto done;
  *dest++ = (1*source[8] + 3*source[9]) >> 2;
  if (--width <= 0) goto done;
  *dest++ = (7*source[9] + 1*source[10]) >> 3;
  if (--width <= 0) goto done;
  *dest++ = (3*source[9] + 5*source[10]) >> 3;
  if (--width <= 0) goto done;
  *dest++ = (7*source[10] + 1*source[11]) >> 3;
 done:
  xine_profiler_stop_count(prof_scale_line);
 }
 /*
 * Interpolates 8 output pixels from 5 source pixels using shifts.
 * Useful for scaling a PAL svcd input source to 4:3 display format.
 */
 static void scale_line_5_8 (uint8_t *source, uint8_t *dest,
                            int width, int step) {
  int p1, p2;
  xine_profiler_start_count(prof_scale_line);
  while ((width -= 8) >= 0) {
    p1 = source[0];
    p2 = source[1];
    dest[0] = p1;
    dest[1] = (3*p1 + 5*p2) >> 3;
    p1 = source[2];
    dest[2] = (3*p2 + 1*p1) >> 2;
    dest[3] = (1*p2 + 7*p1) >> 3;
    p2 = source[3];
    dest[4] = (1*p1 + 1*p2) >> 1;
    p1 = source[4];
    dest[5] = (7*p2 + 1*p1) >> 3;
    dest[6] = (1*p2 + 3*p1) >> 2;
    p2 = source[5];
    dest[7] = (5*p1 + 3*p2) >> 3;
    source += 5;
    dest += 8;
  }
  if ((width += 8) <= 0) goto done;
  *dest++ = source[0];
  if (--width <= 0) goto done;
  *dest++ = (3*source[0] + 5*source[1]) >> 3;
  if (--width <= 0) goto done;
  *dest++ = (3*source[1] + 1*source[2]) >> 2;
  if (--width <= 0) goto done;
  *dest++ = (1*source[1] + 7*source[2]) >> 3;
  if (--width <= 0) goto done;
  *dest++ = (1*source[2] + 1*source[3]) >> 1;
  if (--width <= 0) goto done;
  *dest++ = (7*source[3] + 1*source[4]) >> 3;
  if (--width <= 0) goto done;
  *dest++ = (1*source[3] + 3*source[4]) >> 2;
 done:
  xine_profiler_stop_count(prof_scale_line);
 }
 /*
 * Interpolates 4 output pixels from 3 source pixels using shifts.
 * Useful for scaling a NTSC svcd input source to 4:3 display format.
 */
 static void scale_line_3_4 (uint8_t *source, uint8_t *dest,
                            int width, int step) {
  int p1, p2;
  xine_profiler_start_count(prof_scale_line);
  while ((width -= 4) >= 0) {
    p1 = source[0];
    p2 = source[1];
    dest[0] = p1;
    dest[1] = (1*p1 + 3*p2) >> 2;
    p1 = source[2];
    dest[2] = (1*p2 + 1*p1) >> 1;
    p2 = source[3];
    dest[3] = (3*p1 + 1*p2) >> 2;
    source += 3;
    dest += 4;
  }
  if ((width += 4) <= 0) goto done;
  *dest++ = source[0];
  if (--width <= 0) goto done;
  *dest++ = (1*source[0] + 3*source[1]) >> 2;
  if (--width <= 0) goto done;
  *dest++ = (1*source[1] + 1*source[2]) >> 1;
 done:
  xine_profiler_stop_count(prof_scale_line);
 }
 /* Interpolate 2 output pixels from one source pixel. */
 static void scale_line_1_2 (uint8_t *source, uint8_t *dest,
                            int width, int step) {
  int p1, p2;
  xine_profiler_start_count(prof_scale_line);
  p1 = *source;
  while ((width -= 4) >= 0) {
    *dest++ = p1;
    p2 = *++source;
    *dest++ = (p1 + p2) >> 1;
    *dest++ = p2;
    p1 = *++source;
    *dest++ = (p2 + p1) >> 1;
  }
  if ((width += 4) <= 0) goto done;
  *dest++ = source[0];
  if (--width <= 0) goto done;
  *dest++ = (source[0] + source[1]) >> 1;
  if (--width <= 0) goto done;
  *dest++ = source[1];
 done:
  xine_profiler_stop_count(prof_scale_line);
 }
                        
 /*
 * Scale line with no horizontal scaling. For NTSC mpeg2 dvd input in
 * 4:3 output format (720x480 -> 720x540)
 */
 static void scale_line_1_1 (uint8_t *source, uint8_t *dest,
                            int width, int step) {
  xine_profiler_start_count(prof_scale_line);
  xine_fast_memcpy(dest, source, width);
  xine_profiler_stop_count(prof_scale_line);
 }
                        
 static scale_line_func_t find_scale_line_func(int step) {
  static struct {
            int                 src_step;
            int                 dest_step;
            scale_line_func_tfunc;
            char       *desc;
  } scale_line[] = {
    { 15, 16, scale_line_15_16, "dvd 4:3(pal)" },
    { 45, 64, scale_line_45_64, "dvd 16:9(pal), fullscreen(1024x768)" },
    {  9, 16, scale_line_9_16,  "dvd fullscreen(1280x1024)" },
    { 45, 53, scale_line_45_53, "dvd 16:9(ntsc)" },
    { 11, 12, scale_line_11_12, "vcd 4:3(pal)" },
    { 11, 24, scale_line_11_24, "vcd 4:3(pal) 2*zoom" },
    {  5,  8, scale_line_5_8,   "svcd 4:3(pal)" },
    {  3,  4, scale_line_3_4,   "svcd 4:3(ntsc)" },
    {  1,  2, scale_line_1_2,   "2*zoom" },
    {  1,  1, scale_line_1_1,   "non-scaled" },
  };
  int i;
+        #ifdefLOG
+  /* to filter out multiple messages about the scale_line variant we're using */
+  static int reported_for_step;
+#endif
  for (i = 0; i < sizeof(scale_line)/sizeof(scale_line[0]); i++) {
    if (step == scale_line[i].src_step*32768/scale_line[i].dest_step) {
-        //printf("yuv2rgb: using %s optimized scale_line\n", scale_line[i].desc);
+        #ifdefLOG
+      if (step != reported_for_step)
+        printf("yuv2rgb: using %s optimized scale_line\n", scale_line[i].desc);
+      reported_for_step = step;
+#endif
      return scale_line[i].func;
    }
  }
-  //printf("yuv2rgb: using generic scale_line with interpolation\n");
-  return scale_line_gen;
+        #ifdefLOG
+  if (step != reported_for_step)
+    printf("yuv2rgb: using generic scale_line with interpolation\n");
+  reported_for_step = step;
+#endif
+  return scale_line_gen;
 }
 static void scale_line_2 (uint8_t *source, uint8_t *dest,
                          int width, int step) {
  int p1;
  int p2;
  int dx;
  p1 = *source; source+=2;
  p2 = *source; source+=2;
  dx = 0;
  while (width) {
    *dest = (p1 * (32768 - dx) + p2 * dx) / 32768;
    dx += step;
    while (dx > 32768) {
      dx -= 32768;
      p1 = p2;
      p2 = *source;
      source+=2;
    }
    dest ++;
    width --;
  }
 }
 static void scale_line_4 (uint8_t *source, uint8_t *dest,
                          int width, int step) {
  int p1;
  int p2;
  int dx;
  p1 = *source; source+=4;
  p2 = *source; source+=4;
  dx = 0;
  while (width) {
    *dest = (p1 * (32768 - dx) + p2 * dx) / 32768;
    dx += step;
    while (dx > 32768) {
      dx -= 32768;
      p1 = p2;
      p2 = *source;
      source+=4;
    }
    dest ++;
    width --;
  }
 }
-        #define RGB(i)                                          \
+        #define X_RGB(i)                                                \
                U = pu[i];                                      \
                V = pv[i];                                      \
                r = this->table_rV[V];                          \
                g = (void *) (((uint8_t *)this->table_gU[U]) + this->table_gV[V]);\
        b = this->table_bU[U];
        #define DST1(i)                                 \
        Y = py_1[2*i];                          \
                dst_1[2*i] = r[Y] + g[Y] + b[Y];\
                Y = py_1[2*i+1];                \
        dst_1[2*i+1] = r[Y] + g[Y] + b[Y];
        #define DST2(i)                                 \
                Y = py_2[2*i];                  \
                dst_2[2*i] = r[Y] + g[Y] + b[Y];\
                Y = py_2[2*i+1];                \
        dst_2[2*i+1] = r[Y] + g[Y] + b[Y];
        #define DST1RGB(i)                                              \
                Y = py_1[2*i];                                          \
                dst_1[6*i] = r[Y]; dst_1[6*i+1] = g[Y]; dst_1[6*i+2] = b[Y];\
                Y = py_1[2*i+1];                                        \
        dst_1[6*i+3] = r[Y]; dst_1[6*i+4] = g[Y]; dst_1[6*i+5] = b[Y];
        #define DST2RGB(i)                                              \
                Y = py_2[2*i];                                          \
                dst_2[6*i] = r[Y]; dst_2[6*i+1] = g[Y]; dst_2[6*i+2] = b[Y];\
                Y = py_2[2*i+1];                                        \
        dst_2[6*i+3] = r[Y]; dst_2[6*i+4] = g[Y]; dst_2[6*i+5] = b[Y];
        #define DST1BGR(i)                                              \
                Y = py_1[2*i];                                          \
                dst_1[6*i] = b[Y]; dst_1[6*i+1] = g[Y]; dst_1[6*i+2] = r[Y];\
                Y = py_1[2*i+1];                                        \
        dst_1[6*i+3] = b[Y]; dst_1[6*i+4] = g[Y]; dst_1[6*i+5] = r[Y];
        #define DST2BGR(i)                                              \
                Y = py_2[2*i];                                          \
                dst_2[6*i] = b[Y]; dst_2[6*i+1] = g[Y]; dst_2[6*i+2] = r[Y];\
                Y = py_2[2*i+1];                                        \
        dst_2[6*i+3] = b[Y]; dst_2[6*i+4] = g[Y]; dst_2[6*i+5] = r[Y];
        #define DST1CMAP(i)                                             \
                Y = py_1[2*i];                                          \
                dst_1[2*i] = this->cmap[r[Y] + g[Y] + b[Y]];    \
                Y = py_1[2*i+1];                                        \
        dst_1[2*i+1] = this->cmap[r[Y] + g[Y] + b[Y]];
        #define DST2CMAP(i)                                             \
                Y = py_2[2*i];                                          \
                dst_2[2*i] = this->cmap[r[Y] + g[Y] + b[Y]];    \
                Y = py_2[2*i+1];                                        \
        dst_2[2*i+1] = this->cmap[r[Y] + g[Y] + b[Y]];
 static void yuv2rgb_c_32 (yuv2rgb_t *this, uint8_t * _dst,
                          uint8_t * _py, uint8_t * _pu, uint8_t * _pv)
 {
  int U, V, Y;
  uint8_t  * py_1, * py_2, * pu, * pv;
  uint32_t * r, * g, * b;
  uint32_t * dst_1, * dst_2;
  int width, height, dst_height;
  int dy;
  if (this->do_scale) {
    scale_line_func_t scale_line = this->scale_line;
    scale_line (_pu, this->u_buffer,
                this->dest_width >> 1, this->step_dx);
    scale_line (_pv, this->v_buffer,
                this->dest_width >> 1, this->step_dx);
    scale_line (_py, this->y_buffer, 
                this->dest_width, this->step_dx);
    dy = 0;
-    dst_height = this->dest_height;
+    dst_height = this->next_slice (this, &_dst);
    for (height = 0;; ) {
      dst_1 = (uint32_t*)_dst;
      py_1  = this->y_buffer;
      pu    = this->u_buffer;
      pv    = this->v_buffer;
      width = this->dest_width >> 3;
      do {
-          RGB(0);
+          X_RGB(0);
          DST1(0);
-          RGB(1);
+          X_RGB(1);
          DST1(1);
      
-          RGB(2);
+          X_RGB(2);
          DST1(2);
-          RGB(3);
+          X_RGB(3);
          DST1(3);
          pu += 4;
          pv += 4;
          py_1 += 8;
          dst_1 += 8;
      } while (--width);
      dy += this->step_dy;
      _dst += this->rgb_stride;
      while (--dst_height > 0 && dy < 32768) {
        xine_fast_memcpy (_dst, (uint8_t*)_dst-this->rgb_stride, this->dest_width*4); 
        dy += this->step_dy;
        _dst += this->rgb_stride;
      }
      if (dst_height <= 0)
        break;
      do {
          dy -= 32768;
          _py += this->y_stride;
          scale_line (_py, this->y_buffer, 
                      this->dest_width, this->step_dx);
          if (height & 1) {
              _pu += this->uv_stride;
              _pv += this->uv_stride;
          
              scale_line (_pu, this->u_buffer,
                          this->dest_width >> 1, this->step_dx);
              scale_line (_pv, this->v_buffer,
                          this->dest_width >> 1, this->step_dx);
          
          }
          height++;
      } while( dy>=32768);
    }
  } else {
-    height = this->source_height >> 1;
+    height = this->next_slice (this, &_dst) >> 1;
    do {
      dst_1 = (uint32_t*)_dst;
      dst_2 = (void*)( (uint8_t *)_dst + this->rgb_stride );
      py_1 = _py;
      py_2 = _py + this->y_stride;
      pu   = _pu;
      pv   = _pv;
      width = this->source_width >> 3;
      do {
-        RGB(0);
+        X_RGB(0);
        DST1(0);
        DST2(0);
-        RGB(1);
+        X_RGB(1);
        DST2(1);
        DST1(1);
-        RGB(2);
+        X_RGB(2);
        DST1(2);
        DST2(2);
-        RGB(3);
+        X_RGB(3);
        DST2(3);
        DST1(3);
      
        pu += 4;
        pv += 4;
        py_1 += 8;
        py_2 += 8;
        dst_1 += 8;
        dst_2 += 8;
      } while (--width);
      _dst += 2 * this->rgb_stride; 
      _py += 2 * this->y_stride;
      _pu += this->uv_stride;
      _pv += this->uv_stride;
    } while (--height);
  }
 }
 /* This is very near from the yuv2rgb_c_32 code */
 static void yuv2rgb_c_24_rgb (yuv2rgb_t *this, uint8_t * _dst,
                              uint8_t * _py, uint8_t * _pu, uint8_t * _pv)
 {
  int U, V, Y;
  uint8_t * py_1, * py_2, * pu, * pv;
  uint8_t * r, * g, * b;
  uint8_t * dst_1, * dst_2;
  int width, height, dst_height;
  int dy;
  if (this->do_scale) {
    scale_line_func_t scale_line = this->scale_line;
    scale_line (_pu, this->u_buffer,
                this->dest_width >> 1, this->step_dx);
    scale_line (_pv, this->v_buffer,
                this->dest_width >> 1, this->step_dx);
    scale_line (_py, this->y_buffer, 
                this->dest_width, this->step_dx);
    dy = 0;
-    dst_height = this->dest_height;
+    dst_height = this->next_slice (this, &_dst);
    for (height = 0;; ) {
      dst_1 = _dst;
      py_1  = this->y_buffer;
      pu    = this->u_buffer;
      pv    = this->v_buffer;
      width = this->dest_width >> 3;
      do {
-          RGB(0);
+          X_RGB(0);
          DST1RGB(0);
-          RGB(1);
+          X_RGB(1);
          DST1RGB(1);
      
-          RGB(2);
+          X_RGB(2);
          DST1RGB(2);
-          RGB(3);
+          X_RGB(3);
          DST1RGB(3);
          pu += 4;
          pv += 4;
          py_1 += 8;
          dst_1 += 24;
      } while (--width);
      dy += this->step_dy;
      _dst += this->rgb_stride;
      while (--dst_height > 0 && dy < 32768) {
        xine_fast_memcpy (_dst, _dst-this->rgb_stride, this->dest_width*3); 
        dy += this->step_dy;
        _dst += this->rgb_stride;
      }
      if (dst_height <= 0)
        break;
      do {
          dy -= 32768;
          _py += this->y_stride;
          scale_line (_py, this->y_buffer, 
                      this->dest_width, this->step_dx);
          if (height & 1) {
              _pu += this->uv_stride;
              _pv += this->uv_stride;
          
              scale_line (_pu, this->u_buffer,
                          this->dest_width >> 1, this->step_dx);
              scale_line (_pv, this->v_buffer,
                          this->dest_width >> 1, this->step_dx);
          
          }
          height++;
      } while (dy>=32768);
    }
  } else {
-    height = this->source_height >> 1;
+    height = this->next_slice (this, &_dst) >> 1;
    do {
      dst_1 = _dst;
      dst_2 = (void*)( (uint8_t *)_dst + this->rgb_stride );
      py_1  = _py;
      py_2  = _py + this->y_stride;
      pu    = _pu;
      pv    = _pv;
      width = this->source_width >> 3;
      do {
-        RGB(0);
+        X_RGB(0);
        DST1RGB(0);
        DST2RGB(0);
-        RGB(1);
+        X_RGB(1);
        DST2RGB(1);
        DST1RGB(1);
-        RGB(2);
+        X_RGB(2);
        DST1RGB(2);
        DST2RGB(2);
-        RGB(3);
+        X_RGB(3);
        DST2RGB(3);
        DST1RGB(3);
        pu += 4;
        pv += 4;
        py_1 += 8;
        py_2 += 8;
        dst_1 += 24;
        dst_2 += 24;
      } while (--width);
      _dst += 2 * this->rgb_stride; 
      _py += 2 * this->y_stride;
      _pu += this->uv_stride;
      _pv += this->uv_stride;
      
    } while (--height);
  }
 }
 /* only trivial mods from yuv2rgb_c_24_rgb */
 static void yuv2rgb_c_24_bgr (yuv2rgb_t *this, uint8_t * _dst,
                              uint8_t * _py, uint8_t * _pu, uint8_t * _pv)
 {
  int U, V, Y;
  uint8_t * py_1, * py_2, * pu, * pv;
  uint8_t * r, * g, * b;
  uint8_t * dst_1, * dst_2;
  int width, height, dst_height;
  int dy;
  if (this->do_scale) {
    scale_line_func_t scale_line = this->scale_line;
    scale_line (_pu, this->u_buffer,
                this->dest_width >> 1, this->step_dx);
    scale_line (_pv, this->v_buffer,
                this->dest_width >> 1, this->step_dx);
    scale_line (_py, this->y_buffer, 
                this->dest_width, this->step_dx);
    dy = 0;
-    dst_height = this->dest_height;
+    dst_height = this->next_slice (this, &_dst);
    for (height = 0;; ) {
      dst_1 = _dst;
      py_1  = this->y_buffer;
      pu    = this->u_buffer;
      pv    = this->v_buffer;
      width = this->dest_width >> 3;
      do {
-          RGB(0);
+          X_RGB(0);
          DST1BGR(0);
-          RGB(1);
+          X_RGB(1);
          DST1BGR(1);
      
-          RGB(2);
+          X_RGB(2);
          DST1BGR(2);
-          RGB(3);
+          X_RGB(3);
          DST1BGR(3);
          pu += 4;
          pv += 4;
          py_1 += 8;
          dst_1 += 24;
      } while (--width);
      dy += this->step_dy;
      _dst += this->rgb_stride;
      while (--dst_height > 0 && dy < 32768) {
        xine_fast_memcpy (_dst, _dst-this->rgb_stride, this->dest_width*3);
        dy += this->step_dy;
        _dst += this->rgb_stride;
      }
      if (dst_height <= 0)
        break;
      do {
          dy -= 32768;
          _py += this->y_stride;
          scale_line (_py, this->y_buffer, 
                      this->dest_width, this->step_dx);
          if (height & 1) {
              _pu += this->uv_stride;
              _pv += this->uv_stride;
          
              scale_line (_pu, this->u_buffer,
                          this->dest_width >> 1, this->step_dx);
              scale_line (_pv, this->v_buffer,
                          this->dest_width >> 1, this->step_dx);
          
          }
          height++;
      } while( dy>=32768 );
    }
  } else {
-    height = this->source_height >> 1;
+    height = this->next_slice (this, &_dst) >> 1;
    do {
      dst_1 = _dst;
      dst_2 = (void*)( (uint8_t *)_dst + this->rgb_stride );
      py_1 = _py;
      py_2 = _py + this->y_stride;
      pu   = _pu;
      pv   = _pv;
      width = this->source_width >> 3;
      do {
-        RGB(0);
+        X_RGB(0);
        DST1BGR(0);
        DST2BGR(0);
-        RGB(1);
+        X_RGB(1);
        DST2BGR(1);
        DST1BGR(1);
-        RGB(2);
+        X_RGB(2);
        DST1BGR(2);
        DST2BGR(2);
-        RGB(3);
+        X_RGB(3);
        DST2BGR(3);
        DST1BGR(3);
        pu += 4;
        pv += 4;
        py_1 += 8;
        py_2 += 8;
        dst_1 += 24;
        dst_2 += 24;
      } while (--width);
      _dst += 2 * this->rgb_stride; 
      _py += 2 * this->y_stride;
      _pu += this->uv_stride;
      _pv += this->uv_stride;
    } while (--height);
  }
 }
 /* This is exactly the same code as yuv2rgb_c_32 except for the types of */
 /* r, g, b, dst_1, dst_2 */
 static void yuv2rgb_c_16 (yuv2rgb_t *this, uint8_t * _dst,
                          uint8_t * _py, uint8_t * _pu, uint8_t * _pv)
 {
  int U, V, Y;
  uint8_t * py_1, * py_2, * pu, * pv;
  uint16_t * r, * g, * b;
  uint16_t * dst_1, * dst_2;
  int width, height, dst_height;
  int dy;
  if (this->do_scale) {
    scale_line_func_t scale_line = this->scale_line;
    scale_line (_pu, this->u_buffer,
                this->dest_width >> 1, this->step_dx);
    scale_line (_pv, this->v_buffer,
                this->dest_width >> 1, this->step_dx);
    scale_line (_py, this->y_buffer, 
                this->dest_width, this->step_dx);
    dy = 0;
-    dst_height = this->dest_height;
+    dst_height = this->next_slice (this, &_dst);
    for (height = 0;; ) {
      dst_1 = (uint16_t*)_dst;
      py_1  = this->y_buffer;
      pu    = this->u_buffer;
      pv    = this->v_buffer;
      width = this->dest_width >> 3;
      do {
-          RGB(0);
+          X_RGB(0);
          DST1(0);
-          RGB(1);
+          X_RGB(1);
          DST1(1);
      
-          RGB(2);
+          X_RGB(2);
          DST1(2);
-          RGB(3);
+          X_RGB(3);
          DST1(3);
          pu += 4;
          pv += 4;
          py_1 += 8;
          dst_1 += 8;
      } while (--width);
      dy += this->step_dy;
      _dst += this->rgb_stride;
      while (--dst_height > 0 && dy < 32768) {
        xine_fast_memcpy (_dst, (uint8_t*)_dst-this->rgb_stride, this->dest_width*2); 
        dy += this->step_dy;
        _dst += this->rgb_stride;
      }
      if (dst_height <= 0)
        break;
      do {
          dy -= 32768;
          _py += this->y_stride;
          scale_line (_py, this->y_buffer, 
                      this->dest_width, this->step_dx);
          if (height & 1) {
              _pu += this->uv_stride;
              _pv += this->uv_stride;
          
              scale_line (_pu, this->u_buffer,
                          this->dest_width >> 1, this->step_dx);
              scale_line (_pv, this->v_buffer,
                          this->dest_width >> 1, this->step_dx);
          
          }
          height++;
      } while( dy>=32768);
    }
  } else {
-    height = this->source_height >> 1;
+    height = this->next_slice (this, &_dst) >> 1;
    do {
      dst_1 = (uint16_t*)_dst;
      dst_2 = (void*)( (uint8_t *)_dst + this->rgb_stride );
      py_1 = _py;
      py_2 = _py + this->y_stride;
      pu   = _pu;
      pv   = _pv;
      width = this->source_width >> 3;
      do {
-        RGB(0);
+        X_RGB(0);
        DST1(0);
        DST2(0);
-        RGB(1);
+        X_RGB(1);
        DST2(1);
        DST1(1);
-        RGB(2);
+        X_RGB(2);
        DST1(2);
        DST2(2);
-        RGB(3);
+        X_RGB(3);
        DST2(3);
        DST1(3);
        pu += 4;
        pv += 4;
        py_1 += 8;
        py_2 += 8;
        dst_1 += 8;
        dst_2 += 8;
      } while (--width);
      _dst += 2 * this->rgb_stride; 
      _py += 2 * this->y_stride;
      _pu += this->uv_stride;
      _pv += this->uv_stride;
    } while (--height);
  }
 }
 /* This is exactly the same code as yuv2rgb_c_32 except for the types of */
 /* r, g, b, dst_1, dst_2 */
 static void yuv2rgb_c_8 (yuv2rgb_t *this, uint8_t * _dst,
                          uint8_t * _py, uint8_t * _pu, uint8_t * _pv)
 {
  int U, V, Y;
  uint8_t  * py_1, * py_2, * pu, * pv;
  uint8_t * r, * g, * b;
  uint8_t * dst_1, * dst_2;
  int width, height, dst_height;
  int dy;
  if (this->do_scale) {
    scale_line_func_t scale_line = this->scale_line;
    scale_line (_pu, this->u_buffer,
                this->dest_width >> 1, this->step_dx);
    scale_line (_pv, this->v_buffer,
                this->dest_width >> 1, this->step_dx);
    scale_line (_py, this->y_buffer, 
                this->dest_width, this->step_dx);
    dy = 0;
-    dst_height = this->dest_height;
+    dst_height = this->next_slice (this, &_dst);
    for (height = 0;; ) {
      dst_1 = (uint8_t*)_dst;
      py_1  = this->y_buffer;
      pu    = this->u_buffer;
      pv    = this->v_buffer;
      width = this->dest_width >> 3;
      do {
-          RGB(0);
+          X_RGB(0);
          DST1(0);
-          RGB(1);
+          X_RGB(1);
          DST1(1);
      
-          RGB(2);
+          X_RGB(2);
          DST1(2);
-          RGB(3);
+          X_RGB(3);
          DST1(3);
          pu += 4;
          pv += 4;
          py_1 += 8;
          dst_1 += 8;
      } while (--width);
      dy += this->step_dy;
      _dst += this->rgb_stride;
      while (--dst_height > 0 && dy < 32768) {
        xine_fast_memcpy (_dst, (uint8_t*)_dst-this->rgb_stride, this->dest_width); 
        dy += this->step_dy;
        _dst += this->rgb_stride;
      }
      if (dst_height <= 0)
        break;
      do {
          dy -= 32768;
          _py += this->y_stride;
          scale_line (_py, this->y_buffer, 
                      this->dest_width, this->step_dx);
          if (height & 1) {
              _pu += this->uv_stride;
              _pv += this->uv_stride;
          
              scale_line (_pu, this->u_buffer,
                          this->dest_width >> 1, this->step_dx);
              scale_line (_pv, this->v_buffer,
                          this->dest_width >> 1, this->step_dx);
          
          }
          height++;
      } while( dy>=32768 );
    }
  } else {
-    height = this->source_height >> 1;
+    height = this->next_slice (this, &_dst) >> 1;
    do {
      dst_1 = (uint8_t*)_dst;
      dst_2 = (void*)( (uint8_t *)_dst + this->rgb_stride );
      py_1 = _py;
      py_2 = _py + this->y_stride;
      pu   = _pu;
      pv   = _pv;
      width = this->source_width >> 3;
      do {
-        RGB(0);
+        X_RGB(0);
        DST1(0);
        DST2(0);
-        RGB(1);
+        X_RGB(1);
        DST2(1);
        DST1(1);
-        RGB(2);
+        X_RGB(2);
        DST1(2);
        DST2(2);
-        RGB(3);
+        X_RGB(3);
        DST2(3);
        DST1(3);
      
        pu += 4;
        pv += 4;
        py_1 += 8;
        py_2 += 8;
        dst_1 += 8;
        dst_2 += 8;
      } while (--width);
      _dst += 2 * this->rgb_stride; 
      _py += 2 * this->y_stride;
      _pu += this->uv_stride;
      _pv += this->uv_stride;
    } while (--height);
  }
 }
 /* now for something different: 256 grayscale mode */
 static void yuv2rgb_c_gray (yuv2rgb_t *this, uint8_t * _dst,
                            uint8_t * _py, uint8_t * _pu, uint8_t * _pv)
 {
  int height, dst_height;
  int dy;
  if (this->do_scale) {
    scale_line_func_t scale_line = this->scale_line;
    dy = 0;
-    dst_height = this->dest_height;
+    dst_height = this->next_slice (this, &_dst);
    for (;;) {
      scale_line (_py, _dst, this->dest_width, this->step_dx);
      dy += this->step_dy;
      _dst += this->rgb_stride;
      while (--dst_height > 0 && dy < 32768) {
        xine_fast_memcpy (_dst, (uint8_t*)_dst-this->rgb_stride, this->dest_width); 
        dy += this->step_dy;
        _dst += this->rgb_stride;
      }
      if (dst_height <= 0)
        break;
      _py += this->y_stride*(dy>>15);
      dy &= 32767;
      /* dy -= 32768; 
         _py += this->y_stride;
      */
    }
  } else {
-    for (height = this->source_height; --height >= 0; ) {
+    for (height = this->next_slice (this, &_dst); --height >= 0; ) {
      xine_fast_memcpy(_dst, _py, this->dest_width);
      _dst += this->rgb_stride;
      _py += this->y_stride;
    }
  }
 }
 /* now for something different: 256 color mode */
 static void yuv2rgb_c_palette (yuv2rgb_t *this, uint8_t * _dst,
                               uint8_t * _py, uint8_t * _pu, uint8_t * _pv)
 {
  int U, V, Y;
  uint8_t * py_1, * py_2, * pu, * pv;
  uint16_t * r, * g, * b;
  uint8_t * dst_1, * dst_2;
  int width, height, dst_height;
  int dy;
  if (this->do_scale) {
    scale_line_func_t scale_line = this->scale_line;
    scale_line (_pu, this->u_buffer,
                this->dest_width >> 1, this->step_dx);
    scale_line (_pv, this->v_buffer,
                this->dest_width >> 1, this->step_dx);
    scale_line (_py, this->y_buffer,
                this->dest_width, this->step_dx);
    dy = 0;
-    dst_height = this->dest_height;
+    dst_height = this->next_slice (this, &_dst);
    for (height = 0;; ) {
      dst_1 = _dst;
      py_1  = this->y_buffer;
      pu    = this->u_buffer;
      pv    = this->v_buffer;
      width = this->dest_width >> 3;
      do {
-          RGB(0);
+          X_RGB(0);
          DST1CMAP(0);
-          RGB(1);
+          X_RGB(1);
          DST1CMAP(1);
      
-          RGB(2);
+          X_RGB(2);
          DST1CMAP(2);
-          RGB(3);
+          X_RGB(3);
          DST1CMAP(3);
          pu += 4;
          pv += 4;
          py_1 += 8;
          dst_1 += 8;
      } while (--width);
      dy += this->step_dy;
      _dst += this->rgb_stride;
      while (--dst_height > 0 && dy < 32768) {
        xine_fast_memcpy (_dst, (uint8_t*)_dst-this->rgb_stride, this->dest_width); 
        dy += this->step_dy;
        _dst += this->rgb_stride;
      }
      if (dst_height <= 0)
        break;
      do {
          dy -= 32768;
          _py += this->y_stride;
          scale_line (_py, this->y_buffer,
                      this->dest_width, this->step_dx);
          if (height & 1) {
              _pu += this->uv_stride;
              _pv += this->uv_stride;
          
              scale_line (_pu, this->u_buffer,
                          this->dest_width >> 1, this->step_dx);
              scale_line (_pv, this->v_buffer,
                          this->dest_width >> 1, this->step_dx);
          
          }
          height++;
      } while( dy>=32768 );
    }
  } else {
-    height = this->source_height >> 1;
+    height = this->next_slice (this, &_dst) >> 1;
    do {
      dst_1 = _dst;
      dst_2 = _dst + this->rgb_stride;
      py_1 = _py;
      py_2 = _py + this->y_stride;
      pu   = _pu;
      pv   = _pv;
      width = this->source_width >> 3;
      do {
-        RGB(0);
+        X_RGB(0);
        DST1CMAP(0);
        DST2CMAP(0);
-        RGB(1);
+        X_RGB(1);
        DST2CMAP(1);
        DST1CMAP(1);
-        RGB(2);
+        X_RGB(2);
        DST1CMAP(2);
        DST2CMAP(2);
-        RGB(3);
+        X_RGB(3);
        DST2CMAP(3);
        DST1CMAP(3);
        pu += 4;
        pv += 4;
        py_1 += 8;
        py_2 += 8;
        dst_1 += 8;
        dst_2 += 8;
      } while (--width);
      _dst += 2 * this->rgb_stride; 
      _py += 2 * this->y_stride;
      _pu += this->uv_stride;
      _pv += this->uv_stride;
    } while (--height);
  }
 }
 static int div_round (int dividend, int divisor)
 {
  if (dividend > 0)
    return (dividend + (divisor>>1)) / divisor;
  else
    return -((-dividend + (divisor>>1)) / divisor);
 }
-static void yuv2rgb_setup_tables (yuv2rgb_factory_t *this, int mode, int swapped) 
+static void yuv2rgb_set_csc_levels (yuv2rgb_factory_t *this,
+                                    int brightness, int contrast, int saturation)
 {
  int i;
  uint8_t table_Y[1024];
  uint32_t * table_32 = 0;
  uint16_t * table_16 = 0;
  uint8_t * table_8 = 0;
  int entry_size = 0;
  void *table_r = 0, *table_g = 0, *table_b = 0;
  int shift_r = 0, shift_g = 0, shift_b = 0;
  int crv = Inverse_Table_6_9[this->matrix_coefficients][0];
  int cbu = Inverse_Table_6_9[this->matrix_coefficients][1];
  int cgu = -Inverse_Table_6_9[this->matrix_coefficients][2];
  int cgv = -Inverse_Table_6_9[this->matrix_coefficients][3];
+  int mode = this->mode;
+  int swapped = this->swapped;
  for (i = 0; i < 1024; i++) {
    int j;
-    j = (76309 * (i - 384 - 16) + 32768) >> 16;
+    j = (76309 * (i - 384 - 16 + brightness) + 32768) >> 16;
    j = (j < 0) ? 0 : ((j > 255) ? 255 : j);
    table_Y[i] = j;
  }
  switch (mode) {
  case MODE_32_RGB:
  case MODE_32_BGR:
-    table_32 = malloc ((197 + 2*682 + 256 + 132) * sizeof (uint32_t));
+    if (this->table_base == NULL) {
+      this->table_base = malloc ((197 + 2*682 + 256 + 132) * sizeof (uint32_t));
+    }
+    table_32 = this->table_base;
    entry_size = sizeof (uint32_t);
    table_r = table_32 + 197;
    table_b = table_32 + 197 + 685;
    table_g = table_32 + 197 + 2*682;
    if (swapped) {
      switch (mode) {
      case MODE_32_RGB: shift_r =  8; shift_g = 16; shift_b = 24; break;
              case MODE_32_BGR:shift_r = 24; shift_g = 16; shift_b =  8; break;
      }
    } else {
      switch (mode) {
              case MODE_32_RGB:shift_r = 16; shift_g =  8; shift_b =  0; break;
              case MODE_32_BGR:shift_r =  0; shift_g =  8; shift_b = 16; break;
      }
    }
    for (i = -197; i < 256+197; i++)
      ((uint32_t *) table_r)[i] = table_Y[i+384] << shift_r;
    for (i = -132; i < 256+132; i++)
      ((uint32_t *) table_g)[i] = table_Y[i+384] << shift_g;
    for (i = -232; i < 256+232; i++)
      ((uint32_t *) table_b)[i] = table_Y[i+384] << shift_b;
    break;
  case MODE_24_RGB:
  case MODE_24_BGR:
-    table_8 = malloc ((256 + 2*232) * sizeof (uint8_t));
+    if (this->table_base == NULL) {
+      this->table_base = malloc ((256 + 2*232) * sizeof (uint8_t));
+    }
+    table_8 = this->table_base;
    entry_size = sizeof (uint8_t);
    table_r = table_g = table_b = table_8 + 232;
    for (i = -232; i < 256+232; i++)
      ((uint8_t * )table_b)[i] = table_Y[i+384];
    break;
  case MODE_15_BGR:
  case MODE_16_BGR:
  case MODE_15_RGB:
  case MODE_16_RGB:
-    table_16 = malloc ((197 + 2*682 + 256 + 132) * sizeof (uint16_t));
+    if (this->table_base == NULL) {
+      this->table_base = malloc ((197 + 2*682 + 256 + 132) * sizeof (uint16_t));
+    }
+    table_16 = this->table_base;
    entry_size = sizeof (uint16_t);
    table_r = table_16 + 197;
    table_b = table_16 + 197 + 685;
    table_g = table_16 + 197 + 2*682;
    if (swapped) {
      switch (mode) {
      case MODE_15_BGR: shift_r =  8; shift_g =  5; shift_b = 2; break;
              case MODE_16_BGR:shift_r =  8; shift_g =  5; shift_b = 3; break;
              case MODE_15_RGB:shift_r =  2; shift_g =  5; shift_b = 8; break;
              case MODE_16_RGB:shift_r =  3; shift_g =  5; shift_b = 8; break;
      }
    } else {
      switch (mode) {
              case MODE_15_BGR:shift_r =  0; shift_g =  5; shift_b = 10; break;
              case MODE_16_BGR:shift_r =  0; shift_g =  5; shift_b = 11; break;
              case MODE_15_RGB:shift_r = 10; shift_g =  5; shift_b =  0; break;
              case MODE_16_RGB:shift_r = 11; shift_g =  5; shift_b =  0; break;
      }
    }
    for (i = -197; i < 256+197; i++)
      ((uint16_t *)table_r)[i] = (table_Y[i+384] >> 3) << shift_r;
    for (i = -132; i < 256+132; i++) {
      int j = table_Y[i+384] >> (((mode==MODE_16_RGB) || (mode==MODE_16_BGR)) ? 2 : 3);
      if (swapped)
        ((uint16_t *)table_g)[i] = (j&7) << 13 | (j>>3);
      else
        ((uint16_t *)table_g)[i] = j << 5;
    }
    for (i = -232; i < 256+232; i++)
      ((uint16_t *)table_b)[i] = (table_Y[i+384] >> 3) << shift_b;
    break;
  case MODE_8_RGB:
  case MODE_8_BGR:
-    table_8 = malloc ((197 + 2*682 + 256 + 132) * sizeof (uint8_t));
+    if (this->table_base == NULL) {
+      this->table_base = malloc ((197 + 2*682 + 256 + 132) * sizeof (uint8_t));
+    }
+    table_8 = this->table_base;
    entry_size = sizeof (uint8_t);
    table_r = table_8 + 197;
    table_b = table_8 + 197 + 685;
    table_g = table_8 + 197 + 2*682;
    switch (mode) {
    case MODE_8_RGB: shift_r =  5; shift_g =  2; shift_b =  0; break;
    case MODE_8_BGR: shift_r =  0; shift_g =  3; shift_b =  6; break;
    }
    for (i = -197; i < 256+197; i++)
      ((uint8_t *) table_r)[i] = (table_Y[i+384] >> 5) << shift_r;
    for (i = -132; i < 256+132; i++)
      ((uint8_t *) table_g)[i] = (table_Y[i+384] >> 5) << shift_g;
    for (i = -232; i < 256+232; i++)
      ((uint8_t *) table_b)[i] = (table_Y[i+384] >> 6) << shift_b;
    break;
  case MODE_8_GRAY:
    return;
  case MODE_PALETTE:
-    table_16 = malloc ((197 + 2*682 + 256 + 132) * sizeof (uint16_t));
+    if (this->table_base == NULL) {
+      this->table_base = malloc ((197 + 2*682 + 256 + 132) * sizeof (uint16_t));
+    }
+    table_16 = this->table_base;
    entry_size = sizeof (uint16_t);
    table_r = table_16 + 197;
    table_b = table_16 + 197 + 685;
    table_g = table_16 + 197 + 2*682;
    shift_r = 10;
    shift_g = 5;
    shift_b = 0;
    for (i = -197; i < 256+197; i++)
      ((uint16_t *)table_r)[i] = (table_Y[i+384] >> 3) << 10;
    for (i = -132; i < 256+132; i++)
      ((uint16_t *)table_g)[i] = (table_Y[i+384] >> 3) << 5;
    for (i = -232; i < 256+232; i++)
      ((uint16_t *)table_b)[i] = (table_Y[i+384] >> 3) << 0;
    break;
  default:
-    fprintf (stderr, "mode %d not supported by yuv2rgb\n", mode);
+    lprintf ("mode %d not supported by yuv2rgb\n", mode);
-    abort();
+    _x_abort();
  }
  
  for (i = 0; i < 256; i++) {
    this->table_rV[i] = (((uint8_t *) table_r) +
                         entry_size * div_round (crv * (i-128), 76309));
    this->table_gU[i] = (((uint8_t *) table_g) +
                         entry_size * div_round (cgu * (i-128), 76309));
    this->table_gV[i] = entry_size * div_round (cgv * (i-128), 76309);
    this->table_bU[i] = (((uint8_t *)table_b) +
                         entry_size * div_round (cbu * (i-128), 76309));
  }
-  this->gamma = 0;
-  this->entry_size = entry_size;
+#if defined(ARCH_X86) || defined(ARCH_X86_64)
+  mmx_yuv2rgb_set_csc_levels (this, brightness, contrast, saturation);
+#endif  
 }
 static uint32_t yuv2rgb_single_pixel_32 (yuv2rgb_t *this, uint8_t y, uint8_t u, uint8_t v)
 {
  uint32_t * r, * g, * b;
  r = this->table_rV[v];
  g = (void *) (((uint8_t *)this->table_gU[u]) + this->table_gV[v]);
  b = this->table_bU[u];
  return r[y] + g[y] + b[y];
 }
 static uint32_t yuv2rgb_single_pixel_24_rgb (yuv2rgb_t *this, uint8_t y, uint8_t u, uint8_t v)
 {
  uint8_t * r, * g, * b;
  r = this->table_rV[v];
  g = (void *) (((uint8_t *)this->table_gU[u]) + this->table_gV[v]);
  b = this->table_bU[u];
  return (uint32_t) r[y] +
          ((uint32_t) g[y] << 8) +
          ((uint32_t) b[y] << 16);
 }
 static uint32_t yuv2rgb_single_pixel_24_bgr (yuv2rgb_t *this, uint8_t y, uint8_t u, uint8_t v)
 {
  uint8_t * r, * g, * b;
  r = this->table_rV[v];
  g = (void *) (((uint8_t *)this->table_gU[u]) + this->table_gV[v]);
  b = this->table_bU[u];
  return (uint32_t) b[y] +
          ((uint32_t) g[y] << 8) +
          ((uint32_t) r[y] << 16);
 }
 static uint32_t yuv2rgb_single_pixel_16 (yuv2rgb_t *this, uint8_t y, uint8_t u, uint8_t v)
 {
  uint16_t * r, * g, * b;
  r = this->table_rV[v];
  g = (void *) (((uint8_t *)this->table_gU[u]) + this->table_gV[v]);
  b = this->table_bU[u];
  return r[y] + g[y] + b[y];
 }
 static uint32_t yuv2rgb_single_pixel_8 (yuv2rgb_t *this, uint8_t y, uint8_t u, uint8_t v)
 {
  uint8_t * r, * g, * b;
  r = this->table_rV[v];
  g = (void *) (((uint8_t *)this->table_gU[u]) + this->table_gV[v]);
  b = this->table_bU[u];
  return r[y] + g[y] + b[y];
 }
 static uint32_t yuv2rgb_single_pixel_gray (yuv2rgb_t *this, uint8_t y, uint8_t u, uint8_t v)
 {
  return y;
 }
 static uint32_t yuv2rgb_single_pixel_palette (yuv2rgb_t *this, uint8_t y, uint8_t u, uint8_t v)
 {
  uint16_t * r, * g, * b;
  r = this->table_rV[v];
  g = (void *) (((uint8_t *)this->table_gU[u]) + this->table_gV[v]);
  b = this->table_bU[u];
  return this->cmap[r[y] + g[y] + b[y]];
 }
 static void yuv2rgb_c_init (yuv2rgb_factory_t *this)
 {
  switch (this->mode) {
  case MODE_32_RGB:
  case MODE_32_BGR:
    this->yuv2rgb_fun = yuv2rgb_c_32;
    break;
  case MODE_24_RGB:
  case MODE_24_BGR:
    this->yuv2rgb_fun =
        (this->mode==MODE_24_RGB && !this->swapped) || (this->mode==MODE_24_BGR && this->swapped)
            ? yuv2rgb_c_24_rgb
            : yuv2rgb_c_24_bgr;
    break;
  case MODE_15_BGR:
  case MODE_16_BGR:
  case MODE_15_RGB:
  case MODE_16_RGB:
    this->yuv2rgb_fun = yuv2rgb_c_16;
    break;
  case MODE_8_RGB:
  case MODE_8_BGR:
    this->yuv2rgb_fun = yuv2rgb_c_8;
    break;
  case MODE_8_GRAY:
    this->yuv2rgb_fun = yuv2rgb_c_gray;
    break;
  case MODE_PALETTE:
    this->yuv2rgb_fun = yuv2rgb_c_palette;
    break;
  default:
-    printf ("yuv2rgb: mode %d not supported by yuv2rgb\n", this->mode);
+    lprintf ("mode %d not supported by yuv2rgb\n", this->mode);
-    abort();
+    _x_abort();
  }
 }
 static void yuv2rgb_single_pixel_init (yuv2rgb_factory_t *this) {
  switch (this->mode) {
  case MODE_32_RGB:
  case MODE_32_BGR:
    this->yuv2rgb_single_pixel_fun = yuv2rgb_single_pixel_32;
    break;
  case MODE_24_RGB:
  case MODE_24_BGR:
    this->yuv2rgb_single_pixel_fun =
        (this->mode==MODE_24_RGB && !this->swapped) || (this->mode==MODE_24_BGR && this->swapped)
            ? yuv2rgb_single_pixel_24_rgb
            : yuv2rgb_single_pixel_24_bgr;
    break;
  case MODE_15_BGR:
  case MODE_16_BGR:
  case MODE_15_RGB:
  case MODE_16_RGB:
    this->yuv2rgb_single_pixel_fun = yuv2rgb_single_pixel_16;
    break;
  case MODE_8_RGB:
  case MODE_8_BGR:
    this->yuv2rgb_single_pixel_fun = yuv2rgb_single_pixel_8;
    break;
  case MODE_8_GRAY:
    this->yuv2rgb_single_pixel_fun = yuv2rgb_single_pixel_gray;
    break;
  case MODE_PALETTE:
    this->yuv2rgb_single_pixel_fun = yuv2rgb_single_pixel_palette;
    break;
  default:
-    printf ("yuv2rgb: mode %d not supported by yuv2rgb\n", this->mode);
+    lprintf ("mode %d not supported by yuv2rgb\n", this->mode);
-    abort();
+    _x_abort();
  }
 }
 /*
 * yuy2 stuff
 */
 static void yuy22rgb_c_32 (yuv2rgb_t *this, uint8_t * _dst, uint8_t * _p)
 {
  int U, V, Y;
  uint8_t * py_1, * pu, * pv;
  uint32_t * r, * g, * b;
  uint32_t * dst_1;
  int width, height;
  int dy;
  /* FIXME: implement unscaled version */
  scale_line_4 (_p+1, this->u_buffer,
                this->dest_width >> 1, this->step_dx);
  scale_line_4 (_p+3, this->v_buffer,
                this->dest_width >> 1, this->step_dx);
  scale_line_2 (_p, this->y_buffer,
                this->dest_width, this->step_dx);
  
  dy = 0;
-  height = this->dest_height;
+  height = this->next_slice (this, &_dst);
  
  for (;;) {
    dst_1 = (uint32_t*)_dst;
    py_1  = this->y_buffer;
    pu    = this->u_buffer;
    pv    = this->v_buffer;
    width = this->dest_width >> 3;
    do {
-      RGB(0);
+      X_RGB(0);
      DST1(0);
-      RGB(1);
+      X_RGB(1);
      DST1(1);
      
-      RGB(2);
+      X_RGB(2);
      DST1(2);
      
-      RGB(3);
+      X_RGB(3);
      DST1(3);
      pu += 4;
      pv += 4;
      py_1 += 8;
      dst_1 += 8;
    } while (--width);
    
    dy += this->step_dy;
    _dst += this->rgb_stride;
    
    while (--height > 0 && dy < 32768) {
      
      xine_fast_memcpy (_dst, (uint8_t*)_dst-this->rgb_stride, this->dest_width*4);
      
      dy += this->step_dy;
      _dst += this->rgb_stride;
    }
    
    if (height <= 0)
      break;
-    _p += this->y_stride*2*(dy>>15);
+    _p += this->y_stride*(dy>>15);
    dy &= 32767;
    /*
      dy -= 32768;
      _p += this->y_stride*2;
    */
    
    scale_line_4 (_p+1, this->u_buffer,
                  this->dest_width >> 1, this->step_dx);
    scale_line_4 (_p+3, this->v_buffer,
                  this->dest_width >> 1, this->step_dx);
    scale_line_2 (_p, this->y_buffer, 
                  this->dest_width, this->step_dx);
  }
 }
 static void yuy22rgb_c_24_rgb (yuv2rgb_t *this, uint8_t * _dst, uint8_t * _p)
 {
  int U, V, Y;
  uint8_t * py_1, * pu, * pv;
  uint8_t * r, * g, * b;
  uint8_t * dst_1;
  int width, height;
  int dy;
  /* FIXME: implement unscaled version */
  scale_line_4 (_p+1, this->u_buffer,
                this->dest_width >> 1, this->step_dx);
  scale_line_4 (_p+3, this->v_buffer,
                this->dest_width >> 1, this->step_dx);
  scale_line_2 (_p, this->y_buffer, 
                this->dest_width, this->step_dx);
  dy = 0;
-  height = this->dest_height;
+  height = this->next_slice (this, &_dst);
  
  for (;;) {
    dst_1 = _dst;
    py_1  = this->y_buffer;
    pu    = this->u_buffer;
    pv    = this->v_buffer;
    
    width = this->dest_width >> 3;
    
    do {
-      RGB(0);
+      X_RGB(0);
      DST1RGB(0);
      
-      RGB(1);
+      X_RGB(1);
      DST1RGB(1);
      
-      RGB(2);
+      X_RGB(2);
      DST1RGB(2);
      
-      RGB(3);
+      X_RGB(3);
      DST1RGB(3);
      pu += 4;
      pv += 4;
      py_1 += 8;
      dst_1 += 24;
    } while (--width);
    dy += this->step_dy;
    _dst += this->rgb_stride;
    
    while (--height > 0 && dy < 32768) {
      xine_fast_memcpy (_dst, (uint8_t*)_dst-this->rgb_stride, this->dest_width*3);
      
      dy += this->step_dy;
      _dst += this->rgb_stride;
    }
    
    if (height <= 0)
      break;
-    _p += this->y_stride*2*(dy>>15);
+    _p += this->y_stride*(dy>>15);
    dy &= 32767;
    /*
      dy -= 32768;
      _p += this->y_stride*2;
    */
    
    scale_line_4 (_p+1, this->u_buffer,
                  this->dest_width >> 1, this->step_dx);
    scale_line_4 (_p+3, this->v_buffer,
                  this->dest_width >> 1, this->step_dx);
    scale_line_2 (_p, this->y_buffer,
                  this->dest_width, this->step_dx);
  }
 }
 static void yuy22rgb_c_24_bgr (yuv2rgb_t *this, uint8_t * _dst, uint8_t * _p)
 {
  int U, V, Y;
  uint8_t * py_1, * pu, * pv;
  uint8_t * r, * g, * b;
  uint8_t * dst_1;
  int width, height;
  int dy;
  /* FIXME: implement unscaled version */
  scale_line_4 (_p+1, this->u_buffer,
                this->dest_width >> 1, this->step_dx);
  scale_line_4 (_p+3, this->v_buffer,
                this->dest_width >> 1, this->step_dx);
  scale_line_2 (_p, this->y_buffer, 
                this->dest_width, this->step_dx);
  dy = 0;
-  height = this->dest_height;
+  height = this->next_slice (this, &_dst);
  
  for (;;) {
    dst_1 = _dst;
    py_1  = this->y_buffer;
    pu    = this->u_buffer;
    pv    = this->v_buffer;
    
    width = this->dest_width >> 3;
    
    do {
-      RGB(0);
+      X_RGB(0);
      DST1BGR(0);
      
-      RGB(1);
+      X_RGB(1);
      DST1BGR(1);
      
-      RGB(2);
+      X_RGB(2);
      DST1BGR(2);
-      RGB(3);
+      X_RGB(3);
      DST1BGR(3);
      
      pu += 4;
      pv += 4;
      py_1 += 8;
      dst_1 += 24;
    } while (--width);
    
    dy += this->step_dy;
    _dst += this->rgb_stride;
    
    while (--height > 0 && dy < 32768) {
      xine_fast_memcpy (_dst, (uint8_t*)_dst-this->rgb_stride, this->dest_width*3);
      
      dy += this->step_dy;
      _dst += this->rgb_stride;
    }
    
    if (height <= 0)
      break;
-    _p += this->y_stride*2*(dy>>15);
+    _p += this->y_stride*(dy>>15);
    dy &= 32767;
    scale_line_4 (_p+1, this->u_buffer,
                  this->dest_width >> 1, this->step_dx);
    scale_line_4 (_p+3, this->v_buffer,
                  this->dest_width >> 1, this->step_dx);
    scale_line_2 (_p, this->y_buffer,
                  this->dest_width, this->step_dx);
  }
 }
 static void yuy22rgb_c_16 (yuv2rgb_t *this, uint8_t * _dst, uint8_t * _p)
 {
  int U, V, Y;
  uint8_t * py_1, * pu, * pv;
  uint16_t * r, * g, * b;
  uint16_t * dst_1;
  int width, height;
  int dy;
  /* FIXME: implement unscaled version */
  scale_line_4 (_p+1, this->u_buffer,
                this->dest_width >> 1, this->step_dx);
  scale_line_4 (_p+3, this->v_buffer,
                this->dest_width >> 1, this->step_dx);
  scale_line_2 (_p, this->y_buffer, 
                this->dest_width, this->step_dx);
  
  dy = 0;
-  height = this->dest_height;
+  height = this->next_slice (this, &_dst);
  for (;;) {
    dst_1 = (uint16_t*)_dst;
    py_1  = this->y_buffer;
    pu    = this->u_buffer;
    pv    = this->v_buffer;
    
    width = this->dest_width >> 3;
    
    do {
-      RGB(0);
+      X_RGB(0);
      DST1(0);
-      RGB(1);
+      X_RGB(1);
      DST1(1);
      
-      RGB(2);
+      X_RGB(2);
      DST1(2);
      
-      RGB(3);
+      X_RGB(3);
      DST1(3);
      pu += 4;
      pv += 4;
      py_1 += 8;
      dst_1 += 8;
    } while (--width);
    
    dy += this->step_dy;
    _dst += this->rgb_stride;
    while (--height > 0 && dy < 32768) {
      
      xine_fast_memcpy (_dst, (uint8_t*)_dst-this->rgb_stride, this->dest_width*2); 
      dy += this->step_dy;
      _dst += this->rgb_stride;
    }
    
    if (height <= 0)
      break;
-    _p += this->y_stride*2*(dy>>15);
+    _p += this->y_stride*(dy>>15);
    dy &= 32767;
    
    scale_line_4 (_p+1, this->u_buffer,
                  this->dest_width >> 1, this->step_dx);
    scale_line_4 (_p+3, this->v_buffer,
                  this->dest_width >> 1, this->step_dx);
    scale_line_2 (_p, this->y_buffer,
                  this->dest_width, this->step_dx);
  }
 }
 static void yuy22rgb_c_8 (yuv2rgb_t *this, uint8_t * _dst, uint8_t * _p)
 {
  int U, V, Y;
  uint8_t * py_1, * pu, * pv;
  uint8_t * r, * g, * b;
  uint8_t * dst_1;
  int width, height;
  int dy;
  /* FIXME: implement unscaled version */
  scale_line_4 (_p+1, this->u_buffer,
                this->dest_width >> 1, this->step_dx);
  scale_line_4 (_p+3, this->v_buffer,
                this->dest_width >> 1, this->step_dx);
  scale_line_2 (_p, this->y_buffer,
                this->dest_width, this->step_dx);
  
  dy = 0;
-  height = this->dest_height;
+  height = this->next_slice (this, &_dst);
  
  for (;;) {
    dst_1 = _dst;
    py_1  = this->y_buffer;
    pu    = this->u_buffer;
    pv    = this->v_buffer;
    
    width = this->dest_width >> 3;
    
    do {
-      RGB(0);
+      X_RGB(0);
      DST1(0);
      
-      RGB(1);
+      X_RGB(1);
      DST1(1);
-      RGB(2);
+      X_RGB(2);
      DST1(2);
      
-      RGB(3);
+      X_RGB(3);
      DST1(3);
      pu += 4;
      pv += 4;
      py_1 += 8;
      dst_1 += 8;
    } while (--width);
    
    dy += this->step_dy;
    _dst += this->rgb_stride;
    
    while (--height > 0 && dy < 32768) {
      
      xine_fast_memcpy (_dst, (uint8_t*)_dst-this->rgb_stride, this->dest_width); 
      
      dy += this->step_dy;
      _dst += this->rgb_stride;
    }
    
    if (height <= 0)
      break;
-    _p += this->y_stride*2*(dy>>15);
+    _p += this->y_stride*(dy>>15);
    dy &= 32767;
    
    scale_line_4 (_p+1, this->u_buffer,
                  this->dest_width >> 1, this->step_dx);
    scale_line_4 (_p+3, this->v_buffer,
                  this->dest_width >> 1, this->step_dx);
    scale_line_2 (_p, this->y_buffer, 
                  this->dest_width, this->step_dx);
  }
 }
 static void yuy22rgb_c_gray (yuv2rgb_t *this, uint8_t * _dst, uint8_t * _p)
 {
  int width, height;
  int dy;
  uint8_t * dst;
  uint8_t * y;
  if (this->do_scale) {
    dy = 0;
-    height = this->dest_height;
+    height = this->next_slice (this, &_dst);
  
    for (;;) {
      scale_line_2 (_p, _dst, this->dest_width, this->step_dx);
    
      dy += this->step_dy;
      _dst += this->rgb_stride;
    
      while (--height > 0 && dy < 32768) {
      
        xine_fast_memcpy (_dst, (uint8_t*)_dst-this->rgb_stride, this->dest_width); 
      
        dy += this->step_dy;
        _dst += this->rgb_stride;
      }
    
      if (height <= 0)
        break;
-      _p += this->y_stride*2*(dy>>15);
+      _p += this->y_stride*(dy>>15);
      dy &= 32767;
    }
  } else {
-    for (height = this->source_height; --height >= 0; ) { 
+    for (height = this->next_slice (this, &_dst); --height >= 0; ) { 
      dst = _dst;
      y = _p;
      for (width = this->source_width; --width >= 0; ) {
        *dst++ = *y;
        y += 2;
      }
      _dst += this->rgb_stride;
-      _p += this->y_stride*2;
+      _p += this->y_stride;
    }
  }
 }
 static void yuy22rgb_c_palette (yuv2rgb_t *this, uint8_t * _dst, uint8_t * _p)
 {
  int U, V, Y;
  uint8_t * py_1, * pu, * pv;
  uint16_t * r, * g, * b;
  uint8_t * dst_1;
  int width, height;
  int dy;
  
  scale_line_4 (_p+1, this->u_buffer,
                this->dest_width >> 1, this->step_dx);
  scale_line_4 (_p+3, this->v_buffer,
                this->dest_width >> 1, this->step_dx);
  scale_line_2 (_p, this->y_buffer,
                this->dest_width, this->step_dx);
    
  dy = 0;
-  height = this->dest_height;
+  height = this->next_slice (this, &_dst);
  
  for (;;) {
    dst_1 = _dst;
    py_1  = this->y_buffer;
    pu    = this->u_buffer;
    pv    = this->v_buffer;
    
    width = this->dest_width >> 3;
    
    do {
-      RGB(0);
+      X_RGB(0);
      DST1CMAP(0);
-      RGB(1);
+      X_RGB(1);
      DST1CMAP(1);
-      RGB(2);
+      X_RGB(2);
      DST1CMAP(2);
-      RGB(3);
+      X_RGB(3);
      DST1CMAP(3);
      pu += 4;
      pv += 4;
      py_1 += 8;
      dst_1 += 8;
    } while (--width);
    dy += this->step_dy;
    _dst += this->rgb_stride;
    while (--height > 0 && dy < 32768) {
      xine_fast_memcpy (_dst, (uint8_t*)_dst-this->rgb_stride, this->dest_width);
      dy += this->step_dy;
      _dst += this->rgb_stride;
    }
    if (height <= 0)
      break;
-    _p += this->y_stride*2*(dy>>15);
+    _p += this->y_stride*(dy>>15);
    dy &= 32767;
    scale_line_4 (_p+1, this->u_buffer,
                  this->dest_width >> 1, this->step_dx);
    scale_line_4 (_p+3, this->v_buffer,
                  this->dest_width >> 1, this->step_dx);
    scale_line_2 (_p, this->y_buffer,
                  this->dest_width, this->step_dx);
  }
 }
 static void yuy22rgb_c_init (yuv2rgb_factory_t *this)
 {
  switch (this->mode) {
  case MODE_32_RGB:
  case MODE_32_BGR:
    this->yuy22rgb_fun = yuy22rgb_c_32;
    break;
  case MODE_24_RGB:
  case MODE_24_BGR:
    this->yuy22rgb_fun =
        (this->mode==MODE_24_RGB && !this->swapped) || (this->mode==MODE_24_BGR && this->swapped)
            ? yuy22rgb_c_24_rgb
            : yuy22rgb_c_24_bgr;
    break;
  case MODE_15_BGR:
  case MODE_16_BGR:
  case MODE_15_RGB:
  case MODE_16_RGB:
    this->yuy22rgb_fun = yuy22rgb_c_16;
    break;
  case MODE_8_RGB:
  case MODE_8_BGR:
    this->yuy22rgb_fun = yuy22rgb_c_8;
    break;
  case MODE_8_GRAY:
    this->yuy22rgb_fun = yuy22rgb_c_gray;
    break;
  case MODE_PALETTE:
    this->yuy22rgb_fun = yuy22rgb_c_palette;
    break;
  default:
-    printf ("yuv2rgb: mode %d not supported for yuy2\n", this->mode);
+    lprintf ("mode %d not supported for yuy2\n", this->mode);
  }
 }
-yuv2rgb_t *yuv2rgb_create_converter (yuv2rgb_factory_t *factory) {
+static yuv2rgb_t *yuv2rgb_create_converter (yuv2rgb_factory_t *factory) {
  yuv2rgb_t *this = xine_xmalloc (sizeof (yuv2rgb_t));
-  
+          this->swapped                  = factory->swapped;
  this->cmap                     = factory->cmap;
  this->y_chunk = this->y_buffer = NULL;
  this->u_chunk = this->u_buffer = NULL;
  this->v_chunk = this->v_buffer = NULL;
+#ifdef HAVE_MLIB
+  this->mlib_chunk = this->mlib_buffer = NULL;
+  this->mlib_resize_chunk = this->mlib_resize_buffer = NULL;
+  this->mlib_filter_type = MLIB_BILINEAR;
+#endif
  this->table_rV                 = factory->table_rV;
  this->table_gU                 = factory->table_gU;
  this->table_gV                 = factory->table_gV;
  this->table_bU                 = factory->table_bU;
+  this->table_mmx                = factory->table_mmx;
  this->yuv2rgb_fun              = factory->yuv2rgb_fun;
  this->yuy22rgb_fun             = factory->yuy22rgb_fun;
  this->yuv2rgb_single_pixel_fun = factory->yuv2rgb_single_pixel_fun;
  this->configure                = yuv2rgb_configure;
+  this->next_slice               = yuv2rgb_next_slice;
+  this->dispose                  = yuv2rgb_dispose;
  return this;
 }
 /*
 * factory functions 
 */
-void yuv2rgb_set_gamma (yuv2rgb_factory_t *this, int gamma) {
-    
-    int i;
-    
-    for (i = 0; i < 256; i++) {
-        (uint8_t *)this->table_rV[i] += this->entry_size*(gamma - this->gamma);
-        (uint8_t *)this->table_gU[i] += this->entry_size*(gamma - this->gamma);
-        (uint8_t *)this->table_bU[i] += this->entry_size*(gamma - this->gamma);
-    }
-#ifdef ARCH_X86
-  mmx_yuv2rgb_set_gamma(gamma);
-#endif  
-  this->gamma = gamma;
-}
-int yuv2rgb_get_gamma (yuv2rgb_factory_t *this) {
+static void yuv2rgb_factory_dispose (yuv2rgb_factory_t *this) {
-  return this->gamma;
+  free (this->table_base);
+  free (this->table_mmx_base);
+  free (this);
 }
 yuv2rgb_factory_t* yuv2rgb_factory_init (int mode, int swapped, 
                                         uint8_t *cmap) {
  yuv2rgb_factory_t *this;
-#ifdef ARCH_X86
  uint32_t mm = xine_mm_accel();
-#endif
  this = malloc (sizeof (yuv2rgb_factory_t));
  this->mode                = mode;
  this->swapped             = swapped;
  this->cmap                = cmap;
  this->create_converter    = yuv2rgb_create_converter;
-  this->set_gamma           = yuv2rgb_set_gamma;
+  this->set_csc_levels      = yuv2rgb_set_csc_levels;
-  this->get_gamma           = yuv2rgb_get_gamma;
+  this->dispose             = yuv2rgb_factory_dispose;
  this->matrix_coefficients = 6;
+  this->table_base          = NULL;
+  this->table_mmx           = NULL;
+  this->table_mmx_base      = NULL;
-  yuv2rgb_setup_tables (this, mode, swapped);
+  yuv2rgb_set_csc_levels (this, 0, 128, 128);
  /*
   * auto-probe for the best yuv2rgb function
   */
  this->yuv2rgb_fun = NULL;
-#ifdef ARCH_X86
+#if defined(ARCH_X86) || defined(ARCH_X86_64)
  if ((this->yuv2rgb_fun == NULL) && (mm & MM_ACCEL_X86_MMXEXT)) {
    yuv2rgb_init_mmxext (this);
+#ifdef LOG
    if (this->yuv2rgb_fun != NULL)
      printf ("yuv2rgb: using MMXEXT for colorspace transform\n");
+#endif
  }
  if ((this->yuv2rgb_fun == NULL) && (mm & MM_ACCEL_X86_MMX)) {
    yuv2rgb_init_mmx (this);
+#ifdef LOG
    if (this->yuv2rgb_fun != NULL)
      printf ("yuv2rgb: using MMX for colorspace transform\n");
+#endif
+  }
+#ifdef __arm__
+  if (this->yuv2rgb_fun == NULL) {
+  yuv2rgb_init_arm ( this );
+  if(this->yuv2rgb_fun != NULL)
+       printf("yuv2rgb: using arm4l assembler for colorspace transform\n" );
  }
 #endif
+#endif
 #if HAVE_MLIB
-  if (this->yuv2rgb_fun == NULL) {
+  if ((this->yuv2rgb_fun == NULL) && (mm & MM_ACCEL_MLIB)) {
    yuv2rgb_init_mlib (this);
+#ifdef LOG
    if (this->yuv2rgb_fun != NULL)
      printf ("yuv2rgb: using medialib for colorspace transform\n");
-  }
 #endif
-#ifdef __arm__
-  if (this->yuv2rgb_fun == NULL) {
-  yuv2rgb_init_arm ( this );
-  
-  if(this->yuv2rgb_fun != NULL)
-          printf("yuv2rgb: using arm4l assembler for colorspace transform\n" );
  }
 #endif
  if (this->yuv2rgb_fun == NULL) {
-    printf ("yuv2rgb: no accelerated colorspace conversion found\n");
+    lprintf ("no accelerated colorspace conversion found\n");
    yuv2rgb_c_init (this);
  }
  /*
   * auto-probe for the best yuy22rgb function
   */
  /* FIXME: implement mmx/mlib functions */
  yuy22rgb_c_init (this);
  /*
   * set up single pixel function
   */
  yuv2rgb_single_pixel_init (this);
  return this;
 }
diff --git a/noncore/multimedia/opieplayer2/yuv2rgb.h b/noncore/multimedia/opieplayer2/yuv2rgb.h
index e453243..1833889 100644
--- a/noncore/multimedia/opieplayer2/yuv2rgb.h
+++ b/noncore/multimedia/opieplayer2/yuv2rgb.h
@@ -1,152 +1,172 @@
 #ifndef HAVE_YUV2RGB_H
 #define HAVE_YUV2RGB_h
+#ifdef HAVE_MLIB
+#include <mlib_video.h>
+#endif
 #include <inttypes.h>
 typedef struct yuv2rgb_s yuv2rgb_t;
 typedef struct yuv2rgb_factory_s yuv2rgb_factory_t;
 /*
 * function types for functions which can be replaced
 * by hardware-accelerated versions
 */
 /* internal function use to scale yuv data */
 typedef void (*scale_line_func_t) (uint8_t *source, uint8_t *dest, int width, int step);
 typedef void (*yuv2rgb_fun_t) (yuv2rgb_t *this, uint8_t * image, uint8_t * py, uint8_t * pu, uint8_t * pv) ;
 typedef void (*yuy22rgb_fun_t) (yuv2rgb_t *this, uint8_t * image, uint8_t * p);
 typedef uint32_t (*yuv2rgb_single_pixel_fun_t) (yuv2rgb_t *this, uint8_t y, uint8_t u, uint8_t v);
 /*
 * modes supported - feel free to implement yours
 */
 #define MODE_8_RGB    1
 #define MODE_8_BGR    2
 #define MODE_15_RGB   3
 #define MODE_15_BGR   4
 #define MODE_16_RGB   5
 #define MODE_16_BGR   6
 #define MODE_24_RGB   7
 #define MODE_24_BGR   8
 #define MODE_32_RGB   9
 #define MODE_32_BGR  10
        #defineMODE_8_GRAY  11
 #define MODE_PALETTE 12
 struct yuv2rgb_s {
  /*
   * configure converter for scaling factors
   */
  int (*configure) (yuv2rgb_t *this,
                    int source_width, int source_height,
                    int y_stride, int uv_stride,
                    int dest_width, int dest_height,
                    int rgb_stride);
  /*
+   * start a new field or frame if dest is NULL
+   */
+  int (*next_slice) (yuv2rgb_t *this, uint8_t **dest);
+  /*
+   * free resources
+   */
+  void (*dispose) (yuv2rgb_t *this);
+  /*
   * this is the function to call for the yuv2rgb and scaling process
   */
  yuv2rgb_fun_t     yuv2rgb_fun;
  /*
   * this is the function to call for the yuy2->rgb and scaling process
   */
  yuy22rgb_fun_t    yuy22rgb_fun;
  /*
   * this is the function to call for the yuv2rgb for a single pixel
   * (used for converting clut colors)
   */
  yuv2rgb_single_pixel_fun_t yuv2rgb_single_pixel_fun;
  /* private stuff below */
  int               source_width, source_height;
  int               y_stride, uv_stride;
  int               dest_width, dest_height;
  int               rgb_stride;
+  int               slice_height, slice_offset;
  int               step_dx, step_dy;
-  int               do_scale;
+  int               do_scale, swapped;
  uint8_t          *y_buffer;
  uint8_t          *u_buffer;
  uint8_t          *v_buffer;
          void           *y_chunk;
          void           *u_chunk;
          void           *v_chunk;
+#ifdef HAVE_MLIB
+  uint8_t          *mlib_buffer;
+  uint8_t          *mlib_resize_buffer;
+          void           *mlib_chunk;
+          void           *mlib_resize_chunk;
+  mlib_filter      mlib_filter_type;
+#endif
  void            **table_rV;
  void            **table_gU;
  int              *table_gV;
  void            **table_bU;
+  void             *table_mmx;
  uint8_t          *cmap;
-  scale_line_func_t scale_line;
+  scale_line_func_t scale_line;  
 } ;
 /*
 * convenience class to easily create a lot of converters
 */
 struct yuv2rgb_factory_s {
  yuv2rgb_t* (*create_converter) (yuv2rgb_factory_t *this);
-  /*
+  /* 
-   * adjust gamma (-100 to 100 looks fine)
+   * set color space conversion levels
   * for all converters produced by this factory
   */
-  void (*set_gamma) (yuv2rgb_factory_t *this, int gamma);
+  void (*set_csc_levels) (yuv2rgb_factory_t *this,
+                          int brightness, int contrast, int saturation);
  /*
-   * get gamma value
+   * free resources
   */
-  int (*get_gamma) (yuv2rgb_factory_t *this);
+  void (*dispose) (yuv2rgb_factory_t *this);
  /* private data */
  int      mode;
  int      swapped;
  uint8_t *cmap;
-  int      gamma;
-  int      entry_size;
  uint32_t matrix_coefficients;
+  void    *table_base;
  void    *table_rV[256];
  void    *table_gU[256];
  int      table_gV[256];
  void    *table_bU[256];
+  void    *table_mmx_base;
+  void    *table_mmx;
  /* preselected functions for mode/swap/hardware */
  yuv2rgb_fun_t               yuv2rgb_fun;
  yuy22rgb_fun_t              yuy22rgb_fun;
  yuv2rgb_single_pixel_fun_t  yuv2rgb_single_pixel_fun;
 };
 yuv2rgb_factory_t *yuv2rgb_factory_init (int mode, int swapped, uint8_t *colormap);
+                   
 /*
 * internal stuff below this line
 */
-void mmx_yuv2rgb_set_gamma(int gamma);
+void mmx_yuv2rgb_set_csc_levels(yuv2rgb_factory_t *this,
+                                int brightness, int contrast, int saturation);
 void yuv2rgb_init_mmxext (yuv2rgb_factory_t *this);
 void yuv2rgb_init_mmx (yuv2rgb_factory_t *this);
 void yuv2rgb_init_mlib (yuv2rgb_factory_t *this);
-void yuv2rgb_init_arm (yuv2rgb_factory_t *this);
 #endif