1 files changed, 30 insertions, 24 deletions

diff --git a/core/multimedia/opieplayer/loopcontrol_threaded.cpp b/core/multimedia/opieplayer/loopcontrol_threaded.cpp
index 0a1fc17..9a162c2 100644
--- a/core/multimedia/opieplayer/loopcontrol_threaded.cpp
+++ b/core/multimedia/opieplayer/loopcontrol_threaded.cpp
@@ -1,67 +1,73 @@
 /**********************************************************************
 ** Copyright (C) 2000 Trolltech AS.  All rights reserved.
 **
 ** This file is part of Qtopia Environment.
 **
 ** This file may be distributed and/or modified under the terms of the
 ** GNU General Public License version 2 as published by the Free Software
 ** Foundation and appearing in the file LICENSE.GPL included in the
 ** packaging of this file.
 **
 ** This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
 ** WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
 **
 ** See http://www.trolltech.com/gpl/ for GPL licensing information.
 **
 ** Contact info@trolltech.com if any conditions of this licensing are
 ** not clear to you.
 **
 **********************************************************************/
 #define _REENTRANT
 
+#include "mediaplayerplugininterface.h"
+#include "loopcontrol.h"
+#include "audiodevice.h"
+#include "videowidget.h"
+#include "audiowidget.h"
+#include "mediaplayerstate.h"
+
+/* OPIE */
 #include <qpe/qpeapplication.h>
 #include <qpe/custom.h>
-#include <qimage.h>
-#include <qpainter.h>
+
 #if !defined(QT_NO_COP)
 #include <qpe/qcopenvelope_qws.h>
 #endif
-#include "mediaplayerplugininterface.h"
+
+#include <opie2/odebug.h>
+
+/* QT */
+#include <qimage.h>
+#include <qpainter.h>
+
+/* STD */
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 #include <time.h>
 #include <unistd.h>
 #include <pthread.h>
-#include "loopcontrol.h"
-#include "audiodevice.h"
-#include "videowidget.h"
-#include "audiowidget.h"
-#include "mediaplayerstate.h"
-
-
-
 
 
 extern VideoWidget *videoUI; // now only needed to tell it to play a frame
 extern MediaPlayerState *mediaPlayerState;
 
 
 #define DecodeLoopDebug(x)  qDebug x
 //#define DecodeLoopDebug(x)
 
 
 static char     *audioBuffer = NULL;
 static AudioDevice  *audioDevice = NULL;
 static bool     disabledSuspendScreenSaver = FALSE;
 
 
 pthread_t video_tid;
 pthread_attr_t  video_attr;
 pthread_t audio_tid;
 pthread_attr_t  audio_attr;
 
 
 bool emitPlayFinished = FALSE;
 bool emitChangePos = FALSE;
 
@@ -170,49 +176,49 @@ void LoopControl::timerEvent( QTimerEvent* ) {
       mediaPlayerState->setPosition( current_frame );
   } else if ( hasVideoChannel ) {
       sendingNewPos = TRUE;
       mediaPlayerState->setPosition( current_frame );
   } else if ( hasAudioChannel ) {
       sendingNewPos = TRUE;
       mediaPlayerState->setPosition( audioSampleCounter );
   }
 
     }
 }
 
 
 
 
 void LoopControl::setPosition( long pos ) {
     if ( sendingNewPos ) {
   sendingNewPos = FALSE;
   return;
     }
 
     if ( hasVideoChannel && hasAudioChannel ) {
   videoMutex->lock();
   audioMutex->lock();
-  //qDebug("setting position");
+  //odebug << "setting position" << oendl;
   playtime.restart();
   playtime = playtime.addMSecs( -pos * 1000 / framerate );
   //begin = clock() - (double)pos * CLOCKS_PER_SEC / framerate;
   current_frame = pos + 1;
   mediaPlayerState->curDecoder()->videoSetFrame( current_frame, stream );
   prev_frame = current_frame - 1;
   currentSample = (int)( current_frame * freq / framerate );
   mediaPlayerState->curDecoder()->audioSetSample( currentSample, stream );
   audioSampleCounter = currentSample - 1;
   audioMutex->unlock();
   videoMutex->unlock();
     } else if ( hasVideoChannel ) {
   videoMutex->lock();
   playtime.restart();
   playtime = playtime.addMSecs( -pos * 1000 / framerate );
   //begin = clock() - (double)pos * CLOCKS_PER_SEC / framerate;
   current_frame = pos + 1;
   mediaPlayerState->curDecoder()->videoSetFrame( current_frame, stream );
   videoMutex->unlock();
   prev_frame = current_frame - 1;
     } else if ( hasAudioChannel ) {
   audioMutex->lock();
   playtime.restart();
   playtime = playtime.addMSecs( -pos * 1000 / freq );
@@ -271,204 +277,204 @@ void LoopControl::startVideo() {
 
         if ( mSecsToNextFrame ) {
       usleep( mSecsToNextFrame ); // wait a bit
 
       videoMutex->lock();
       // This should now be the next frame
       current_frame = int( (double)playtime.elapsed() * (double)framerate / 1000.0 );
       //current_frame = ( clock() - begin ) * (double)framerate / CLOCKS_PER_SEC;
       videoMutex->unlock();
         }
 
         videoMutex->lock();
         done = current_frame >= prev_frame;
         videoMutex->unlock();
 */
         videoMutex->lock();
         current_frame = int( (double)playtime.elapsed() * (double)framerate / 1000.0 );
         done = current_frame >= prev_frame;
         videoMutex->unlock();
         if ( !done )
       usleep( 1000 ); // wait a bit
 
     } while ( !done );
 
-//    qDebug("elapsed: %i %i (%f)", int( playtime.elapsed() ), current_frame, framerate );
+//    odebug << "elapsed: " << int( playtime.elapsed() ) << " " << current_frame << " (" << framerate << ")" << oendl;
 
       } else {
     videoMutex->lock();
     current_frame++;
     videoMutex->unlock();
       }
 
       videoMutex->lock();
       bool check = current_frame && current_frame > prev_frame;
       videoMutex->unlock();
 
       if ( check ) {
     videoMutex->lock();
     if ( current_frame > prev_frame + 1 ) {
-       //       qDebug("skipped a frame");
+       //       odebug << "skipped a frame" << oendl;
         mediaPlayerState->curDecoder()->videoSetFrame( current_frame, stream );
     }
     prev_frame = current_frame;
     if ( moreVideo = videoUI->playVideo() )
         emitChangePos = TRUE;
     videoMutex->unlock();
       }
 
   } else
       moreVideo = FALSE;
 
     }
 
     if ( !moreVideo && !moreAudio )
   emitPlayFinished = TRUE;
 
     pthread_exit(NULL);
 }
 
 void LoopControl::startAudio() {
     moreAudio = TRUE;
 
     while ( moreAudio ) {
 
   if ( !isMuted && mediaPlayerState->curDecoder() && hasAudioChannel ) {
 
       audioMutex->lock();
       currentSample = mediaPlayerState->curDecoder()->audioGetSample( stream );
 
       if ( currentSample == 0 )
     currentSample = audioSampleCounter + 1;
 
 //        if ( currentSample != audioSampleCounter + 1 )
-//      qDebug("out of sync with decoder %i %i", currentSample, audioSampleCounter);
+//      odebug << "out of sync with decoder " << currentSample << " " << audioSampleCounter << "" << oendl;
       audioMutex->unlock();
 
 /*
       int sampleWeShouldBeAt = int( playtime.elapsed() ) * freq / 1000;
 
       if ( sampleWeShouldBeAt - currentSample > 20000 ) {
     mediaPlayerState->curDecoder()->audioSetSample( sampleWeShouldBeAt, stream );
     currentSample = sampleWeShouldBeAt;
       }
 */
       long samplesRead = 0;
 
       const long samples = 1024;
 
       moreAudio = !mediaPlayerState->curDecoder()->audioReadSamples( (short*)audioBuffer, channels, samples, samplesRead, stream );
 
       audioMutex->lock();
       long sampleWeShouldBeAt = long( playtime.elapsed() ) * freq / 1000;
       //long sampleWeShouldBeAt = long( clock() - begin ) * (double) freq / CLOCKS_PER_SEC;
       long sampleWaitTime = currentSample - sampleWeShouldBeAt;
       audioMutex->unlock();
 
       if ( sampleWaitTime >= 0 && sampleWaitTime <= 2000 ) {
-    //qDebug("sampleWaitTime: %i", sampleWaitTime);
+    //odebug << "sampleWaitTime: " << sampleWaitTime << "" << oendl;
     usleep( ( sampleWaitTime * 1000000 ) / ( freq ) );
       } else {
     audioMutex->lock();
     if ( sampleWaitTime <= -2000 ) {
-       //        qDebug("need to catch up by: %li (%i,%li)", -sampleWaitTime, currentSample, sampleWeShouldBeAt );
+       //        odebug << "need to catch up by: " << -sampleWaitTime << " (" << currentSample << "," << sampleWeShouldBeAt << ")" << oendl;
         mediaPlayerState->curDecoder()->audioSetSample( sampleWeShouldBeAt, stream );
         currentSample = sampleWeShouldBeAt;
     }
     audioMutex->unlock();
       }
 
       audioDevice->write( audioBuffer, samplesRead * 2 * channels );
 
       audioMutex->lock();
 //      audioSampleCounter += samplesRead;
       audioSampleCounter = currentSample + samplesRead - 1;
       audioMutex->unlock();
 
       if ( !hasVideoChannel )
     emitChangePos = TRUE;
 
-      //qDebug("currentSample: %i audioSampleCounter: %i total_audio_samples: %i", currentSample, audioSampleCounter, total_audio_samples);
-//      qDebug("current: %i counter: %i total: %i", currentSample, audioSampleCounter, (int)total_audio_samples);
+      //odebug << "currentSample: " << currentSample << " audioSampleCounter: " << audioSampleCounter << " total_audio_samples: " << total_audio_samples << "" << oendl;
+//      odebug << "current: " << currentSample << " counter: " << audioSampleCounter << " total: " << (int)total_audio_samples << "" << oendl;
       moreAudio = audioSampleCounter <= total_audio_samples;
 
   } else {
 
       if ( mediaPlayerState->curDecoder() && hasAudioChannel )
           usleep( 100000 ); // Check every 1/10 sec to see if mute is off
       else
     moreAudio = FALSE;
 
   }
     }
 
-    //    qDebug( "End of file" );
+    //    odebug << "End of file" << oendl;
 
     if ( !moreVideo && !moreAudio )
   emitPlayFinished = TRUE;
 
     pthread_exit(NULL);
 }
 
 void LoopControl::killTimers() {
     if ( hasVideoChannel ) {
   if ( pthread_self() != video_tid ) {
       if ( pthread_cancel(video_tid) == 0 ) {
     void *thread_result = 0;
     if ( pthread_join(video_tid,&thread_result) != 0 )
-       //        qDebug("thread join error 1");
+       //        odebug << "thread join error 1" << oendl;
     pthread_attr_destroy(&video_attr);
       }
   }
     }
     if ( hasAudioChannel ) {
   if ( pthread_self() != audio_tid ) {
       if ( pthread_cancel(audio_tid) == 0 ) {
     void *thread_result = 0;
     if ( pthread_join(audio_tid,&thread_result) != 0 )
-       //        qDebug("thread join error 2");
+       //        odebug << "thread join error 2" << oendl;
     pthread_attr_destroy(&audio_attr);
       }
   }
     }
 }
 
 void LoopControl::startTimers() {
     moreVideo = FALSE;
     moreAudio = FALSE;
 
     if ( hasVideoChannel ) {
   moreVideo = TRUE;
   pthread_attr_init(&video_attr);
   pthread_create(&video_tid, &video_attr, (void * (*)(void *))startVideoThread, this);
     }
 
     if ( hasAudioChannel ) {
   moreAudio = TRUE;
   pthread_attr_init(&audio_attr);
 #ifdef USE_REALTIME_AUDIO_THREAD
   pthread_attr_setschedpolicy(&audio_attr,SCHED_RR); // Real-time round robin
-  //qDebug("min: %i, max: %i", sched_get_priority_min( SCHED_RR ), sched_get_priority_max( SCHED_RR ) );
+  //odebug << "min: " << sched_get_priority_min( SCHED_RR ) << ", max: " << sched_get_priority_max( SCHED_RR ) << "" << oendl;
   sched_param params;
   params.sched_priority = 50;
   pthread_attr_setschedparam(&audio_attr,&params);
 #endif
   pthread_create(&audio_tid, &audio_attr, (void * (*)(void *))startAudioThread, this);
     }
 }
 
 
 
 
 void LoopControl::setPaused( bool pause ) {
     static int whenPaused = 0;
 
     if ( !mediaPlayerState->curDecoder() || !mediaPlayerState->curDecoder()->isOpen() )
   return;
 
     if ( pause ) {
   // Remember where we are
   whenPaused = playtime.elapsed();
   killTimers();
     } else {
   // Just like we never stopped
   playtime.restart();
@@ -491,49 +497,49 @@ void LoopControl::stop( bool willPlayAgainShortly ) {
 
     if ( mediaPlayerState->curDecoder() && mediaPlayerState->curDecoder()->isOpen() ) {
 
   killTimers();
 
   mediaPlayerState->curDecoder()->close();
 
   if ( audioDevice ) {
       delete audioDevice;
       delete audioBuffer;
       audioDevice = 0;
       audioBuffer = 0;
   }
 
     }
 }
 
 
 bool LoopControl::init( const QString& filename ) {
     stop();
     fileName = filename;
     stream = 0; // only play stream 0 for now
     current_frame = total_video_frames = total_audio_samples = 0;
 
-    //    qDebug( "Using the %s decoder", mediaPlayerState->curDecoder()->pluginName() );
+    //    odebug << "Using the " << mediaPlayerState->curDecoder()->pluginName() << " decoder" << oendl;
 
     // ### Hack to use libmpeg3plugin to get the number of audio samples if we are using the libmad plugin
     if ( mediaPlayerState->curDecoder()->pluginName() == QString("LibMadPlugin") ) {
   if ( mediaPlayerState->libMpeg3Decoder() && mediaPlayerState->libMpeg3Decoder()->open( filename ) ) {
       total_audio_samples = mediaPlayerState->libMpeg3Decoder()->audioSamples( 0 );
       mediaPlayerState->libMpeg3Decoder()->close();
   }
     }
 
     if ( !mediaPlayerState->curDecoder()|| !mediaPlayerState->curDecoder()->open( filename ) )
   return FALSE;
 
     hasAudioChannel = mediaPlayerState->curDecoder()->audioStreams() > 0;
     hasVideoChannel = mediaPlayerState->curDecoder()->videoStreams() > 0;
 
     if ( hasAudioChannel ) {
   int astream = 0;
 
   channels = mediaPlayerState->curDecoder()->audioChannels( astream );
   DecodeLoopDebug(( "channels = %d\n", channels ));
 
   if ( !total_audio_samples )
       total_audio_samples = mediaPlayerState->curDecoder()->audioSamples( astream );