video in qvfb works now with 0/90/180/270° rotation

3 files changed, 22 insertions, 11 deletions

diff --git a/noncore/multimedia/opieplayer2/lib.cpp b/noncore/multimedia/opieplayer2/lib.cpp
index ac5cdd5..5ae6c21 100644
--- a/noncore/multimedia/opieplayer2/lib.cpp
+++ b/noncore/multimedia/opieplayer2/lib.cpp
@@ -1,209 +1,209 @@
 
 #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) {
     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() );
 
     // allocate oss for sound
     // and fb for framebuffer
     m_audioOutput= xine_load_audio_output_plugin( m_config, "oss") ;
     if (m_audioOutput == NULL )
         printf("Failure\n");
     else
         printf("Success\n");
 
 
     // test code
 /*    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("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 );
 }
 
 Lib::~Lib() {
     delete m_config;
     xine_remove_event_listener( m_xine, xine_event_handler );
     xine_exit( m_xine );
     delete m_videoOutput;
     //delete m_audioOutput;
 
 }
 
 QCString Lib::version() {
     QCString str( xine_get_str_version() );
     return str;
 };
 
 int Lib::majorVersion() {
     return xine_get_major_version();
 }
 int Lib::minorVersion() {
     return xine_get_minor_version();
 };
 
 int Lib::subVersion() {
     return xine_get_sub_version();
 }
 int Lib::play( const QString& fileName,
                int startPos,
                int start_time ) {
     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 );
 }
 void Lib::pause(){
     xine_set_speed( m_xine, SPEED_PAUSE );
 }
 int Lib::speed() {
     return xine_get_speed( m_xine );
 }
 void Lib::setSpeed( int speed ) {
     xine_set_speed( m_xine, speed );
 }
 int Lib::status(){
     return xine_get_status( m_xine );
 }
 int Lib::currentPosition(){
     return xine_get_current_position( m_xine );
 }
 int Lib::currentTime()  {
     return xine_get_current_time( m_xine );
 };
 int Lib::length() {
     return xine_get_stream_length( m_xine );
 }
 bool Lib::isSeekable() {
     return xine_is_stream_seekable(m_xine);
 }
 Frame Lib::currentFrame() {
     Frame frame;
     return frame;
 };
 int Lib::error() {
     return xine_get_error( m_xine );
 };
 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 ) {
     ::null_set_fullscreen( m_videoOutput, fullScreen );
 }
 bool Lib::isVideoFullScreen() {
     return ::null_is_fullscreen( m_videoOutput );
 }
 void Lib::setScaling( bool scale ) {
     ::null_set_scaling( m_videoOutput, 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");
+//    printf("display x frame");
     ((Lib*)user_data)->drawFrame( frame,  width, height,  bytes );
-    printf("displayed x frame\n");
+//    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);
+//    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(false);
 
 }
diff --git a/noncore/multimedia/opieplayer2/nullvideo.c b/noncore/multimedia/opieplayer2/nullvideo.c
index 63d5752..3a18a40 100644
--- a/noncore/multimedia/opieplayer2/nullvideo.c
+++ b/noncore/multimedia/opieplayer2/nullvideo.c
@@ -1,400 +1,402 @@
 
 /*#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"
 
+#define printf(x,...)
+
 /* 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 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->output->m_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);
 }
 
 /* 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;
     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_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");
 
     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;
         }
 
         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(1 /*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;
diff --git a/noncore/multimedia/opieplayer2/xinevideowidget.cpp b/noncore/multimedia/opieplayer2/xinevideowidget.cpp
index e46c4df..8e8f139 100644
--- a/noncore/multimedia/opieplayer2/xinevideowidget.cpp
+++ b/noncore/multimedia/opieplayer2/xinevideowidget.cpp
@@ -1,258 +1,267 @@
 
 /*
                             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 <qimage.h>
 #include <qpainter.h>
 #include <qgfx_qws.h>
 #include <qdirectpainter_qws.h>
 #include <qsize.h>
 
 #include <qpe/resource.h>
 
 #include "xinevideowidget.h"
 
 static inline void memcpy_rev ( void *dst, void *src, size_t len )
 {
         ((char *) src ) += len;
 
         len >>= 1; 
         while ( len-- )
                 *((short int *) dst )++ = *--((short int *) src );
 }
 
 static inline void memcpy_step ( void *dst, void *src, size_t len, size_t step )
 {
         len >>= 1;
         while ( len-- ) {
+        //      *((char *) dst ) = *((char *) src + 1);
+        //      *((char *) dst + 1) = *((char *) src );
+        //      ((char *) dst ) += 2;
+
                 *((short int *) dst )++ = *((short int *) src );
                 ((char *) src ) += step;
         }
 }
 
 static inline void memcpy_step_rev ( void *dst, void *src, size_t len, size_t step )
 {
         len >>= 1;
         
         ((char *) src ) += ( len * step );
         
         while ( len-- ) {
                 ((char *) src ) -= step;
                 *((short int *) dst )++ = *((short int *) src );
+
+        //      *((char *) dst ) = *((char *) src + 1);
+        //      *((char *) dst + 1) = *((char *) src );
+        //      ((char *) dst ) += 2;
         }
 }
 
 
 XineVideoWidget::XineVideoWidget( int width,
                                   int height,
                                   QWidget* parent,
                                   const char* name )
                 : QWidget ( parent, name, WRepaintNoErase | WResizeNoErase )
 {
         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 ( false );
 }
 
 void XineVideoWidget::paintEvent ( QPaintEvent * )
 {
-        qWarning( "painting" );
+        qWarning( "painting <<<" );
         if ( m_buff == 0 ) {
                 QPainter p ( this );
                 p. fillRect ( rect ( ), black );
                 p. drawImage ( 0, 0, *m_image );
                 qWarning ( "logo\n" );
         }
         else {
-                qWarning ( "paintevent\n" );
+        //      qWarning ( "paintevent\n" );
                 
                 QArray <QRect> qt_bug_workaround_clip_rects;
                 
                 {
                         QDirectPainter dp ( this );
 
+                        int rot = dp. transformOrientation ( );
+
                         uchar *fb = dp. frameBuffer ( );
                         uchar *frame = m_buff;  // rot == 0 ? m_buff : m_buff + ( m_thisframe. height ( ) - 1 ) * m_bytes_per_line_frame;
                         
                         QRect framerect = QRect ( mapToGlobal ( m_thisframe. topLeft ( )), m_thisframe. size ( ));
 
                         qt_bug_workaround_clip_rects. resize ( dp. numRects ( ));
 
                         for ( int i = dp. numRects ( ) - 1; i >= 0; i-- ) {
                                 const QRect &clip = dp. rect ( i );
                                                                 
                                 qt_bug_workaround_clip_rects [i] = clip;
                                 
-                                int rot = dp. transformOrientation ( );
-
                                         if ( rot == 0 || rot == 180 ) {                 
                                         uchar *dst = fb + ( clip. x ( ) * m_bytes_per_pixel ) + ( clip. y ( ) * m_bytes_per_line_fb ); 
                                         uchar *src = frame + (( clip. x ( ) - framerect. x ( )) * m_bytes_per_pixel ) + (( clip. y ( ) - framerect. y ( )) * m_bytes_per_line_frame );
                                         
                                         if ( rot == 180 )
                                                 src += (( framerect. height ( ) - 1 ) * m_bytes_per_line_frame );
                                                                                 
                                         uint leftfill = 0;
                                         uint framefill = 0;
                                         uint rightfill = 0;
                                         uint clipwidth = clip. width ( ) * m_bytes_per_pixel;
                                         
                                         if ( clip. left ( ) < framerect. left ( ))
                                                 leftfill = (( framerect. left ( ) - clip. left ( )) * m_bytes_per_pixel ) <? clipwidth;
                                         if ( clip. right ( ) > framerect. right ( ))
                                                 rightfill = (( clip. right ( ) - framerect. right ( )) * m_bytes_per_pixel ) <? clipwidth;
                                         
                                         framefill = clipwidth - ( leftfill + rightfill );
                                         
                                         for ( int y = clip. top ( ); y <= clip. bottom ( ); y++ ) {
                                                 if (( y < framerect. top ( )) || ( y > framerect. bottom ( ))) {
                                                         memset ( dst, 0, clipwidth );
                                                 }
                                                 else {
                                                         if ( leftfill )
                                                                 memset ( dst, 0, leftfill );
                                                                 
                                                         if ( framefill ) {
                                                                 if ( rot == 0 )
                                                                                 memcpy ( dst + leftfill, src, framefill ); 
                                                                 else
                                                                         memcpy_rev ( dst + leftfill, src, framefill );
                                                                 }
                                                         if ( rightfill )
                                                                 memset ( dst + leftfill + framefill, 0, rightfill );
                                                 }
                                                 
                                                 dst += m_bytes_per_line_fb;
                                                 src += ( rot == 0 ? m_bytes_per_line_frame : -m_bytes_per_line_frame );
                                         }
                                 }
                                 else { // rot == 90 || rot == 270
                                         uchar *dst = fb + ( clip. y ( ) * m_bytes_per_pixel ) + ( clip. x ( ) * m_bytes_per_line_fb ); 
                                         uchar *src = frame + (( clip. x ( ) - framerect. x ( )) * m_bytes_per_pixel ) + (( clip. y ( ) - framerect. y ( )) * m_bytes_per_line_frame );
                                         
                                         if ( rot == 270 )
-                                                src += (( framerect. height ( ) - 1 ) * m_bytes_per_line_frame );
+                                                src += (( framerect. height ( ) - 1 ) * m_bytes_per_pixel );
                                                                                 
                                         uint leftfill = 0;
                                         uint framefill = 0;
                                         uint rightfill = 0;
                                         uint clipwidth = clip. height ( ) * m_bytes_per_pixel;
                                         
                                         if ( clip. bottom ( ) > framerect. bottom ( ))
                                                 leftfill = (( clip. bottom ( ) - framerect. bottom ( )) * m_bytes_per_pixel ) <? clipwidth;
                                         if ( clip. top ( ) < framerect. top ( ))
                                                 rightfill = (( framerect. top ( ) - framerect. top ( )) * m_bytes_per_pixel ) <? clipwidth;
                                         
                                         framefill = clipwidth - ( leftfill + rightfill );
                                         
                                         for ( int y = clip. left ( ); y <= clip. right ( ); y++ ) {
                                                 if (( y < framerect. left ( )) || ( y > framerect. right ( ))) {
                                                         memset ( dst, 0, clipwidth );
                                                 }
                                                 else {
                                                         if ( leftfill )
                                                                 memset ( dst, 0, leftfill );
                                                                 
                                                         if ( framefill ) {
                                                                 if ( rot == 90 )
-                                                                        memcpy_step ( dst + leftfill, src, framefill, m_bytes_per_line_frame );
-                                                                else
                                                                         memcpy_step_rev ( dst + leftfill, src, framefill, m_bytes_per_line_frame );
+                                                                else
+                                                                        memcpy_step ( dst + leftfill, src, framefill, m_bytes_per_line_frame );
                                                                 }
                                                         if ( rightfill )
                                                                 memset ( dst + leftfill + framefill, 0, rightfill );
                                                 }
                                                 
                                                 dst += m_bytes_per_line_fb;
-                                                src += ( rot == 90 ? +1 : -1 ); // m_bytes_per_line_frame : -m_bytes_per_line_frame );
+                                                src += ( rot == 270 ? -m_bytes_per_pixel : m_bytes_per_pixel );
                                                 }                               
                                 }
                         }
                         }       
                 {
                         // QVFB hack by MArtin Jones
                         QPainter p ( this );
                         
                         for ( int i = qt_bug_workaround_clip_rects. size ( ) - 1; i >= 0; i-- ) {  
                                 p. fillRect ( QRect ( mapFromGlobal ( qt_bug_workaround_clip_rects [i]. topLeft ( )), qt_bug_workaround_clip_rects [i]. size ( )), QBrush ( NoBrush ) );
                         }
                 }
         }
+        qWarning( "painting >>>" );
 }
 
 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 )
 {
 
         m_lastframe = m_thisframe;
         m_thisframe. setRect ( xoffsetXBytes, yoffsetXLine, width, height );
 
         m_buff                 = image;
         m_bytes_per_line_fb    = linestep;
         m_bytes_per_line_frame = bytes;
         m_bytes_per_pixel      = bpp;
 
         repaint ((( m_thisframe & m_lastframe ) != m_lastframe ) ? m_lastframe : m_thisframe, false );
 }