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,208 +1,210 @@
 
 /*#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:
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 );
 }