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
@@ -1,32 +1,44 @@
 
 #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);
     int null_is_showing_video( vo_driver_t* self );
     void null_set_show_video( vo_driver_t* self, int show );
     int null_is_fullscreen( vo_driver_t* self );
     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";
     // get the configuration
     m_config = xine_config_file_init( str.data() );
 
@@ -37,28 +49,45 @@ Lib::Lib(XineVideoWidget* /*widget*/) {
         printf("Failure\n");
     else
         printf("Success\n");
 
 
     // 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,
 //                      m_audioOutput,
 //                      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
     xine_register_event_listener( m_xine, xine_event_handler, this );
 }
 
@@ -86,13 +115,16 @@ int Lib::minorVersion() {
 int Lib::subVersion() {
     return xine_get_sub_version();
 }
 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);
 }
 void Lib::stop() {
     xine_stop(m_xine );
 }
@@ -129,12 +161,13 @@ int Lib::error() {
 };
 void Lib::handleXineEvent( xine_event_t* t ) {
     if ( t->type == XINE_EVENT_PLAYBACK_FINISHED )
         emit stopped();
 }
 void Lib::setShowVideo( bool video ) {
+    m_video = video;
     ::null_set_show_video( m_videoOutput,  video );
 }
 bool Lib::isShowingVideo() {
     return ::null_is_showing_video( m_videoOutput );
 }
 void Lib::showVideoFullScreen( bool fullScreen ) {
@@ -149,6 +182,28 @@ void Lib::setScaling( bool scale ) {
 bool Lib::isScaling() {
     return ::null_is_scaling( m_videoOutput );
 }
 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
@@ -89,19 +89,25 @@ namespace XINE {
          */
         int error() /*const*/;
 
     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 );
     };
 };
 
 
 #endif
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
@@ -1,140 +1,502 @@
 
 /*#include <xine.h>*/
 #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 {
     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 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;
   
     int bytes_per_line;
     uint8_t *data;
 
-
+    int show_video;
     null_driver_t *output;
 };
 
 static uint32_t null_get_capabilities(vo_driver_t *self ){   
     null_driver_t* this = (null_driver_t*)self;
     printf("capabilities\n");
     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 ){
     null_driver_t* this = (null_driver_t*) self;
     opie_frame_t*  frame = (opie_frame_t*)img;
     /* not needed now */
     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,
                               int property,
                               int value ){
             printf("set property\n");                
@@ -162,33 +524,42 @@ static int null_redraw_needed( vo_driver_t* self ){
                                        
 
 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;
 }
 
 static vo_info_t vo_info_null = {
     5,
@@ -230,11 +601,66 @@ int null_is_scaling( vo_driver_t* self ){
 }
 void null_set_scaling( vo_driver_t* self, int scale ){
     ((null_driver_t*)self)->m_is_scaling = 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
@@ -1,17 +1,19 @@
 TEMPLATE  = app
 CONFIG    = qt warn_on release
 #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 
 LIBS            += -lqpe -lpthread -lopie -lxine -lxineutils
 
 INCLUDEPATH += $(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
@@ -285,33 +285,34 @@ void VideoWidget::makeVisible() {
 
 void VideoWidget::paintEvent( QPaintEvent * ) {
     QPainter p( this );
 
     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 );
 
         // draw the buttons
         for ( int i = 0; i < numButtons; i++ ) {
             paintButton( &p, i );
         }
 
         // draw the slider
         slider->repaint( TRUE );
+        //videoFrame->repaint( TRUE );
     }
 }
 
 
 void VideoWidget::closeEvent( QCloseEvent* ) {
     mediaPlayerState->setList();
@@ -379,6 +380,9 @@ void VideoWidget::keyReleaseEvent( QKeyEvent *e)
           break;
       case Key_Escape:
           break;
 
     };
 }
+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
@@ -54,13 +54,13 @@ class VideoWidget : public QWidget {
     Q_OBJECT
 public:
     VideoWidget( QWidget* parent=0, const char* name=0, WFlags f=0 );
     ~VideoWidget();
 
     bool playVideo();
-
+    XineVideoWidget* vidWidget();
 public slots:
     void updateSlider( long, long );
     void sliderPressed( );
     void sliderReleased( );
     void setPaused( bool b)      { setToggleButton( VideoPause, b ); }
     void setPlaying( bool b)     { setToggleButton( VideoPlay, b ); }
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
@@ -32,19 +32,19 @@
 */
 
 
 #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 ) ) );
     connect( mediaPlayerState, SIGNAL( playingToggled( bool ) ), this, SLOT( stop( bool ) ) );
     connect( mediaPlayerState, SIGNAL( fullscreenToggled( bool ) ), this, SLOT( setFullscreen( bool ) ) );
     connect( mediaPlayerState, SIGNAL( positionChanged( long ) ),  this,  SLOT( seekTo( long ) ) );
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
@@ -1,12 +1,12 @@
 
 /*
                             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.
            .>+-=
  _;:,     .>    :=|.         This program is free software; you can
 .> <`_,   >  .   <=          redistribute it and/or  modify it under
@@ -30,24 +30,101 @@
                              Inc., 59 Temple Place - Suite 330,
                              Boston, MA 02111-1307, USA.
 
 */
 
 #include <qimage.h>
+#include <qpainter.h>
 #include <qgfx_qws.h>
+#include <qdirectpainter_qws.h>
+#include <qsize.h>
+
+#include <qpe/resource.h>
 
 #include "xinevideowidget.h"
 
 XineVideoWidget::XineVideoWidget( int width,
                                   int height,
                                   QWidget* parent,
                                   const char* name )
     : 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
@@ -39,13 +39,26 @@ class QImage;
 class XineVideoWidget : public QWidget {
     Q_OBJECT
 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
@@ -1,10 +1,10 @@
         TEMPLATE= app
 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
 TARGET          = zeckeplayer
\ No newline at end of file