broken video widget

10 files changed, 659 insertions, 76 deletions

diff --git a/noncore/multimedia/opieplayer2/lib.cpp b/noncore/multimedia/opieplayer2/lib.cpp
index 3f2eea6..aa37cd7 100644
--- a/noncore/multimedia/opieplayer2/lib.cpp
+++ b/noncore/multimedia/opieplayer2/lib.cpp
@@ -2,13 +2,20 @@
 #include <stdio.h>
 #include <stdlib.h>
 //#include <qpe/qpeapplication.h>
+#include <qimage.h>
+#include <qpe/resource.h>
 
 #include <qfile.h>
 
+#include <qgfx_qws.h>
+#include <qdirectpainter_qws.h>
+
 #include "xinevideowidget.h"
 #include "frame.h"
 #include "lib.h"
 
+typedef void (*display_xine_frame_t) (void *user_data, uint8_t* frame,
+				      int  width, int height,int bytes );
 
 extern "C" {
     vo_driver_t* init_video_out_plugin( config_values_t* conf, void* video);
@@ -18,12 +25,17 @@ extern "C" {
     void null_set_fullscreen( vo_driver_t* self, int screen );
     int null_is_scaling( vo_driver_t* self );
     void null_set_scaling( vo_driver_t* self, int scale );
-
+    void null_set_gui_width( vo_driver_t* self, int width );
+    void null_set_gui_height( vo_driver_t* self, int height );
+    void null_set_mode( vo_driver_t* self, int depth,  int rgb  );
+    void null_display_handler(vo_driver_t* self, display_xine_frame_t t, void* user_data);
 }
 
 using namespace XINE;
 
-Lib::Lib(XineVideoWidget* /*widget*/) {
+Lib::Lib(XineVideoWidget* widget) {
+    m_video = false;
+    m_wid = widget;
     printf("Lib");
     QCString str( getenv("HOME") );
     str += "/Settings/opiexine.cf";
@@ -40,15 +52,16 @@ Lib::Lib(XineVideoWidget* /*widget*/) {
 
 
     // test code
-    m_videoOutput = xine_load_video_output_plugin(m_config, "fb",
+/*    m_videoOutput = xine_load_video_output_plugin(m_config, "fb",
                                                   VISUAL_TYPE_FB,
                                                   0 );
+*/
 
     char** files = xine_list_video_output_plugins(3);
     char* out;
     int i = 0;
     while ( ( out = files[i] ) != 0 ) {
-        printf("Audio %s\n", out );
+        printf("Video %s\n", out );
         i++;
     }
 //    m_xine = xine_init( m_videoOutput,
@@ -56,6 +69,22 @@ Lib::Lib(XineVideoWidget* /*widget*/) {
 //                      m_config );
     // test loading
     m_videoOutput = ::init_video_out_plugin( m_config, NULL );
+    if (m_wid != 0 ) {
+        printf("!0\n" );
+        ::null_set_gui_width( m_videoOutput,  m_wid->image()->width() );
+        ::null_set_gui_height(m_videoOutput,  m_wid->image()->height() );
+        ::null_set_mode( m_videoOutput, qt_screen->depth(), qt_screen->pixelType() );
+        m_bytes_per_pixel = ( qt_screen->depth() + 7 ) / 8;
+        QImage image = Resource::loadImage("SoundPlayer");
+        image = image.smoothScale( m_wid->width(), m_wid->height() );
+        QImage* img = new QImage( image );
+        m_wid->setImage( img );
+        m_wid->repaint();
+    }
+    null_display_handler( m_videoOutput,
+                          xine_display_frame,
+                          this );
+
     m_xine = xine_init( m_videoOutput,
 			m_audioOutput, m_config );
     // install the event handler
@@ -89,7 +118,10 @@ int Lib::subVersion() {
 int Lib::play( const QString& fileName,
                int startPos,
                int start_time ) {
-    QString str = fileName;
+    QString str = fileName.stripWhiteSpace();
+    //workaround OpiePlayer bug
+    if (str.right(1) == QString::fromLatin1("/") )
+        str = str.mid( str.length() -1 );
     return xine_play( m_xine, QFile::encodeName(str.utf8() ).data(),
                startPos, start_time);
 }
@@ -132,6 +164,7 @@ void Lib::handleXineEvent( xine_event_t* t ) {
         emit stopped();
 }
 void Lib::setShowVideo( bool video ) {
+    m_video = video;
     ::null_set_show_video( m_videoOutput,  video );
 }
 bool Lib::isShowingVideo() {
@@ -152,3 +185,25 @@ bool Lib::isScaling() {
 void Lib::xine_event_handler( void* user_data, 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 ) {
+    printf("display x frame");
+    ((Lib*)user_data)->drawFrame( frame,  width, height,  bytes );
+    printf("displayed x frame\n");
+}
+void Lib::drawFrame( uint8_t* frame,  int width,  int height,  int bytes ) {
+    if (!m_video ) {
+        qWarning("not showing video now");
+        return;
+    }
+    qWarning("called draw frame %d %d",  width,  height);
+
+    QSize size = m_wid->size();
+    int xoffset  = (size.width() - width) / 2;
+    int yoffset  = (size.height() - height) / 2;
+    int linestep = qt_screen->linestep();
+
+    m_wid->setImage( frame, yoffset, xoffset, width, height, linestep, bytes, m_bytes_per_pixel );
+    m_wid->repaint();
+
+}
diff --git a/noncore/multimedia/opieplayer2/lib.h b/noncore/multimedia/opieplayer2/lib.h
index 1d0d3af..d568a32 100644
--- a/noncore/multimedia/opieplayer2/lib.h
+++ b/noncore/multimedia/opieplayer2/lib.h
@@ -92,14 +92,20 @@ namespace XINE {
     signals:
         void stopped();
     private:
+        int m_bytes_per_pixel;
+        bool m_video:1;
+        XineVideoWidget *m_wid;
         xine_t *m_xine;
         config_values_t *m_config;
         vo_driver_t *m_videoOutput;
         ao_driver_t* m_audioOutput;
 
         void handleXineEvent( xine_event_t* t );
+        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, xine_event_t* t);
+        static void xine_display_frame( void* user_data, uint8_t* frame ,
+                                        int width, int height, int bytes );
     };
 };
 
diff --git a/noncore/multimedia/opieplayer2/nullvideo.c b/noncore/multimedia/opieplayer2/nullvideo.c
index 8badb7b..e50d7b5 100644
--- a/noncore/multimedia/opieplayer2/nullvideo.c
+++ b/noncore/multimedia/opieplayer2/nullvideo.c
@@ -3,11 +3,21 @@
 #include <stdlib.h>
 #include <stdio.h>
 
+#include <math.h>
+
 #include <xine/video_out.h>
 #include <xine/xine_internal.h>
 #include <xine/xineutils.h>
 #include <xine/configfile.h>
 
+#include <pthread.h>
+#include "alphablend.h"
+#include "yuv2rgb.h"
+
+/* 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 );
+
 typedef struct null_driver_s null_driver_t;
 
 struct null_driver_s {
@@ -16,23 +26,45 @@ struct null_driver_s {
     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 zuv2rgb_gamma;
+    uint8_t *yuv2rgb_cmap;
+    yuv2rgb_factory_t *yuv2rgb_factory;
+    vo_overlay_t *overlay;
+    int user_ratio;
+    double output_scale_factor;
+    int last_frame_output_width;
+    int last_frame_output_height;
+    int gui_width;
+    int gui_height;
+    int gui_changed;
+    double display_ratio;
+    void* caller;
+    display_xine_frame_t frameDis;
+
+
 };
 typedef struct opie_frame_s opie_frame_t;
 struct opie_frame_s {
     vo_frame_t frame;
     char* name;
     int version;
-    int m_width;
-    int m_height;
-    int m_ratio_code;
+    int width;
+    int height;
+    int ratio_code;
     int format;
     int flags;
     int user_ratio;
 
+    double ratio_factor;
     int ideal_width;
     int ideal_height;
     int output_width, output_height;
     uint8_t *chunk[3];
+
+    yuv2rgb_t *yuv2rgb;
     uint8_t *rgb_dst;
     int yuv_stride;
     int stripe_height, stripe_inc;
@@ -40,7 +72,7 @@ struct opie_frame_s {
     int bytes_per_line;
     uint8_t *data;
 
-
+    int show_video;
     null_driver_t *output;
 };
 
@@ -50,38 +82,197 @@ static uint32_t null_get_capabilities(vo_driver_t *self ){
     return this->m_capabilities;
 }
 
+static void null_frame_copy (vo_frame_t *vo_img, uint8_t **src) {
+  opie_frame_t  *frame = (opie_frame_t *) vo_img ;
+  printf("frame copy\n");
+  if(!frame->show_video ){ printf("no video\n"); return; } // no video
+
+  if (frame->format == 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; 
+  printf("returning\n");
+}
+
+static void null_frame_field (vo_frame_t *vo_img, int which_field) {
+
+  opie_frame_t  *frame = (opie_frame_t *) vo_img ;
+  printf("field\n\n");
+
+  switch (which_field) {
+  case VO_TOP_FIELD:
+    frame->rgb_dst    = (uint8_t *)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->stripe_inc = 2*frame->stripe_height * frame->bytes_per_line;
+    break;
+  case VO_BOTH_FIELDS:
+    frame->rgb_dst    = (uint8_t *)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;
     printf("frame_dispose\n");
+    if( frame->data )
+	free( frame->data );
     free (frame);
 }
-static void null_frame_field( vo_frame_t* frame, int inti ){
-    printf("frame_field\n");
-    /* not needed */
-}
 
 /* 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 = (opie_frame_t*)malloc ( sizeof(opie_frame_t) );
+    opie_frame_t* frame;
+    frame = (opie_frame_t*)malloc ( sizeof(opie_frame_t) );
+    
     memset( frame, 0, sizeof( opie_frame_t) );
+    pthread_mutex_init (&frame->frame.mutex, NULL);
+
     printf("alloc_frame\n");
     frame->name = "opie\0";
     frame->version = 1;
     frame->output = this;
-
+    frame->show_video = this->m_show_video;
     /* initialize the frame*/
     frame->frame.driver = self;
     /*frame.frame.free = null_frame_free;*/
-    frame->frame.copy = NULL;
+    frame->frame.copy = null_frame_copy;
     frame->frame.field = null_frame_field;
     frame->frame.dispose = null_frame_dispose;
- 
+    frame->yuv2rgb = 0;
+    /*
+     *    colorspace converter for this frame
+     */   
+    frame->yuv2rgb = this->yuv2rgb_factory->create_converter (this->yuv2rgb_factory);
+  
 
     return (vo_frame_t*) frame;
 }
+
+// size specific
+static void null_compute_ideal_size (null_driver_t *this, opie_frame_t *frame) {
+
+    if (!this->m_is_scaling || !this->m_show_video) {
+        printf("Not scaling\n");
+	frame->ideal_width   = frame->width;
+	frame->ideal_height  = frame->height;
+	frame->ratio_factor  = 1.0;
+
+  } else {
+    
+      double image_ratio, desired_ratio, corr_factor;
+
+      image_ratio = (double) frame->width / (double) frame->height;
+
+      switch (frame->user_ratio) {
+	  case ASPECT_AUTO:
+	      switch (frame->ratio_code) {
+		  case XINE_ASPECT_RATIO_ANAMORPHIC:  /* anamorphic     */
+		      desired_ratio = 16.0 /9.0;
+		      break;
+		  case XINE_ASPECT_RATIO_211_1:       /* 2.11:1 */
+		      desired_ratio = 2.11/1.0;
+		      break;
+		  case XINE_ASPECT_RATIO_SQUARE:      /* square pels */
+		  case XINE_ASPECT_RATIO_DONT_TOUCH:  /* probably non-mpeg stream => don't touch aspect ratio */
+		      desired_ratio = image_ratio;
+		      break;
+		  case 0:                             /* forbidden -> 4:3 */
+		      printf ("video_out_fb: invalid ratio, using 4:3\n");
+		  default:
+		      printf ("video_out_fb: unknown aspect ratio (%d) in stream => using 4:3\n",
+			      frame->ratio_code);
+		  case XINE_ASPECT_RATIO_4_3:         /* 4:3             */
+		      desired_ratio = 4.0 / 3.0;
+		      break;
+	      }
+	      break;
+	  case ASPECT_ANAMORPHIC:
+	      desired_ratio = 16.0 / 9.0;
+	      break;
+	  case ASPECT_DVB:
+	      desired_ratio = 2.0 / 1.0;
+	      break;
+	  case ASPECT_SQUARE:
+	      desired_ratio = image_ratio;
+	      break;
+	  case ASPECT_FULL:
+	  default:
+	      desired_ratio = 4.0 / 3.0;
+      }
+      
+      frame->ratio_factor = this->display_ratio * desired_ratio;
+      
+      corr_factor = frame->ratio_factor / image_ratio ;
+
+      if (fabs(corr_factor - 1.0) < 0.005) {
+	  frame->ideal_width  = frame->width;
+	  frame->ideal_height = frame->height;
+	  
+      } else {
+	  
+	  if (corr_factor >= 1.0) {
+	      frame->ideal_width  = frame->width * corr_factor + 0.5;
+	      frame->ideal_height = frame->height;
+	  } else {
+	      frame->ideal_width  = frame->width;
+	      frame->ideal_height = frame->height / corr_factor + 0.5;
+	  }
+	  
+      }
+  }
+    printf("return from helper\n");
+}
+
+static void null_compute_rgb_size (null_driver_t *this, opie_frame_t *frame) {
+
+    double x_factor, y_factor;
+    
+    /*
+     * make the frame fit into the given destination area
+     */
+  
+    x_factor = (double) this->gui_width  / (double) frame->ideal_width;
+    y_factor = (double) this->gui_height / (double) frame->ideal_height;
+  
+    if ( x_factor < y_factor ) {
+	frame->output_width   = (double) frame->ideal_width  * x_factor ;
+	frame->output_height  = (double) frame->ideal_height * x_factor ;
+    } else {
+	frame->output_width   = (double) frame->ideal_width  * y_factor ;
+	frame->output_height  = (double) frame->ideal_height * y_factor ;
+    }
+
+#define LOG 1
+#ifdef LOG
+    printf("video_out_fb: frame source %d x %d => screen output %d x %d%s\n",
+	   frame->width, frame->height,
+	   frame->output_width, frame->output_height,
+	   ( frame->width != frame->output_width
+	     || frame->height != frame->output_height
+	     ? ", software scaling"
+	     : "" )
+	   );
+#endif
+}
+
+
+// size specific
+
+
 static void null_update_frame_format( vo_driver_t* self, vo_frame_t* img,
 				      uint32_t width, uint32_t height,
 				      int ratio_code, int format, int flags ){
@@ -91,47 +282,218 @@ static void null_update_frame_format( vo_driver_t* self, vo_frame_t* img,
     printf("update_frame_format\n");
     printf("al crash aye?\n");
 
-    if(frame->chunk[0] ){
-	free( frame->chunk[0] );
-	frame->chunk[0] = NULL;	
-    }
-    if(frame->chunk[1] ){
-	free ( frame->chunk[1] );
-	frame->chunk[1] = NULL;
-    }	
-    if(frame->chunk[2] ){
-	free ( frame->chunk[2] );
-	frame->chunk[2] = NULL;
-    }
+    flags &= VO_BOTH_FIELDS;
+
+    /* find out if we need to adapt this frame */
+
+    if ((width != frame->width)
+	|| (height != frame->height)
+	|| (ratio_code != frame->ratio_code)
+	|| (flags != frame->flags)
+	|| (format != frame->format)
+	|| (this->user_ratio != frame->user_ratio)
+	|| this->gui_changed ) {
+
+	frame->width      = width;
+	frame->height     = height;
+	frame->ratio_code = ratio_code;
+	frame->flags      = flags;
+	frame->format     = format;
+	frame->user_ratio = this->user_ratio;
+	this->gui_changed = 0;
+	frame->show_video = this->m_show_video;
+
+        
+	    null_compute_ideal_size (this, frame);
+	    null_compute_rgb_size (this, frame);
+	
+	/*
+	 * (re-) allocate 
+	 */
+	if( frame->data ) {
+	    if(frame->chunk[0] ){
+		free( frame->chunk[0] );
+		frame->chunk[0] = NULL;	
+	    }
+	    if(frame->chunk[1] ){
+		free ( frame->chunk[1] );
+		frame->chunk[1] = NULL;
+	    }	
+	    if(frame->chunk[2] ){
+		free ( frame->chunk[2] );
+		frame->chunk[2] = NULL;
+	    }
+	    free ( frame->data );
+	}
+	printf("after freeing\n");
+	frame->data = xine_xmalloc (frame->output_width * frame->output_height *
+				    this->bytes_per_pixel );
 
+	if( format == IMGFMT_YV12 ) {
+	    int image_size = width * height; /* cast ouch*/
+	    frame->frame.base[0] = xine_xmalloc_aligned(16, image_size,
+							(void **)&frame->chunk[0] );
+	    frame->frame.base[1] = xine_xmalloc_aligned(16, image_size,
+							(void **)&frame->chunk[1] );
+	    frame->frame.base[2] = xine_xmalloc_aligned(16, image_size,
+							(void **)&frame->chunk[2] );
+	}else{
+	    int image_size = width * height; /* cast ouch*/
+	    frame->frame.base[0] = xine_xmalloc_aligned(16, image_size,
+							(void **)&frame->chunk[0] );
+	    frame->chunk[1] = NULL;
+	    frame->chunk[2] = NULL;
+	}
 
-    if( format == IMGFMT_YV12 ) {
-	int image_size = width * height; /* cast ouch*/
-	frame->frame.base[0] = xine_xmalloc_aligned(16, image_size,
-						       (void **)&frame->chunk[0] );
-	frame->frame.base[1] = xine_xmalloc_aligned(16, image_size,
-						       (void **)&frame->chunk[1] );
-	frame->frame.base[2] = xine_xmalloc_aligned(16, image_size,
-						       (void **)&frame->chunk[2] );
-    }else{
-	int image_size = width * height; /* cast ouch*/
-	frame->frame.base[0] = xine_xmalloc_aligned(16, image_size,
-						       (void **)&frame->chunk[0] );
-	frame->chunk[1] = NULL;
-	frame->chunk[2] = NULL;
+	frame->format = format;
+	frame->width  = width;
+	frame->height = height;
+
+	frame->stripe_height = 16 * frame->output_height / frame->height;
+	frame->bytes_per_line = frame->output_width * this->bytes_per_pixel;
+  
+	/* 
+	 * set up colorspace converter
+	 */
+	if(this->m_show_video ){
+	    printf("showing video\n");	    	
+
+	switch (flags) {
+	    case VO_TOP_FIELD:
+	    case VO_BOTTOM_FIELD:
+		frame->yuv2rgb->configure (frame->yuv2rgb,
+					   frame->width,
+					   16,	
+					   frame->width*2,
+					   frame->width,
+					   frame->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->width,
+					   16,
+					   frame->width,
+					   frame->width/2,
+					   frame->output_width,
+					   frame->stripe_height,
+					   frame->bytes_per_line);
+		frame->yuv_stride = frame->bytes_per_line;
+		break;
+	}
+	}
     }
+    printf("after gui changed\n");
+    /*
+     * reset dest pointers
+     */
 
+    if (frame->data) {
+	switch (flags) {
+	    case VO_TOP_FIELD:
+		frame->rgb_dst    = (uint8_t *)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->stripe_inc = 2 * frame->stripe_height * frame->bytes_per_line;
+		break;
+	    case VO_BOTH_FIELDS:
+		frame->rgb_dst    = (uint8_t *)frame->data;
+		frame->stripe_inc = frame->stripe_height * frame->bytes_per_line;
+		break;
+	}
+    }    
+    printf("done\n");
 }
-static void null_display_frame( vo_driver_t* self, vo_frame_t *frame ){
+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;
+
     printf("display frame\n");
+    //    if( this->m_show_video ) { // return if not displaying	
+	printf("calling home aye\n" );
+	if( display != NULL ) {
+	(*display)(this->caller, frame->data,
+		   frame->output_width, frame->output_height,
+		   this->bytes_per_pixel );
+	printf("display done hope you enyoyed the frame");
+	}
+	//    }
+    
+    frame->frame.displayed (&frame->frame);
 }
-static void null_overlay_blend( vo_driver_t* self, vo_frame_t* frame,
-			       vo_overlay_t* overlay ){
-    /* sure */
+
+
+// blending related
+
+
+static void null_overlay_clut_yuv2rgb(null_driver_t  *this, vo_overlay_t *overlay,
+				    opie_frame_t *frame) {
+  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;
+
+  printf("overlay blend\n");
+  if(!this->m_show_video || frame->output_width == 0 || frame->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, overlay,
+		     frame->output_width, frame->output_height,
+		     frame->width, frame->height);
+        break;
+       case 24:
+        blend_rgb24( (uint8_t *)frame->data, overlay,
+		     frame->output_width, frame->output_height,
+		     frame->width, frame->height);
+        break;
+       case 32:
+        blend_rgb32( (uint8_t *)frame->data, overlay,
+		     frame->output_width, frame->output_height,
+		     frame->width, frame->height);
+        break;
+       default:
+	/* It should never get here */
+	break;
+     }        
+   }
 }
+
+
 static int null_get_property( vo_driver_t* self,
 			      int property ){
-    printf("property get]n");			     
+    printf("property get\n");			     
     return 0;
 }
 static int null_set_property( vo_driver_t* self,
@@ -165,27 +527,36 @@ vo_driver_t* init_video_out_plugin( config_values_t* conf,
 				    void* video ){
     null_driver_t *vo;
     vo = (null_driver_t*)malloc( sizeof(null_driver_t ) );
+    
+    /* memset? */
+    memset(vo,0, sizeof(null_driver_t ) );
     vo->m_show_video = 0; // false
     vo->m_video_fullscreen = 0;
     vo->m_is_scaling = 0;
-    /* memset? */
+    vo->user_ratio = ASPECT_AUTO;
+    vo->display_ratio = 1.0;
+    vo->gui_width = 200;
+    vo->gui_height = 150;
+    vo->frameDis = NULL;
 
     /* install callback handlers*/
-    vo->vo_driver.get_capabilities = null_get_capabilities;
-    vo->vo_driver.alloc_frame = null_alloc_frame;
-    vo->vo_driver.update_frame_format = null_update_frame_format;
-    vo->vo_driver.display_frame = null_display_frame;
-    vo->vo_driver.overlay_blend = null_overlay_blend;
-    vo->vo_driver.get_property = null_get_property;
-    vo->vo_driver.set_property = null_set_property;
-    vo->vo_driver.get_property_min_max = null_get_property_min_max;
-    vo->vo_driver.gui_data_exchange = null_gui_data_exchange;
-    vo->vo_driver.exit = null_exit;
-    vo->vo_driver.redraw_needed = null_redraw_needed;
+    vo->vo_driver.get_capabilities      = null_get_capabilities;
+    vo->vo_driver.alloc_frame           = null_alloc_frame;
+    vo->vo_driver.update_frame_format   = null_update_frame_format;
+    vo->vo_driver.display_frame         = null_display_frame;
+    vo->vo_driver.overlay_blend         = null_overlay_blend;
+    vo->vo_driver.get_property          = null_get_property;
+    vo->vo_driver.set_property          = null_set_property;
+    vo->vo_driver.get_property_min_max  = null_get_property_min_max;
+    vo->vo_driver.gui_data_exchange     = null_gui_data_exchange;
+    vo->vo_driver.exit                  = null_exit;
+    vo->vo_driver.redraw_needed         = null_redraw_needed;
     
 
     /* capabilities */
-    vo->m_capabilities = /*VO_CAP_COPIES_IMAGE |*/ VO_CAP_YV12 | VO_CAP_BRIGHTNESS;
+    vo->m_capabilities = VO_CAP_COPIES_IMAGE | VO_CAP_YUY2 | VO_CAP_YV12;
+    vo->yuv2rgb_factory = yuv2rgb_factory_init (MODE_16_RGB, vo->yuv2rgb_swap, 
+						vo->yuv2rgb_cmap);
     printf("done initialisation\n");
     return (vo_driver_t*) vo;
 }
@@ -233,8 +604,63 @@ void null_set_scaling( vo_driver_t* self, int scale ){
 }
      
 void null_set_gui_width( vo_driver_t* self, int width ){
-
+    ((null_driver_t*)self)->gui_width = width;
 }
 void null_set_gui_height( vo_driver_t* self, int height ){
-
+    ((null_driver_t*)self)->gui_height = height;
+}
+void null_set_mode( vo_driver_t* self, int depth,  int rgb  ){
+    null_driver_t* this = (null_driver_t*)self;
+    
+    this->bytes_per_pixel = (depth + 7 ) / 8;
+    this->bpp = this->bytes_per_pixel * 8;
+    this->depth = depth;
+    printf("depth %d %d\n", depth, this->bpp);
+    printf("pixeltype %d\n", rgb );
+    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(vo_driver_t* self, display_xine_frame_t t, void* user_data) {
+    null_driver_t* this = (null_driver_t*) self;
+    this->caller = user_data;
+    this->frameDis = t;
 }
diff --git a/noncore/multimedia/opieplayer2/opieplayer2.pro b/noncore/multimedia/opieplayer2/opieplayer2.pro
index a2cb987..448dd34 100644
--- a/noncore/multimedia/opieplayer2/opieplayer2.pro
+++ b/noncore/multimedia/opieplayer2/opieplayer2.pro
@@ -4,11 +4,13 @@ CONFIG    = qt warn_on release
 DESTDIR   = $(OPIEDIR)/bin
 HEADERS   = playlistselection.h mediaplayerstate.h xinecontrol.h mediadetect.h\
 	      videowidget.h audiowidget.h playlistwidget.h mediaplayer.h inputDialog.h \
-	      frame.h lib.h xinevideowidget.h
+	      frame.h lib.h xinevideowidget.h \
+              alphablend.h yuv2rgb.h
 SOURCES   = main.cpp \
     	  playlistselection.cpp mediaplayerstate.cpp xinecontrol.cpp mediadetect.cpp\
      	 videowidget.cpp audiowidget.cpp playlistwidget.cpp mediaplayer.cpp inputDialog.cpp \
-	 frame.cpp lib.cpp nullvideo.c xinevideowidget.cpp
+	 frame.cpp lib.cpp nullvideo.c xinevideowidget.cpp \
+         alphablend.c yuv2rgb.c yuv2rgb_mlib.c yuv2rgb_mmx.c
 TARGET    = opieplayer2
 INCLUDEPATH += $(OPIEDIR)/include 
 DEPENDPATH  += $(OPIEDIR)/include 
diff --git a/noncore/multimedia/opieplayer2/videowidget.cpp b/noncore/multimedia/opieplayer2/videowidget.cpp
index 8fdb3d3..d3898a0 100644
--- a/noncore/multimedia/opieplayer2/videowidget.cpp
+++ b/noncore/multimedia/opieplayer2/videowidget.cpp
@@ -288,16 +288,16 @@ void VideoWidget::paintEvent( QPaintEvent * ) {
 
     if ( mediaPlayerState->fullscreen() ) {
         // Clear the background
-        p.setBrush( QBrush( Qt::black ) );
-        p.drawRect( rect() );
+//        p.setBrush( QBrush( Qt::black ) );
+        //p.drawRect( rect() );
 
     } else {
         // draw border
         qDrawShadePanel( &p, 4, 15, 230, 170, colorGroup(), TRUE, 5, NULL );
 
         // Clear the movie screen first
-        p.setBrush( QBrush( Qt::black ) );
-        p.drawRect( 9, 20, 220, 160 );
+//        p.setBrush( QBrush( Qt::black ) );
+//        p.drawRect( 9, 20, 220, 160 );
 
         // draw current frame (centrally positioned from scaling to maintain aspect ratio)
         //p.drawImage( 9 + (220 - scaledWidth) / 2, 20 + (160 - scaledHeight) / 2, *currentFrame, 0, 0, scaledWidth, scaledHeight );
@@ -309,6 +309,7 @@ void VideoWidget::paintEvent( QPaintEvent * ) {
 
         // draw the slider
         slider->repaint( TRUE );
+//	videoFrame->repaint( TRUE );
     }
 }
 
@@ -382,3 +383,6 @@ void VideoWidget::keyReleaseEvent( QKeyEvent *e)
 
     };
 }
+XineVideoWidget* VideoWidget::vidWidget() {
+    return videoFrame;
+}
diff --git a/noncore/multimedia/opieplayer2/videowidget.h b/noncore/multimedia/opieplayer2/videowidget.h
index 9ab91ac..8f98889 100644
--- a/noncore/multimedia/opieplayer2/videowidget.h
+++ b/noncore/multimedia/opieplayer2/videowidget.h
@@ -57,7 +57,7 @@ public:
     ~VideoWidget();
 
     bool playVideo();
-
+    XineVideoWidget* vidWidget();
 public slots:
     void updateSlider( long, long );
     void sliderPressed( );
diff --git a/noncore/multimedia/opieplayer2/xinecontrol.cpp b/noncore/multimedia/opieplayer2/xinecontrol.cpp
index 893ac41..3be9fa4 100644
--- a/noncore/multimedia/opieplayer2/xinecontrol.cpp
+++ b/noncore/multimedia/opieplayer2/xinecontrol.cpp
@@ -35,13 +35,13 @@
 #include <qtimer.h>
 #include "xinecontrol.h"
 #include "mediaplayerstate.h"
-
+#include "videowidget.h"
 
 extern MediaPlayerState *mediaPlayerState;
-
+extern VideoWidget *videoUI;
 XineControl::XineControl( QObject *parent, const char *name )
     : QObject( parent, name ) {
-    libXine = new XINE::Lib();
+    libXine = new XINE::Lib(videoUI->vidWidget() );
 
     connect( mediaPlayerState, SIGNAL( pausedToggled(bool) ),  this, SLOT( pause(bool) ) );
     connect( this, SIGNAL( positionChanged( int position ) ),  mediaPlayerState, SLOT( updatePosition( long p ) ) );
diff --git a/noncore/multimedia/opieplayer2/xinevideowidget.cpp b/noncore/multimedia/opieplayer2/xinevideowidget.cpp
index e02ee7c..d665f16 100644
--- a/noncore/multimedia/opieplayer2/xinevideowidget.cpp
+++ b/noncore/multimedia/opieplayer2/xinevideowidget.cpp
@@ -3,7 +3,7 @@
                             This file is part of the Opie Project
 
                              Copyright (c)  2002 Max Reiss <harlekin@handhelds.org>
-                             Copyright (c)  2002 L. Potter <ljp@llornkcor.com>
+                             Copyright (c)  2002 LJP <>
                              Copyright (c)  2002 Holger Freyther <zecke@handhelds.org>
               =.
             .=l.
@@ -33,7 +33,12 @@
 */
 
 #include <qimage.h>
+#include <qpainter.h>
 #include <qgfx_qws.h>
+#include <qdirectpainter_qws.h>
+#include <qsize.h>
+
+#include <qpe/resource.h>
 
 #include "xinevideowidget.h"
 
@@ -44,10 +49,82 @@ XineVideoWidget::XineVideoWidget( int width,
     : QWidget( parent, name )
 {
     m_image = new QImage( width, height,  qt_screen->depth() );
+    m_buff = 0;
+    setBackgroundMode( NoBackground);
+/*    QImage image = Resource::loadImage("SoundPlayer");
+    image = image.smoothScale( width, height );
+
+    m_image = new QImage( image );*/
 }
 XineVideoWidget::~XineVideoWidget() {
     delete m_image;
 }
+void XineVideoWidget::clear() {
+    m_buff = 0;
+    repaint();
+}
 void XineVideoWidget::paintEvent( QPaintEvent* e ) {
-    QWidget::paintEvent( e );
+    qWarning("painting");
+    QPainter p(this );
+    p.setBrush( QBrush( Qt::black ) );
+    p.drawRect( rect() );
+    if (m_buff == 0 )
+        p.drawImage( 0, 0, *m_image );
+    else {
+        qWarning("paitnevent\n");
+
+        QDirectPainter dp( this );
+        uchar* dst =  dp.frameBuffer() + (m_yOff + dp.yOffset()  ) * linestep +
+                        (m_xOff + dp.xOffset() )  * m_bytes_per_pixel;
+        uchar* frame = m_buff;
+        for(int  y = 0; y < m_Height; y++ ) {
+            memcpy( dst, frame, m_bytes );
+            frame += m_bytes;
+            dst += linestep;
+        }
+        // QVFB hack by MArtin Jones
+//        QPainter dp2(this);
+        //      dp2.fillRect( rect(), QBrush( NoBrush ) );
+    }
+//    QWidget::paintEvent( e );
+}
+int XineVideoWidget::height() const{
+    return m_image->height();
+}
+int XineVideoWidget::width() const{
+    return m_image->width();
+}
+void XineVideoWidget::setImage( QImage* image ) {
+    delete m_image;
+    m_image = image;
+}
+void XineVideoWidget::setImage( uchar* image, int yoffsetXLine,
+                                int xoffsetXBytes,  int width,
+                                int height, int linestep,  int bytes, int bpp ) {
+/*    if (m_buff != 0 )
+        free(m_buff );
+*/
+    m_buff = image;
+    m_yOff = yoffsetXLine;
+    m_xOff = xoffsetXBytes;
+    m_Width = width;
+    m_Height = height;
+    this->linestep = linestep;
+    m_bytes = bytes;
+    m_bytes_per_pixel = bpp;
+    ////
+    qWarning("width %d  %d", width, height );
+/*    QDirectPainter dp( this );
+    uchar* dst =  dp.frameBuffer() + (m_yOff + dp.yOffset()  ) * linestep +
+                  (m_xOff + dp.xOffset() )  * m_bytes_per_pixel;
+    uchar* frame = m_buff;
+    for(int  y = 0; y < m_Height; y++ ) {
+        memcpy( dst, frame, m_bytes );
+        frame += m_bytes;
+        dst += linestep;
+    }
+    // QVFB hack
+    QPainter dp2(this);
+    dp2.fillRect( rect(), QBrush( NoBrush ) );
+*/
 }
diff --git a/noncore/multimedia/opieplayer2/xinevideowidget.h b/noncore/multimedia/opieplayer2/xinevideowidget.h
index 46bb98b..b670fa0 100644
--- a/noncore/multimedia/opieplayer2/xinevideowidget.h
+++ b/noncore/multimedia/opieplayer2/xinevideowidget.h
@@ -42,9 +42,22 @@ public:
     XineVideoWidget( int width,  int height, QWidget* parent,  const char* name );
     ~XineVideoWidget();
     QImage *image() { return m_image; };
+    void setImage( QImage* image );
+    void setImage( uchar* image, int yoffsetXLine, int xoffsetXBytes,
+                   int width, int height,  int linestep,  int bytes,  int bpp);
+    int width() const;
+    int height() const;
+    void clear() ;
 protected:
     void paintEvent( QPaintEvent* p );
 private:
+    int m_wid;
+    int m_height;
+    int m_yOff, m_xOff;
+    uchar* m_buff;
+    int m_Width,  m_Height, linestep;
+    int m_bytes;
+    int m_bytes_per_pixel;
     QImage* m_image;
 
 };
diff --git a/noncore/multimedia/opieplayer2/zeckeplayer.pro b/noncore/multimedia/opieplayer2/zeckeplayer.pro
index a1683e2..18ee623 100644
--- a/noncore/multimedia/opieplayer2/zeckeplayer.pro
+++ b/noncore/multimedia/opieplayer2/zeckeplayer.pro
@@ -3,7 +3,7 @@ DESTDIR         = .
 #CONFIG		= qt warn_on debug
 CONFIG		= qt warn_on release
 HEADERS		= frame.h lib.h
-SOURCES		= nullvideo.o frame.cpp lib.cpp mainTest.cpp 
+SOURCES		= alphablend.c yuv2rgb.c nullvideo.o frame.cpp lib.cpp mainTest.cpp 
 INCLUDEPATH	+= $(OPIEDIR)/include /opt/QtPalmtop/include
 DEPENDPATH	+= $(OPIEDIR)/include /opt/QtPalmtop/include
 LIBS            += -L/opt/QtPalmtop/lib -lxine -lxineutils