- convert qDebug to odebug

14 files changed, 292 insertions, 228 deletions

diff --git a/core/multimedia/opieplayer/audiodevice.cpp b/core/multimedia/opieplayer/audiodevice.cpp
index 355062b..9b64e07 100644
--- a/core/multimedia/opieplayer/audiodevice.cpp
+++ b/core/multimedia/opieplayer/audiodevice.cpp
@@ -1,61 +1,65 @@
 /**********************************************************************
  ** 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.
  **
  **********************************************************************/
 // L.J.Potter added better error code Fri 02-15-2002 14:37:47
 
 
-#include <stdlib.h>
-#include <stdio.h>
-#include <qpe/qpeapplication.h>
-#include <qpe/config.h>
-#include <qmessagebox.h>
-
 #include "audiodevice.h"
 
-
-#include <errno.h>
+/* OPIE */
+#include <qpe/qpeapplication.h>
+#include <qpe/config.h>
+#include <opie2/odebug.h>
 
 #if !defined(QT_NO_COP)
 #include <qpe/qcopenvelope_qws.h>
 #endif
 
+/* QT */
+#include <qmessagebox.h>
+
+/* STD */
+#include <stdlib.h>
+#include <stdio.h>
+#include <errno.h>
+
 #if defined(Q_WS_X11) || defined(Q_WS_QWS)
 #include <fcntl.h>
 #include <sys/ioctl.h>
 #include <sys/soundcard.h>
 #include <sys/stat.h>
 #include <sys/time.h>
 #include <sys/types.h>
 #include <unistd.h>
 #endif
 
 #ifdef OPIE_SOUND_FRAGMENT_SHIFT
 static const int sound_fragment_shift = OPIE_SOUND_FRAGMENT_SHIFT;
 #else
 static const int sound_fragment_shift = 16;
 #endif
 static const int sound_fragment_bytes = (1<<sound_fragment_shift);
 //#endif
 
 
 class AudioDevicePrivate {
 public:
     int handle;
     unsigned int frequency;
     unsigned int channels;
@@ -124,155 +128,155 @@ void AudioDevice::setVolume( unsigned int leftVolume, unsigned int rightVolume,
 # if 0
     unsigned int lV = (leftVolume  * 101) >> 16;
     unsigned int volume = ((rV << 8) & 0xFF00) | (lV & 0x00FF);
     int mixerHandle = 0;
 #ifdef QT_QWS_DEVFS
     if ( ( mixerHandle = open( "/dev/sound/mixer", O_RDWR ) ) >= 0 ) {
 #else
     if ( ( mixerHandle = open( "/dev/mixer", O_RDWR ) ) >= 0 ) {
 #endif
         if(ioctl( mixerHandle, MIXER_WRITE(0), &volume ) ==-1)
             perror("ioctl(\"MIXER_WRITE\")");
         close( mixerHandle );
     } else
         perror("open(\"/dev/mixer\")");
 
 # else
       // This is the way this has to be done now I guess, doesn't allow for
       // independant right and left channel setting, or setting for different outputs
     Config cfg("qpe"); // qtopia is "Sound"
     cfg.setGroup("Volume"); // qtopia is "Settings"
     cfg.writeEntry("VolumePercent",(int)rV); //qtopia is Volume
 # endif
 
 //#endif
-//    qDebug( "setting volume to: 0x%x", volume );
+//    odebug << "setting volume to: 0x" << volume << "" << oendl;
 #if ( defined Q_WS_QWS || defined(_WS_QWS_) ) && !defined(QT_NO_COP)
       // Send notification that the volume has changed
     QCopEnvelope( "QPE/System", "volumeChange(bool)" ) << muted;
 #endif
 }
 
 
 
 AudioDevice::AudioDevice( unsigned int f, unsigned int chs, unsigned int bps ) {
-   //    qDebug("creating new audio device");
+   //    odebug << "creating new audio device" << oendl;
 //     QCopEnvelope( "QPE/System", "volumeChange(bool)" ) << TRUE;
     d = new AudioDevicePrivate;
     d->frequency = f;
     d->channels = chs;
     d->bytesPerSample = bps;
-    //    qDebug("%d",bps);
+    //    odebug << "" << bps << "" << oendl;
     int format=0;
     if( bps == 8)  format  = AFMT_U8;
     else if( bps <= 0) format = AFMT_S16_LE;
     else format = AFMT_S16_LE;
-    //    qDebug("AD- freq %d, channels %d, b/sample %d, bitrate %d",f,chs,bps,format);
+    //    odebug << "AD- freq " << f << ", channels " << chs << ", b/sample " << bps << ", bitrate " << format << "" << oendl;
     connect( qApp, SIGNAL( volumeChanged(bool) ), this, SLOT( volumeChanged(bool) ) );
 
     int fragments = 0x10000 * 8 + sound_fragment_shift;
     int capabilities = 0;
 
 
 #ifdef KEEP_DEVICE_OPEN
     if ( AudioDevicePrivate::dspFd == 0 ) {
 #endif
 #ifdef QT_QWS_DEVFS
         if ( ( d->handle = ::open( "/dev/sound/dsp", O_WRONLY ) ) < 0 ) {
 #else
         if ( ( d->handle = ::open( "/dev/dsp", O_WRONLY ) ) < 0 ) {
 #endif
 
         perror("open(\"/dev/dsp\")");
         QString errorMsg=tr("Somethin's wrong with\nyour sound device.\nopen(\"/dev/dsp\")\n")+(QString)strerror(errno)+tr("\n\nClosing player now.");
         QMessageBox::critical(0, "Vmemo", errorMsg, tr("Abort"));
         exit(-1); //harsh?
         }
 #ifdef KEEP_DEVICE_OPEN
         AudioDevicePrivate::dspFd = d->handle;
     } else {
         d->handle = AudioDevicePrivate::dspFd;
     }
 #endif
 
     if(ioctl( d->handle, SNDCTL_DSP_GETCAPS, &capabilities )==-1)
         perror("ioctl(\"SNDCTL_DSP_GETCAPS\")");
     if(ioctl( d->handle, SNDCTL_DSP_SETFRAGMENT, &fragments )==-1)
         perror("ioctl(\"SNDCTL_DSP_SETFRAGMENT\")");
     if(ioctl( d->handle, SNDCTL_DSP_SETFMT, & format )==-1)
         perror("ioctl(\"SNDCTL_DSP_SETFMT\")");
-    //    qDebug("freq %d", d->frequency);
+    //    odebug << "freq " << d->frequency << "" << oendl;
     if(ioctl( d->handle, SNDCTL_DSP_SPEED, &d->frequency )==-1)
         perror("ioctl(\"SNDCTL_DSP_SPEED\")");
-    //    qDebug("channels %d",d->channels);
+    //    odebug << "channels " << d->channels << "" << oendl;
     if ( ioctl( d->handle, SNDCTL_DSP_CHANNELS, &d->channels ) == -1 ) {
         d->channels = ( d->channels == 1 ) ? 2 : d->channels;
         if(ioctl( d->handle, SNDCTL_DSP_CHANNELS, &d->channels )==-1)
             perror("ioctl(\"SNDCTL_DSP_CHANNELS\")");
     }
 //   QCopEnvelope( "QPE/System", "volumeChange(bool)" ) << FALSE;
 
     d->bufferSize = sound_fragment_bytes;
     d->unwrittenBuffer = new char[d->bufferSize];
     d->unwritten = 0;
     d->can_GETOSPACE = TRUE; // until we find otherwise
 
-      //if ( chs != d->channels )       qDebug( "Wanted %d, got %d channels", chs, d->channels );
-      //if ( f != d->frequency )        qDebug( "wanted %dHz, got %dHz", f, d->frequency );
-      //if ( capabilities & DSP_CAP_BATCH )   qDebug( "Sound card has local buffer" );
-      //if ( capabilities & DSP_CAP_REALTIME )qDebug( "Sound card has realtime sync" );
-      //if ( capabilities & DSP_CAP_TRIGGER ) qDebug( "Sound card has precise trigger" );
-      //if ( capabilities & DSP_CAP_MMAP )    qDebug( "Sound card can mmap" );
+      //if ( chs != d->channels )       odebug << "Wanted " << chs << ", got " << d->channels << " channels" << oendl;
+      //if ( f != d->frequency )        odebug << "wanted " << f << "Hz, got " << d->frequency << "Hz" << oendl;
+      //if ( capabilities & DSP_CAP_BATCH )   odebug << "Sound card has local buffer" << oendl;
+      //if ( capabilities & DSP_CAP_REALTIME )odebug << "Sound card has realtime sync" << oendl;
+      //if ( capabilities & DSP_CAP_TRIGGER ) odebug << "Sound card has precise trigger" << oendl;
+      //if ( capabilities & DSP_CAP_MMAP )    odebug << "Sound card can mmap" << oendl;
 
 }
 
 
 AudioDevice::~AudioDevice() {
-   //    qDebug("destryo audiodevice");
+   //    odebug << "destryo audiodevice" << oendl;
 //    QCopEnvelope( "QPE/System", "volumeChange(bool)" ) << TRUE;
 
 # ifndef KEEP_DEVICE_OPEN
     close( d->handle );     // Now it should be safe to shut the handle
 # endif
     delete d->unwrittenBuffer;
     delete d;
 //   QCopEnvelope( "QPE/System", "volumeChange(bool)" ) << FALSE;
 
 }
 
 
 void AudioDevice::volumeChanged( bool muted )
 {
     AudioDevicePrivate::muted = muted;
 }
 
 
 void AudioDevice::write( char *buffer, unsigned int length )
 {
     int t = ::write( d->handle, buffer, length );
     if ( t<0 ) t = 0;
     if ( t != (int)length) {
-       //        qDebug("Ahhh!! memcpys 1");
+       //        odebug << "Ahhh!! memcpys 1" << oendl;
         memcpy(d->unwrittenBuffer,buffer+t,length-t);
         d->unwritten = length-t;
     }
 //#endif
 }
 
 
 unsigned int AudioDevice::channels() const
 {
     return d->channels;
 }
 
 
 unsigned int AudioDevice::frequency() const
 {
     return d->frequency;
 }
 
 
 unsigned int AudioDevice::bytesPerSample() const
 {
     return d->bytesPerSample;
 }
 
@@ -293,30 +297,30 @@ unsigned int AudioDevice::canWrite() const
         int t = info.fragments * sound_fragment_bytes;
         return QMIN(t,(int)bufferSize());
     } else {
         if ( d->unwritten ) {
             int t = ::write( d->handle, d->unwrittenBuffer, d->unwritten );
             if ( t<0 ) t = 0;
             if ( (unsigned)t!=d->unwritten ) {
                 memcpy(d->unwrittenBuffer,d->unwrittenBuffer+t,d->unwritten-t);
                 d->unwritten -= t;
             } else {
                 d->unwritten = 0;
             }
         }
         if ( d->unwritten )
             return 0;
         else
             return d->bufferSize;
     }
 }
 
 
 int AudioDevice::bytesWritten() {
     int buffered = 0;
     if ( ioctl( d->handle, SNDCTL_DSP_GETODELAY, &buffered ) ) {
-       //        qDebug( "failed to get audio device position" );
+       //        odebug << "failed to get audio device position" << oendl;
         return -1;
     }
     return buffered;
 }
 
diff --git a/core/multimedia/opieplayer/audiowidget.cpp b/core/multimedia/opieplayer/audiowidget.cpp
index 7da2d54..376f8d3 100644
--- a/core/multimedia/opieplayer/audiowidget.cpp
+++ b/core/multimedia/opieplayer/audiowidget.cpp
@@ -1,148 +1,153 @@
 /**********************************************************************
 ** 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.
 **
 **********************************************************************/
+#include "audiowidget.h"
+#include "mediaplayerstate.h"
+
+/* OPIE */
 #include <qpe/qpeapplication.h>
 #include <qpe/resource.h>
 #include <qpe/config.h>
+#include <opie2/odebug.h>
 
+/* QT */
 #include <qdir.h>
-#include "audiowidget.h"
-#include "mediaplayerstate.h"
 
+/* STD */
 #include <stdlib.h>
 #include <stdio.h>
 
 extern MediaPlayerState *mediaPlayerState;
 
 
 static const int xo = -2; // movable x offset
 static const int yo = 22; // movable y offset
 
 using namespace Opie::Ui;
 struct MediaButton {
    bool isToggle, isHeld, isDown;
 };
 
 //Layout information for the audioButtons (and if it is a toggle button or not)
 MediaButton audioButtons[] = {
    { TRUE,  FALSE, FALSE }, // play
    { FALSE, FALSE, FALSE }, // stop
    { FALSE, FALSE, FALSE }, // next
    { FALSE, FALSE, FALSE }, // previous
    { FALSE, FALSE, FALSE }, // volume up
    { FALSE, FALSE, FALSE }, // volume down
    { TRUE,  FALSE, FALSE }, // repeat/loop
    { FALSE, FALSE, FALSE }, // playlist
    { FALSE, FALSE, FALSE }, // forward
    { FALSE, FALSE, FALSE }  // back
 };
 
 const char *skin_mask_file_names[10] = {
    "play", "stop", "next", "prev", "up",
    "down", "loop", "playlist", "forward", "back"
 };
 
 static void changeTextColor( QWidget *w ) {
    QPalette p = w->palette();
    p.setBrush( QColorGroup::Background, QColor( 167, 212, 167 ) );
    p.setBrush( QColorGroup::Base, QColor( 167, 212, 167 ) );
    w->setPalette( p );
 }
 
 static const int numButtons = (sizeof(audioButtons)/sizeof(MediaButton));
 
 AudioWidget::AudioWidget(QWidget* parent, const char* name, WFlags f) :
     QWidget( parent, name, f ), songInfo( this ), slider( Qt::Horizontal, this ),  time( this )
 {
     setCaption( tr("OpiePlayer") );
-    //    qDebug("<<<<<audioWidget");
+    //    odebug << "<<<<<audioWidget" << oendl;
     
     Config cfg("OpiePlayer");
     cfg.setGroup("Options");
     skin = cfg.readEntry("Skin","default");
     //skin = "scaleTest";
 // color of background, frame, degree of transparency
 
 //    QString skinPath = "opieplayer/skins/" + skin;
     QString skinPath;
     skinPath = "opieplayer2/skins/" + skin;
     if(!QDir(QString(getenv("OPIEDIR")) +"/pics/"+skinPath).exists())
        skinPath = "opieplayer2/skins/default";
        
-    //    qDebug("skin path " + skinPath);
+    //    odebug << "skin path " + skinPath << oendl;
     
     pixBg = new QPixmap( Resource::loadPixmap( QString("%1/background").arg(skinPath) ) );
     imgUp = new QImage( Resource::loadImage( QString("%1/skin_up").arg(skinPath) ) );
     imgDn = new QImage( Resource::loadImage( QString("%1/skin_down").arg(skinPath) ) );
 
     imgButtonMask = new QImage( imgUp->width(), imgUp->height(), 8, 255 );
     imgButtonMask->fill( 0 );
 
     for ( int i = 0; i < 10; i++ ) {
         QString filename = QString(getenv("OPIEDIR")) + "/pics/" + skinPath + "/skin_mask_" + skin_mask_file_names[i] + ".png";
         masks[i] = new QBitmap( filename );
 
         if ( !masks[i]->isNull() ) {
             QImage imgMask = masks[i]->convertToImage();
             uchar **dest = imgButtonMask->jumpTable();
             for ( int y = 0; y < imgUp->height(); y++ ) {
                 uchar *line = dest[y];
                 for ( int x = 0; x < imgUp->width(); x++ ) 
                     if ( !qRed( imgMask.pixel( x, y ) ) ) 
                         line[x] = i + 1;
             }
         }
 
     }
 
     for ( int i = 0; i < 11; i++ ) {
         buttonPixUp[i] = NULL;
         buttonPixDown[i] = NULL;
     }
 
                 QWidget *d = QApplication::desktop();
                 int width = d->width();
                 int height = d->height();
 
     if( (width != pixBg->width() ) || (height != pixBg->height() ) ) {
-        //                      qDebug("<<<<<<<< scale image >>>>>>>>>>>>");
+//              odebug << "<<<<<<<< scale image >>>>>>>>>>>>" << oendl;
                                 QImage img;
                                 img = pixBg->convertToImage();
                                 pixBg->convertFromImage( img.smoothScale( width, height));
                 }
     setBackgroundPixmap( *pixBg);
 
     songInfo.setFocusPolicy( QWidget::NoFocus );
     
 //    changeTextColor( &songInfo );
 //    songInfo.setBackgroundColor( QColor( 167, 212, 167 ));
 //    songInfo.setFrameStyle( QFrame::NoFrame);
 //    songInfo.setFrameStyle( QFrame::WinPanel | QFrame::Sunken );
       //NoFrame
 //    songInfo.setForegroundColor(Qt::white);
     
     slider.setFixedHeight( 20 );
     slider.setMinValue( 0 );
     slider.setMaxValue( 1 );
     slider.setFocusPolicy( QWidget::NoFocus );
 
     slider.setBackgroundPixmap( *pixBg );
 
     time.setFocusPolicy( QWidget::NoFocus );
     time.setAlignment( Qt::AlignCenter );
@@ -232,49 +237,49 @@ void AudioWidget::resizeEvent( QResizeEvent * ) {
     }
 
     delete pixUp;
     delete pixDn;
 }
 
 
 static bool audioSliderBeingMoved = FALSE;
 
 void AudioWidget::sliderPressed() {
     audioSliderBeingMoved = TRUE;
 }
 
 
 void AudioWidget::sliderReleased() {
     audioSliderBeingMoved = FALSE;
     if ( slider.width() == 0 )
   return;
     long val = long((double)slider.value() * mediaPlayerState->length() / slider.width());
     mediaPlayerState->setPosition( val );
 }
 
 
 void AudioWidget::setPosition( long i ) {
-//    qDebug("set position %d",i);
+//    odebug << "set position " << i << "" << oendl;
     long length = mediaPlayerState->length();
     updateSlider( i, length );
 }
 
 
 void AudioWidget::setLength( long max ) {
     updateSlider( mediaPlayerState->position(), max );
 }
 
 
 void AudioWidget::setView( char view ) {
 
     if (mediaPlayerState->isStreaming) {
         if( !slider.isHidden()) slider.hide();
         disconnect( mediaPlayerState, SIGNAL( positionChanged(long) ),this, SLOT( setPosition(long) ) );
         disconnect( mediaPlayerState, SIGNAL( positionUpdated(long) ),this, SLOT( setPosition(long) ) );
     } else {
 // this stops the slider from being moved, thus
           // does not stop stream when it reaches the end
         slider.show();
         connect( mediaPlayerState, SIGNAL( positionChanged(long) ),this, SLOT( setPosition(long) ) );
         connect( mediaPlayerState, SIGNAL( positionUpdated(long) ),this, SLOT( setPosition(long) ) );
     }
 
@@ -346,60 +351,60 @@ void AudioWidget::timerEvent( QTimerEvent * ) {
  p.drawPixmap( x + 14, y +  8, *pixmaps[3], 32 * frame, 0, 32, 32 );
  p.drawPixmap( x + 37, y + 37, *pixmaps[2], 18 * AudioPlay, 0, 6, 3 );
 */
 /*
     static int frame = 0;
     if ( !mediaPlayerState->paused() && audioButtons[ AudioPlay ].isDown ) {
   frame = frame >= 7 ? 0 : frame + 1;
     }
     */
 }
 
 
 void AudioWidget::mouseMoveEvent( QMouseEvent *event ) {
     for ( int i = 0; i < numButtons; i++ ) {
         if ( event->state() == QMouseEvent::LeftButton ) {
 
               // The test to see if the mouse click is inside the button or not
             int x = event->pos().x() - xoff;
             int y = event->pos().y() - yoff;
 
             bool isOnButton = ( x > 0 && y > 0 && x < imgButtonMask->width()
                                 && y < imgButtonMask->height() && imgButtonMask->pixelIndex( x, y ) == i + 1 );
 
 //              if ( isOnButton && i == AudioVolumeUp ) 
-//                  qDebug("on up");
+//                  odebug << "on up" << oendl;
 
             if ( isOnButton && !audioButtons[i].isHeld ) {
                 audioButtons[i].isHeld = TRUE;
                 toggleButton(i);
                 switch (i) {
                   case AudioVolumeUp:   
-                     //                      qDebug("more clicked");
+                     //                      odebug << "more clicked" << oendl;
                       emit moreClicked(); 
                       return;
                   case AudioVolumeDown:
-                     //                      qDebug("less clicked");
+                     //                      odebug << "less clicked" << oendl;
                       emit lessClicked();
                       return;
                 case AudioForward:
                     emit forwardClicked();
                     return;
                 case AudioBack:
                     emit backClicked();
                     return;
                 }
             } else if ( !isOnButton && audioButtons[i].isHeld ) {
                 audioButtons[i].isHeld = FALSE;
                 toggleButton(i);
             }
         } else {
             if ( audioButtons[i].isHeld ) {
                 audioButtons[i].isHeld = FALSE;
                 if ( !audioButtons[i].isToggle )
                     setToggleButton( i, FALSE );
                 switch (i) {
                 case AudioPlay:
                     if( mediaPlayerState->isPaused ) {
                         mediaPlayerState->setPaused( FALSE );
                         return;
                     } else if( !mediaPlayerState->isPaused ) {
@@ -449,49 +454,49 @@ void AudioWidget::paintEvent( QPaintEvent * pe) {
           // Combine with background and double buffer
         QPixmap pix( pe->rect().size() );
         QPainter p( &pix );
         p.translate( -pe->rect().topLeft().x(), -pe->rect().topLeft().y() );
         p.drawTiledPixmap( pe->rect(), *pixBg, pe->rect().topLeft() );
         for ( int i = 0; i < numButtons; i++ )
             paintButton( &p, i );
         QPainter p2( this );
         p2.drawPixmap( pe->rect().topLeft(), pix );
     } else {
         QPainter p( this );
         for ( int i = 0; i < numButtons; i++ )
             paintButton( &p, i );
     }
 }
 
 void AudioWidget::keyReleaseEvent( QKeyEvent *e)
 {
     switch ( e->key() ) {
 ////////////////////////////// Zaurus keys
       case Key_Home:
           break;
       case Key_F9: //activity
            hide();
-//           qDebug("Audio F9");
+//           odebug << "Audio F9" << oendl;
           break;
       case Key_F10: //contacts
           break;
       case Key_F11: //menu
           break;
       case Key_F12: //home
           break;
       case Key_F13: //mail
           break;
       case Key_Space: {
 
           if(mediaPlayerState->playing()) {
 //                toggleButton(1);
               mediaPlayerState->setPlaying(FALSE);
 //                toggleButton(1);
           } else {
 //                toggleButton(0);
               mediaPlayerState->setPlaying(TRUE);
 //                toggleButton(0);
           }
       }
           break;
       case Key_Down: //volume
 //            toggleButton(6);
diff --git a/core/multimedia/opieplayer/libmad/libmadplugin.cpp b/core/multimedia/opieplayer/libmad/libmadplugin.cpp
index 1989b4a..428fc28 100644
--- a/core/multimedia/opieplayer/libmad/libmadplugin.cpp
+++ b/core/multimedia/opieplayer/libmad/libmadplugin.cpp
@@ -1,81 +1,86 @@
 /**********************************************************************
 ** Copyright (C) 2001 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.
 **
 **********************************************************************/
 // largly modified by Maximilian Reiss <max.reiss@gmx.de>
 
+#include "libmadplugin.h"
+
+/* OPIE */
+#include <qpe/config.h>
+#include <opie2/odebug.h>
+
+/* QT */
+#include <qapplication.h>
+#include <qmessagebox.h>
+#include <qregexp.h>
+
+/* STD */
 #include <stdio.h>
 #include <stdarg.h>
 #include <stdlib.h>
 #include <sys/types.h>
 #include <sys/stat.h>
 #include <fcntl.h>
 #include <unistd.h>
 #include <string.h>
 #include <ctype.h>
 #include <errno.h>
 #include <time.h>
 #include <locale.h>
 #include <math.h>
 #include <assert.h>
 
-#include <qapplication.h>
-#include <qmessagebox.h>
-#include <qregexp.h>
-
-#include <qpe/config.h>
-
 // for network handling
 #include <netinet/in.h>
 #include <netdb.h>
 #include <linux/limits.h>
 #include <sys/socket.h>
 #include <arpa/inet.h>
 #include <unistd.h>
 
 
 //#define HAVE_MMAP
 
 #if defined(HAVE_MMAP)
 #   include <sys/mman.h>
 #endif
-#include "libmadplugin.h"
 
 
 extern "C" {
 #include "mad.h"
 }
 
 
 #define MPEG_BUFFER_SIZE    65536
 //#define MPEG_BUFFER_SIZE    32768 //16384 // 8192
 //#define debugMsg(a)     qDebug(a)
 #define debugMsg(a)
 
 
 class Input {
 public:
     char const *path;
     int fd;
 #if defined(HAVE_MMAP)
     void *fdm;
 #endif
     unsigned long fileLength;
    unsigned char *data;
     unsigned long length;
     int eof;
@@ -361,259 +366,258 @@ int LibMadPlugin::http_open(const QString& path ) {
     http_request[4] = 0;
     if (strcmp(http_request, "200 "))     {
         fprintf(stderr, "http_open: ");
         do {
             read(tcp_sock, &c, sizeof(char));
             fprintf(stderr, "%c", c);
         } while (c != '\r');
         fprintf(stderr, "\n");
         return (0);
     }
 #endif
 
     QString name;
     QString genre;
     QString bitrate;
     QString url;
     QString message = tr("Info: ");
     do {
 
         int len;
 
         len = http_read_line(tcp_sock, http_request, sizeof(http_request));
 
         if (len == -1) {
-           //            qDebug( "http_open: "+ QString(strerror(errno)) +"\n");
+           //            odebug << "http_open: "+ QString(strerror(errno)) +"\n" << oendl;
             return 0;
         }
 
         if (QString(http_request).left(9) == "Location:") {
             /* redirect */
             ::close(tcp_sock);
             http_request[strlen(http_request) - 1] = '\0';
             return http_open(&http_request[10]);
         }
 
         if (QString(http_request).left(4) == "ICY ") {
             /* This is shoutcast/icecast streaming */
             if (strncmp(http_request + 4, "200 ", 4)) {
-               //                qDebug("http_open: " + QString(http_request) + "\n");
+               //                odebug << "http_open: " + QString(http_request) + "\n" << oendl;
                 return 0;
             }
         } else if (QString(http_request).left(4) == "icy-") {
             /* we can have: icy-noticeX, icy-name, icy-genre, icy-url, icy-pub, icy-metaint, icy-br */
             if ( QString( http_request ).left( 8 ) == "icy-name" ) {
                 name = tr("Name: ") + QString(http_request).mid(9, (QString(http_request).length())- 9 );
             } else if ( QString( http_request ).left( 9 ) == "icy-genre" ) {
                 genre = tr("Genre: ") + QString(http_request).mid(10, (QString(http_request).length())-10 );
             } else if ( QString( http_request ).left( 6 ) == "icy-br" ) {
                 bitrate = tr("Bitrate: ") + QString(http_request).mid(7, (QString(http_request).length())- 7 );
             } else if ( QString( http_request ).left( 7 ) == "icy-url" ) {
                 url = tr("URL: ") + QString(http_request).mid(8, (QString(http_request).length())- 8 );
             }  else if ( QString( http_request ).left( 10 ) == "icy-notice" ) {
                 message += QString(http_request).mid(11, QString(http_request).length()-11 ) ;
             }
         }
     } while (strcmp(http_request, "\n") != 0);
 
     info = QString(name + genre + url + bitrate + message).replace( QRegExp("\n"), " : " );
 
-    //    qDebug("Stream info: " + info);
+    //    odebug << "Stream info: " + info << oendl;
 
     return (tcp_sock);
 }
 
 
 
 bool LibMadPlugin::open( const QString& path ) {
     debugMsg( "LibMadPlugin::open" );
     Config cfg("OpiePlayer");
     cfg.setGroup("Options");
     bufferSize = cfg.readNumEntry("MPeg_BufferSize",MPEG_BUFFER_SIZE);
-    //    qDebug("buffer size is %d", bufferSize);
+    //    odebug << "buffer size is " << bufferSize << "" << oendl;
     d->bad_last_frame = 0;
     d->flush = TRUE;
     info = QString( "" );
 
-    //qDebug( "Opening %s", path.latin1() );
+    //odebug << "Opening " << path << "" << oendl;
 
     if (path.left( 4 ) == "http" ) {
         // in case of any error we get 0 here
         if ( !(http_open(path) == 0) ) {
             d->input.fd = http_open(path);
         } else {
             return FALSE;
         }
     } else {
         d->input.path = path.latin1();
         d->input.fd = ::open( d->input.path, O_RDONLY );
         // thats a better place, since it should only seek for ID3 tags on mp3 files, not streams
         printID3Tags();
     }
     if (d->input.fd == -1) {
-       //        qDebug("error opening %s", d->input.path );
+       //        odebug << "error opening " << d->input.path << "" << oendl;
         return FALSE;
     }
 
     struct stat stat;
     if (fstat(d->input.fd, &stat) == -1) {
-       //    qDebug("error calling fstat"); return FALSE;
+       //    odebug << "error calling fstat" << oendl;  return FALSE;
     }
     if (S_ISREG(stat.st_mode) && stat.st_size > 0)
   d->input.fileLength = stat.st_size;
     else
   d->input.fileLength = 0;
     
 #if defined(HAVE_MMAP)
     if (S_ISREG(stat.st_mode) && stat.st_size > 0) {
         d->input.length = stat.st_size;
         d->input.fdm = map_file(d->input.fd, &d->input.length);
         if (d->input.fdm == 0) {
-           //            qDebug("error mmapping file"); return FALSE;
+           //            odebug << "error mmapping file" << oendl;  return FALSE;
         }
         d->input.data = (unsigned char *)d->input.fdm;
     }
 #endif
 
     if (d->input.data == 0) {
         d->input.data = (unsigned char *)malloc( bufferSize /*MPEG_BUFFER_SIZE*/);
         if (d->input.data == 0) {
-           //            qDebug("error allocating input buffer");
+           //            odebug << "error allocating input buffer" << oendl;
             return FALSE;
         }
         d->input.length = 0;
     }
 
     d->input.eof = 0;
 
     mad_stream_init(&d->stream);
     mad_frame_init(&d->frame);
     mad_synth_init(&d->synth);
 
     return TRUE;
 }
 
 
 bool LibMadPlugin::close() {
     debugMsg( "LibMadPlugin::close" );
 
     int result = TRUE;
 
     mad_synth_finish(&d->synth);
     mad_frame_finish(&d->frame);
     mad_stream_finish(&d->stream);
 
 #if defined(HAVE_MMAP)
     if (d->input.fdm) {
         if (unmap_file(d->input.fdm, d->input.length) == -1) {
-           //            qDebug("error munmapping file");
+           //            odebug << "error munmapping file" << oendl;
             result = FALSE;
         }
         d->input.fdm  = 0;
         d->input.data = 0;
     }
 #endif
 
     if (d->input.data) {
         free(d->input.data);
         d->input.data = 0;
     }
 
     if (::close(d->input.fd) == -1) {
-       //        qDebug("error closing file %s", d->input.path);
+       //        odebug << "error closing file " << d->input.path << "" << oendl;
         result = FALSE;
     }
 
     d->input.fd = 0;
 
     return result;
 }
 
 
 bool LibMadPlugin::isOpen() {
     debugMsg( "LibMadPlugin::isOpen" );
     return ( d->input.fd != 0 );
 }
 
 
 int LibMadPlugin::audioStreams() {
     debugMsg( "LibMadPlugin::audioStreams" );
     return 1;
 }
 
 
 int LibMadPlugin::audioChannels( int ) {
     debugMsg( "LibMadPlugin::audioChannels" );
 /*
   long t; short t1[5]; audioReadSamples( t1, 2, 1, t, 0 );
-  qDebug( "LibMadPlugin::audioChannels: %i", d->frame.header.mode > 0 ? 2 : 1 );
+  odebug << "LibMadPlugin::audioChannels: " << d->frame.header.mode > 0 ? 2 : 1 << "" << oendl;
   return d->frame.header.mode > 0 ? 2 : 1;
 */
     return 2;
 }
 
 
 int LibMadPlugin::audioFrequency( int ) {
     debugMsg( "LibMadPlugin::audioFrequency" );
     long t; short t1[5]; audioReadSamples( t1, 2, 1, t, 0 );
-    //    qDebug( "LibMadPlugin::audioFrequency: %i", d->frame.header.samplerate );
+    //    odebug << "LibMadPlugin::audioFrequency: " << d->frame.header.samplerate << "" << oendl;
     return d->frame.header.samplerate;
 }
 
 
 int LibMadPlugin::audioSamples( int ) {
    debugMsg( "LibMadPlugin::audioSamples" );
 
    long t; short t1[5]; audioReadSamples( t1, 2, 1, t, 0 );
    mad_header_decode( (struct mad_header *)&d->frame.header, &d->stream );
 /*
-  qDebug( "LibMadPlugin::audioSamples: %i*%i", d->frame.header.duration.seconds,
-  d->frame.header.samplerate );
+  odebug << "LibMadPlugin::audioSamples: " <<  d->frame.header.duration.seconds << "*" << d->frame.header.samplerate << oendl;
   return d->frame.header.duration.seconds * d->frame.header.samplerate;
 */
    if ( d->frame.header.bitrate == 0 )
       return 0;
    int samples = (d->input.fileLength / (d->frame.header.bitrate/8)) * d->frame.header.samplerate;
 
    //   qDebug( "LibMadPlugin::audioSamples: %i * %i * 8 / %i", (int)d->input.fileLength,
    //           (int)d->frame.header.samplerate, (int)d->frame.header.bitrate ); 
-   //   qDebug( "LibMadPlugin::audioSamples: %i", samples );
+   //   odebug << "LibMadPlugin::audioSamples: " << samples << "" << oendl;
 
    return samples;
 
 //    return 10000000;
 }
 
 
 bool LibMadPlugin::audioSetSample( long, int ) {
     debugMsg( "LibMadPlugin::audioSetSample" );
 
 //     long totalSamples = audioSamples(0);
 //     if ( totalSamples <= 1 )
 //   return FALSE;
 
 //     // Seek to requested position
-//     qDebug( "seek pos: %i", (int)((double)pos * d->input.fileLength / totalSamples) );
+//     odebug << "seek pos: " << (int)((double)pos * d->input.fileLength / totalSamples) << "" << oendl;
 //     ::lseek( d->input.fd, (long)((double)pos * d->input.fileLength / totalSamples), SEEK_SET );
 //     mad_stream_sync(&d->stream);
 
 //     mad_stream_init(&d->stream);
 //     mad_frame_init(&d->frame);
 //     mad_synth_init(&d->synth);
 
 //     return TRUE;
     debugMsg( "LibMadPlugin::audioSetSample" );
     return FALSE;
 }
 
 
 long LibMadPlugin::audioGetSample( int ) {
     debugMsg( "LibMadPlugin::audioGetSample" );
     return 0;
 }
 
 /*
 bool LibMadPlugin::audioReadSamples( short *, int, long, int ) {
 debugMsg( "LibMadPlugin::audioReadSamples" );
 return FALSE;
 }
 
@@ -659,49 +663,49 @@ bool LibMadPlugin::read() {
               if (d->input.fdm == 0) {
                   d->input.data = 0;
                   return FALSE;
               }
 
               d->input.data = (unsigned char *)d->input.fdm;
           }
 
           mad_stream_buffer(&d->stream, d->input.data + skip, d->input.length - skip);
 
       } else
 #endif
       {
           if (d->stream.next_frame) {
               memmove(d->input.data, d->stream.next_frame,
                       d->input.length = &d->input.data[d->input.length] - d->stream.next_frame);
           }
 
           do {
               len = ::read(d->input.fd, d->input.data + d->input.length, bufferSize /* MPEG_BUFFER_SIZE*/ - d->input.length);
           }
           while (len == -1 && errno == EINTR);
 
           if (len == -1) {
-             //              qDebug("error reading audio");
+             //              odebug << "error reading audio" << oendl;
               return FALSE;
           }
           else if (len == 0) {
               d->input.eof = 1;
 
               assert(bufferSize /*MPEG_BUFFER_SIZE*/ - d->input.length >= MAD_BUFFER_GUARD);
 
               while (len < MAD_BUFFER_GUARD)
                   d->input.data[d->input.length + len++] = 0;
           }
 
           mad_stream_buffer(&d->stream, d->input.data, d->input.length += len);
       }
 
       return TRUE;
 }
 
 
 static mad_fixed_t left_err, right_err;
 static const int bits = 16;
 static const int shift = MAD_F_FRACBITS + 1 - bits;
 
 
 inline long audio_linear_dither( mad_fixed_t sample, mad_fixed_t& error ) {
@@ -737,49 +741,49 @@ bool LibMadPlugin::decode( short *output, long samples, long& samplesMade ) {
     int offset = buffered;
     samplesMade = 0;
 
     static int maxBuffered = 8000; // 65536;
 
     if ( samples > maxBuffered ) {
         samples = maxBuffered;
     }
 
     if ( d->flush ) {
         buffered = 0;
         offset = 0;
         d->flush = FALSE;
     }
 
     while ( buffered < maxBuffered ) {
 
         while (mad_frame_decode(&d->frame, &d->stream) == -1) {
             if (!MAD_RECOVERABLE(d->stream.error)) {
                 debugMsg( "feed me" );
                 return FALSE; // Feed me
             }
             if ( d->stream.error == MAD_ERROR_BADCRC ) {
                 mad_frame_mute(&d->frame);
-                //                qDebug( "error decoding, bad crc" );
+                //                odebug << "error decoding, bad crc" << oendl;
             }
         }
 
         mad_synth_frame(&d->synth, &d->frame);
         int decodedSamples = d->synth.pcm.length;
         memcpy( &(buffer[0][offset]), d->synth.pcm.samples[0], decodedSamples * sizeof(mad_fixed_t) );
         if ( d->synth.pcm.channels == 2 )
             memcpy( &(buffer[1][offset]), d->synth.pcm.samples[1], decodedSamples * sizeof(mad_fixed_t) );
         offset += decodedSamples;
         buffered += decodedSamples;
     }
 
 //qApp->processEvents();
     audio_pcm( output, samples, buffer[0], (d->synth.pcm.channels == 2) ? buffer[1] : 0 );
 //    audio_pcm( output, samples, buffer[1], buffer[0] );
 //    audio_pcm( output, samples, buffer[0], buffer[1] );
     samplesMade = samples;
     memmove( buffer[0], &(buffer[0][samples]), (buffered - samples) * sizeof(mad_fixed_t) );
     if ( d->synth.pcm.channels == 2 ) {
         memmove( buffer[1], &(buffer[1][samples]), (buffered - samples) * sizeof(mad_fixed_t) );
     }
     buffered -= samples;
 
     return TRUE;
@@ -800,70 +804,70 @@ bool LibMadPlugin::audioReadSamples( short *output, int /*channels*/, long sampl
             if ( !read() ) {
                 return FALSE;
             }
 
         needInput = FALSE;
 
         if ( decode( output, samples, samplesMade ) )
             return TRUE;
         else
             needInput = TRUE;
     }
     while ( ( samplesMade < samples ) && ( !d->input.eof ) );
 
     return FALSE;
 }
 
 
 double LibMadPlugin::getTime() {
     debugMsg( "LibMadPlugin::getTime" );
     return 0.0;
 }
 
 
 void LibMadPlugin::printID3Tags() {
-   //    qDebug( "LibMadPlugin::printID3Tags" );
+   //    odebug << "LibMadPlugin::printID3Tags" << oendl;
 
     char id3v1[128 + 1];
 
     if ( ::lseek( d->input.fd, -128, SEEK_END ) == -1 ) {
-       //        qDebug( "error seeking to id3 tags" );
+       //        odebug << "error seeking to id3 tags" << oendl;
         return;
     }
 
     if ( ::read( d->input.fd, id3v1, 128 ) != 128 ) {
-       //        qDebug( "error reading in id3 tags" );
+       //        odebug << "error reading in id3 tags" << oendl;
         return;
     }
 
     if ( ::strncmp( (const char *)id3v1, "TAG", 3 ) != 0 ) {
         debugMsg( "sorry, no id3 tags" );
     } else {
         int len[5] = { 30, 30, 30, 4, 30 };
         QString label[5] = { tr( "Title" ), tr( "Artist" ), tr( "Album" ), tr( "Year" ), tr( "Comment" ) };
         char *ptr = id3v1 + 3, *ptr2 = ptr + len[0];
-        //        qDebug( "ID3 tags in file:" );
+        //        odebug << "ID3 tags in file:" << oendl;
         info = "";
         for ( int i = 0; i < 5; ptr += len[i], i++, ptr2 += len[i] ) {
             char push = *ptr2;
             *ptr2 = '\0';
             char *ptr3 = ptr2;
             while ( ptr3-1 >= ptr && isspace(ptr3[-1]) ) ptr3--;
             char push2 = *ptr3; *ptr3 = '\0';
             if ( strcmp( ptr, "" ) ) {
                 if( ((QString)ptr).find("  ") == -1) // don't add anything that has blanks
                 info += ( i != 0 ? ", " : "" ) + label[i] + ": " + ptr;
             }
-//             qDebug( info.latin1() );
+//             odebug << info.latin1() << oendl;
             *ptr3 = push2;
             *ptr2 = push;
         }
         if (id3v1[126] == 0 && id3v1[127] != 0)
             info += tr( ", Track: " ) + id3v1[127];
     }
 
     if ( ::lseek(d->input.fd, 0, SEEK_SET) == -1 ) {
-       //        qDebug( "error seeking back to beginning" );
+       //        odebug << "error seeking back to beginning" << oendl;
         return;
     }
 }
 
diff --git a/core/multimedia/opieplayer/loopcontrol.cpp b/core/multimedia/opieplayer/loopcontrol.cpp
index 4ed5921..91153fd 100644
--- a/core/multimedia/opieplayer/loopcontrol.cpp
+++ b/core/multimedia/opieplayer/loopcontrol.cpp
@@ -1,61 +1,69 @@
 /**********************************************************************
  ** 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.
  **
  **********************************************************************/
 // L.J.Potter added changes Fri 02-15-2002
 
+
+#include "mediaplayerstate.h"
+#include "loopcontrol.h"
+#include "videowidget.h"
+#include "audiodevice.h"
+
+/* OPIE */
 #include <qpe/qpeapplication.h>
+#include <qpe/mediaplayerplugininterface.h>
+#include <opie2/odebug.h>
 
 #ifdef Q_WS_QWS
 #include <qpe/qcopenvelope_qws.h>
 #endif
+
+/* QT */
+
+/* STD */
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 #include <pthread.h>
 #include <errno.h>
 #include <unistd.h>
-#include "loopcontrol.h"
-#include "videowidget.h"
-#include "audiodevice.h"
-#include <qpe/mediaplayerplugininterface.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;
 static bool     previousSuspendMode = FALSE;
 
 
 pthread_t audio_tid;
 pthread_attr_t  audio_attr;
 bool threadOkToGo = FALSE;
 
 
 class Mutex {
 public:
     Mutex() {
@@ -79,102 +87,102 @@ public:
 private:
     pthread_mutex_t mutex;
 };
 
 
 void *startAudioThread( void *ptr ) {
     LoopControl *mpegView = (LoopControl *)ptr;
     while ( TRUE ) {
         if ( threadOkToGo && mpegView->moreAudio )
             mpegView->startAudio();
         else
             usleep( 10000 ); // Semi-buzy-wait till we are playing again
     }
     return 0;
 }
 
 
 Mutex *audioMutex;
 
 
 LoopControl::LoopControl( QObject *parent, const char *name )
         : QObject( parent, name ) {
     isMuted = FALSE;
     connect( qApp, SIGNAL( volumeChanged(bool) ), this, SLOT( setMute(bool) ) );
-    //qDebug("starting loopcontrol");
+    //odebug << "starting loopcontrol" << oendl;
     audioMutex = new Mutex;
 
     pthread_attr_init(&audio_attr);
 #define USE_REALTIME_AUDIO_THREAD
 #ifdef USE_REALTIME_AUDIO_THREAD
       // Attempt to set it to real-time round robin
     if ( pthread_attr_setschedpolicy( &audio_attr, SCHED_RR ) == 0 ) {
         sched_param params;
         params.sched_priority = 50;
         pthread_attr_setschedparam(&audio_attr,&params);
     } else {
-       //        qDebug( "Error setting up a realtime thread, reverting to using a normal thread." );
+       //        odebug << "Error setting up a realtime thread, reverting to using a normal thread." << oendl;
         pthread_attr_destroy(&audio_attr);
         pthread_attr_init(&audio_attr);
     }
 #endif
-    //qDebug("create audio thread");
+    //odebug << "create audio thread" << oendl;
     pthread_create(&audio_tid, &audio_attr, (void * (*)(void *))startAudioThread, this);
 }
 
 
 LoopControl::~LoopControl() {
     stop();
 }
 
 
 static long prev_frame = 0;
 static int currentSample = 0;
 
 
 void LoopControl::timerEvent( QTimerEvent *te ) {
 
     if ( te->timerId() == videoId )
         startVideo();
 
     if ( te->timerId() == sliderId ) {
         if ( hasAudioChannel && !hasVideoChannel && moreAudio ) {
             mediaPlayerState->updatePosition( audioSampleCounter );
         } else if ( hasVideoChannel && moreVideo ) {
             mediaPlayerState->updatePosition( current_frame );
         }
     }
 
     if ( !moreVideo && !moreAudio ) { 
         mediaPlayerState->setPlaying( FALSE );
         mediaPlayerState->setNext();
     }
 }
 
 
 void LoopControl::setPosition( long pos ) {
     audioMutex->lock();
-//    qDebug("Loop control %d", pos);
+//    odebug << "Loop control " << pos << "" << oendl;
     if ( hasVideoChannel && hasAudioChannel ) {
         playtime.restart();
         playtime = playtime.addMSecs( long((double)-pos * 1000.0 / framerate) );
         current_frame = pos + 1;
         mediaPlayerState->curDecoder()->videoSetFrame( current_frame, stream );
         prev_frame = current_frame - 1;
         currentSample = (int)( (double)current_frame * freq / framerate );
         mediaPlayerState->curDecoder()->audioSetSample( currentSample, stream );
         audioSampleCounter = currentSample - 1;
     } else if ( hasVideoChannel ) {
         playtime.restart();
         playtime = playtime.addMSecs( long((double)-pos * 1000.0 / framerate) );
         current_frame = pos + 1;
         mediaPlayerState->curDecoder()->videoSetFrame( current_frame, stream );
         prev_frame = current_frame - 1;
     } else if ( hasAudioChannel ) {
         playtime.restart();
         playtime = playtime.addMSecs( long((double)-pos * 1000.0 / freq) );
         currentSample = pos + 1;
         mediaPlayerState->curDecoder()->audioSetSample( currentSample, stream );
         audioSampleCounter = currentSample - 1;
     }
 
     audioMutex->unlock();
@@ -207,62 +215,62 @@ void LoopControl::startVideo() {
                 prev_frame = current_frame;
             }
 
         } else {
 
             moreVideo = FALSE;
             killTimer( videoId );
 
         }
 
     }
 }
 
 
 void LoopControl::startAudio() {
     
     audioMutex->lock();
     if ( moreAudio ) {
 
         if ( !isMuted && mediaPlayerState->curDecoder() ) {
 
             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;
 
             long samplesRead = 0;
             bool readOk=mediaPlayerState->curDecoder()->audioReadSamples( (short*)audioBuffer, channels, 1024, samplesRead, stream );
             long sampleWeShouldBeAt = long( playtime.elapsed() ) * freq / 1000;
             long sampleWaitTime = currentSample - sampleWeShouldBeAt;
 
 // this causes drop outs not sure why its even here
          if ( hasVideoChannel ) {
            if ( ( sampleWaitTime > 2000 ) && ( sampleWaitTime < 20000 ) ) {
          usleep( (long)((double)sampleWaitTime * 1000000.0 / freq) );
            }
          else if ( sampleWaitTime <= -5000 ) {
-            //        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;
           }
 }
 
             audioDevice->write( audioBuffer, samplesRead * 2 * channels );
 
             if(  mediaPlayerState->isStreaming == FALSE)
                 audioSampleCounter = currentSample + samplesRead - 1;
 
             moreAudio = readOk && (audioSampleCounter <= total_audio_samples);
 
         } else {
 
             moreAudio = FALSE;
 
         }
 
     }
 
     audioMutex->unlock();
 }
 
 
@@ -340,139 +348,139 @@ void LoopControl::stop( bool willPlayAgainShortly ) {
 
         if ( audioDevice ) {
             delete audioDevice;
             delete audioBuffer;
             audioDevice = 0;
             audioBuffer = 0;
         }
 
         audioMutex->unlock();
     }
     audioSampleCounter=0;
     current_frame=0;
     total_audio_samples=0; 
 }
 
 
 bool LoopControl::init( const QString& filename ) {
     stop();
     audioMutex->lock();
 
     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 ) ) {
         audioMutex->unlock();
         return FALSE;
     }
 
     hasAudioChannel = mediaPlayerState->curDecoder()->audioStreams() > 0;
     hasVideoChannel = mediaPlayerState->curDecoder()->videoStreams() > 0;
 
     if ( hasAudioChannel ) {
         int astream = 0;
 
         if ( mediaPlayerState->curDecoder()->pluginName() == QString("LibMpeg3Plugin") )
             channels = 2; //dont akx me why, but it needs this hack
         else
             channels = mediaPlayerState->curDecoder()->audioChannels( astream );
 
-        //        qDebug( "LC- channels = %d", channels );
+        //        odebug << "LC- channels = " << channels << "" << oendl;
   
 //        if ( !total_audio_samples )
             total_audio_samples = mediaPlayerState->curDecoder()->audioSamples( astream );
 
         total_audio_samples += 1000;
-        //        qDebug("total samples %d", total_audio_samples);
+        //        odebug << "total samples " << total_audio_samples << "" << oendl;
         mediaPlayerState->setLength( total_audio_samples );
   
         freq = mediaPlayerState->curDecoder()->audioFrequency( astream );
-        //        qDebug( "LC- frequency = %d", freq );
+        //        odebug << "LC- frequency = " << freq << "" << oendl;
 
         audioSampleCounter = 0;
         int bits_per_sample;
         if ( mediaPlayerState->curDecoder()->pluginName() == QString("LibWavPlugin") ) {
             bits_per_sample =(int) mediaPlayerState->curDecoder()->getTime();
-            //            qDebug("using stupid hack");
+            //            odebug << "using stupid hack" << oendl;
         } else {
             bits_per_sample=0;
         }
 
         audioDevice = new AudioDevice( freq, channels, bits_per_sample);
         audioBuffer = new char[ audioDevice->bufferSize() ];
         channels = audioDevice->channels();
 
           //### must check which frequency is actually used.
         static const int size = 1;
         short int buf[size];
         long samplesRead = 0;
         mediaPlayerState->curDecoder()->audioReadSamples( buf, channels, size, samplesRead, stream );
     }
 
     if ( hasVideoChannel ) {
         total_video_frames = mediaPlayerState->curDecoder()->videoFrames( stream );
 
         mediaPlayerState->setLength( total_video_frames );
 
         framerate = mediaPlayerState->curDecoder()->videoFrameRate( stream );
         DecodeLoopDebug(( "Frame rate %g total %ld", framerate, total_video_frames ));
 
         if ( framerate <= 1.0 ) {
             DecodeLoopDebug(( "Crazy frame rate, resetting to sensible" ));
             framerate = 25;
         }
 
         if ( total_video_frames == 1 ) {
             DecodeLoopDebug(( "Cannot seek to frame" ));
         }
 
     }
 
     current_frame = 0;
     prev_frame = -1;
 
     connect( mediaPlayerState, SIGNAL( positionChanged(long) ), this, SLOT( setPosition(long) ) );
     connect( mediaPlayerState, SIGNAL( pausedToggled(bool) ), this, SLOT( setPaused(bool) ) );
 
     audioMutex->unlock();
 
     return TRUE;
 }
 
 
 void LoopControl::play() {
-   //    qDebug("LC- play");
+   //    odebug << "LC- play" << oendl;
     mediaPlayerState->setPosition( 0); //uglyhack
     
 #if defined(Q_WS_QWS) && !defined(QT_NO_COP)
     if ( !disabledSuspendScreenSaver || previousSuspendMode != hasVideoChannel ) {
         disabledSuspendScreenSaver = TRUE; 
         previousSuspendMode = hasVideoChannel;
           // Stop the screen from blanking and power saving state
         QCopEnvelope("QPE/System", "setScreenSaverMode(int)" ) 
             << ( hasVideoChannel ? QPEApplication::Disable : QPEApplication::DisableSuspend );
     }
 #endif
 
     playtime.start();
     startTimers();
 }
 
 
 void LoopControl::setMute( bool on ) {
     if ( on != isMuted ) {
         isMuted = on;
         if ( !on ) {
               // Force an update of the position
             mediaPlayerState->setPosition( mediaPlayerState->position() + 1 );
             mediaPlayerState->setPosition( mediaPlayerState->position() - 1 );
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 );
 
diff --git a/core/multimedia/opieplayer/mediaplayer.cpp b/core/multimedia/opieplayer/mediaplayer.cpp
index 6c743ec..15f6928 100644
--- a/core/multimedia/opieplayer/mediaplayer.cpp
+++ b/core/multimedia/opieplayer/mediaplayer.cpp
@@ -1,111 +1,113 @@
 /**********************************************************************
 ** Copyright (C) 2000-2002 Trolltech AS.  All rights reserved.
 **
 ** This file is part of the 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.
 **
 **********************************************************************/
 
 
-#include <qmessagebox.h>
-
 #include "mediaplayer.h"
 #include "playlistwidget.h"
 #include "audiowidget.h"
 #include "loopcontrol.h"
 #include "audiodevice.h"
-
 #include "mediaplayerstate.h"
 
+/* OPIE */
+#include <opie2/odebug.h>
+
+/* QT */
+#include <qmessagebox.h>
 
 extern AudioWidget *audioUI;
 extern PlayListWidget *playList;
 extern LoopControl *loopControl;
 extern MediaPlayerState *mediaPlayerState;
 
 
 MediaPlayer::MediaPlayer( QObject *parent, const char *name )
     : QObject( parent, name ), volumeDirection( 0 ), currentFile( NULL ) {
 
 //    QPEApplication::grabKeyboard();
     connect( qApp,SIGNAL( aboutToQuit()),SLOT( cleanUp()) );
 
     connect( mediaPlayerState, SIGNAL( playingToggled(bool) ), this, SLOT( setPlaying(bool) ) );
     connect( mediaPlayerState, SIGNAL( pausedToggled(bool) ),  this, SLOT( pauseCheck(bool) ) );
     connect( mediaPlayerState, SIGNAL( next() ),     this, SLOT( next() ) );
     connect( mediaPlayerState, SIGNAL( prev() ),     this, SLOT( prev() ) );
 
     connect( audioUI,  SIGNAL( moreClicked() ),         this, SLOT( startIncreasingVolume() ) );
     connect( audioUI,  SIGNAL( lessClicked() ),         this, SLOT( startDecreasingVolume() ) );
     connect( audioUI,  SIGNAL( moreReleased() ),        this, SLOT( stopChangingVolume() ) );
     connect( audioUI,  SIGNAL( lessReleased() ),        this, SLOT( stopChangingVolume() ) );
 }
 
 
 MediaPlayer::~MediaPlayer() {
 
 }
 
 
 void MediaPlayer::pauseCheck( bool b ) {
     // Only pause if playing
     if ( b && !mediaPlayerState->playing() )
   mediaPlayerState->setPaused( FALSE );
 }
 
 
 void MediaPlayer::play() {
     mediaPlayerState->setPlaying( FALSE );
     mediaPlayerState->setPlaying( TRUE );
 }
 
 
 void MediaPlayer::setPlaying( bool play ) {
-   //    qDebug("MediaPlayer setPlaying %d", play);
+   //    odebug << "MediaPlayer setPlaying " << play << "" << oendl;
     if ( !play ) {
         mediaPlayerState->setPaused( FALSE );
         loopControl->stop( FALSE );
         return;
     }
 
     if ( mediaPlayerState->paused() ) {
         mediaPlayerState->setPaused( FALSE );
         return;
     }
-    //    qDebug("about to ctrash");
+    //    odebug << "about to ctrash" << oendl;
     const DocLnk *playListCurrent = playList->current();
     
     if ( playListCurrent != NULL ) {
         loopControl->stop( TRUE );
         currentFile = playListCurrent;
     }
     if ( currentFile == NULL ) {
         QMessageBox::critical( 0, tr( "No file"), tr( "Error: There is no file selected" ) );
         mediaPlayerState->setPlaying( FALSE );
         return;
     }
 
     if ( ((currentFile->file()).left(4) != "http") && !QFile::exists( currentFile->file() ) ) {
         QMessageBox::critical( 0, tr( "File not found"),
                                tr( "The following file was not found: <i>" )
                                + currentFile->file() + "</i>" );
         mediaPlayerState->setPlaying( FALSE );
         return;
     }
 
     if ( !mediaPlayerState->newDecoder( currentFile->file() ) ) {
         QMessageBox::critical( 0, tr( "No decoder found"),
                                tr( "Sorry, no appropriate decoders found for this file: <i>" )
                                + currentFile->file() + "</i>" );
@@ -170,102 +172,102 @@ void MediaPlayer::startDecreasingVolume() {
 void MediaPlayer::startIncreasingVolume() {
     volumeDirection = +1;
     startTimer( 100 );
     AudioDevice::increaseVolume();
     
 }
 
 bool drawnOnScreenDisplay = FALSE;
 unsigned int onScreenDisplayVolume = 0;
 const int yoff = 110;
 
 void MediaPlayer::stopChangingVolume() {
     killTimers();
 
       // Get rid of the on-screen display stuff
     drawnOnScreenDisplay = FALSE;
     onScreenDisplayVolume = 0;
     int w = audioUI->width();
     int h = audioUI->height();
     audioUI->repaint( (w - 200) / 2, h - yoff, 200 + 9, 70, FALSE );
 }
 
 
 void MediaPlayer::timerEvent( QTimerEvent * ) {
-//    qDebug("timer");
+//    odebug << "timer" << oendl;
     if ( volumeDirection == +1 )
         AudioDevice::increaseVolume();
     else if ( volumeDirection == -1 )
         AudioDevice::decreaseVolume();
 
     // Display an on-screen display volume
     unsigned int l, r, v; bool m;
     AudioDevice::getVolume( l, r, m );
     v = ((l + r) * 11) / (2*0xFFFF);
 
     if ( drawnOnScreenDisplay && onScreenDisplayVolume == v ) {
-//        qDebug("returning %d, %d, %d, %d", v, l, r, m);
+//        odebug << "returning " << v << ", " << l << ", " << r << ", " << m << "" << oendl;
         return;
     }
 
     int w = audioUI->width();
     int h = audioUI->height();
 
     if ( drawnOnScreenDisplay ) {
         if ( onScreenDisplayVolume > v )
             audioUI->repaint( (w - 200) / 2 + v * 20 + 0, h - yoff + 40,
                               (onScreenDisplayVolume - v) * 20 + 9, 30, FALSE );
     }
 
     drawnOnScreenDisplay = TRUE;
     onScreenDisplayVolume = v;
 
     QPainter p( audioUI );
     p.setPen( QColor( 0x10, 0xD0, 0x10 ) );
     p.setBrush( QColor( 0x10, 0xD0, 0x10 ) );
 
     QFont f;
     f.setPixelSize( 20 );
     f.setBold( TRUE );
     p.setFont( f );
     p.drawText( (w - 200) / 2, h - yoff + 20, tr("Volume") );
 
     for ( unsigned int i = 0; i < 10; i++ ) {
         if ( v > i ) 
             p.drawRect( (w - 200) / 2 + i * 20 + 0, h - yoff + 40, 9, 30 );
         else 
             p.drawRect( (w - 200) / 2 + i * 20 + 3, h - yoff + 50, 3, 10 );
     }
 }
 
 void MediaPlayer::keyReleaseEvent( QKeyEvent *e) {
     switch ( e->key() ) {
 ////////////////////////////// Zaurus keys
       case Key_Home:
           break;
       case Key_F9: //activity
           break;
       case Key_F10: //contacts
           break;
       case Key_F11: //menu
           break;
       case Key_F12: //home
-         //          qDebug("Blank here");
+         //          odebug << "Blank here" << oendl;
           break;
       case Key_F13: //mail
           break;
     }
 }
 
 void MediaPlayer::doBlank() {
 
 }
 
 void MediaPlayer::doUnblank() {
 
 }
 
 void MediaPlayer::cleanUp() {
 //     QPEApplication::grabKeyboard();
 //     QPEApplication::ungrabKeyboard();
 
 }
diff --git a/core/multimedia/opieplayer/mediaplayerstate.cpp b/core/multimedia/opieplayer/mediaplayerstate.cpp
index 5bfb87e..b700cd1 100644
--- a/core/multimedia/opieplayer/mediaplayerstate.cpp
+++ b/core/multimedia/opieplayer/mediaplayerstate.cpp
@@ -1,59 +1,63 @@
 /**********************************************************************
  ** 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.
  **
  **********************************************************************/
-#include <qpe/qpeapplication.h>
-#include <qpe/qlibrary.h>
-#include <qpe/config.h>
-#include <qdir.h>
-#include <qpe/mediaplayerplugininterface.h>
-#include "mediaplayerstate.h"
-
-
 
 #ifdef QT_NO_COMPONENT
 // Plugins which are compiled in when no plugin architecture available
 #include "libmad/libmadpluginimpl.h"
 #include "libmpeg3/libmpeg3pluginimpl.h"
 #include "wavplugin/wavpluginimpl.h"
 #endif
 
+#include "mediaplayerstate.h"
+
+/* OPIE */
+#include <qpe/qpeapplication.h>
+#include <qpe/qlibrary.h>
+#include <qpe/config.h>
+#include <qpe/mediaplayerplugininterface.h>
+#include <opie2/odebug.h>
+
+/* QT */
+#include <qdir.h>
+
 
 //#define MediaPlayerDebug(x) qDebug x
 #define MediaPlayerDebug(x)
 
 
 MediaPlayerState::MediaPlayerState( QObject *parent, const char *name )
         : QObject( parent, name ), decoder( NULL ), libmpeg3decoder( NULL ) {
     Config cfg( "OpiePlayer" );
     readConfig( cfg );
     loadPlugins();
 }
 
 
 MediaPlayerState::~MediaPlayerState() {
     Config cfg( "OpiePlayer" );
     writeConfig( cfg );
 }
 
 
 void MediaPlayerState::readConfig( Config& cfg ) {
     cfg.setGroup("Options");
     isFullscreen = cfg.readBoolEntry( "FullScreen" );
     isScaled = cfg.readBoolEntry( "Scaling" );
     isLooping = cfg.readBoolEntry( "Looping" );
@@ -104,70 +108,70 @@ MediaPlayerDecoder *MediaPlayerState::newDecoder( const QString& file ) {
     if(file.left(4)=="http")
         isStreaming = TRUE;
     else
         isStreaming = FALSE;  
     return decoder = tmpDecoder; 
 }
 
 
 MediaPlayerDecoder *MediaPlayerState::curDecoder() {
     return decoder;
 }
 
 
 // ### hack to get true sample count
 MediaPlayerDecoder *MediaPlayerState::libMpeg3Decoder() {
     return libmpeg3decoder;
 }
 
 // ### hack to get true sample count
 // MediaPlayerDecoder *MediaPlayerState::libWavDecoder() {
 //     return libwavdecoder;
 // }
 
 void MediaPlayerState::loadPlugins() {
-   //    qDebug("load plugins");
+   //    odebug << "load plugins" << oendl;
 #ifndef QT_NO_COMPONENT
     QValueList<MediaPlayerPlugin>::Iterator mit;
     for ( mit = pluginList.begin(); mit != pluginList.end(); ++mit ) {
         (*mit).iface->release();
         (*mit).library->unload();
         delete (*mit).library;
     }
     pluginList.clear();
 
     QString path = QPEApplication::qpeDir() + "/plugins/codecs";
     QDir dir( path, "lib*.so" );
     QStringList list = dir.entryList();
     QStringList::Iterator it;
     for ( it = list.begin(); it != list.end(); ++it ) {
         MediaPlayerPluginInterface *iface = 0;
         QLibrary *lib = new QLibrary( path + "/" + *it );
-//   qDebug( "querying: %s", QString( path + "/" + *it ).latin1() );
+//   odebug << "querying: " << QString( path + "/" + *it ) << "" << oendl;
 
         if ( lib->queryInterface( IID_MediaPlayerPlugin, (QUnknownInterface**)&iface ) == QS_OK ) {
 
-//       qDebug( "loading: %s", QString( path + "/" + *it ).latin1() );
+//       odebug << "loading: " << QString( path + "/" + *it ) << "" << oendl;
 
             MediaPlayerPlugin plugin;
             plugin.library = lib;
             plugin.iface = iface;
             plugin.decoder = plugin.iface->decoder();
             plugin.encoder = plugin.iface->encoder();
             pluginList.append( plugin );
 
               // ### hack to get true sample count
             if ( plugin.decoder->pluginName() == QString("LibMpeg3Plugin") )
                 libmpeg3decoder = plugin.decoder;
 
         } else {
             delete lib;
         }
     }
 #else
     pluginList.clear();
     
     MediaPlayerPlugin plugin0;
     plugin0.iface = new LibMpeg3PluginImpl;
     plugin0.decoder = plugin0.iface->decoder();
     plugin0.encoder = plugin0.iface->encoder();
     pluginList.append( plugin0 );
diff --git a/core/multimedia/opieplayer/modplug/memfile.cpp b/core/multimedia/opieplayer/modplug/memfile.cpp
index 8a29997..cd243c7 100644
--- a/core/multimedia/opieplayer/modplug/memfile.cpp
+++ b/core/multimedia/opieplayer/modplug/memfile.cpp
@@ -1,76 +1,80 @@
 /* This file is part of the KDE project
    Copyright (C) 2002 Simon Hausmann <hausmann@kde.org>
 
    This program is free software; you can redistribute it and/or
    modify it under the terms of the GNU General Public
    License as published by the Free Software Foundation; either
    version 2 of the License, or (at your option) any later version.
 
    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
     General Public License for more details.
 
    You should have received a copy of the GNU General Public License
    along with this program; see the file COPYING.  If not, write to
    the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
    Boston, MA 02111-1307, USA.
 */
 
 #include "memfile.h"
 
+/* OPIE */
+#include <opie2/odebug.h>
+
+/* STD */
 #include <unistd.h>
 #include <sys/mman.h>
 
 MemFile::MemFile()
 {
 }
 
 MemFile::MemFile( const QString &name )
     : QFile( name )
 {
 }
 
 MemFile::~MemFile()
 {
     close();
 }
 
 void MemFile::close()
 {
     unmap();
     QFile::close();
 }
 
 void MemFile::unmap()
 {
 #if defined(Q_WS_X11) || defined(Q_WS_QWS)
     if ( m_data.data() )
     {
         munmap( m_data.data(), m_data.size() );
         m_data.resetRawData( m_data.data(), m_data.size() );
     }
 #endif
 }
 
 QByteArray &MemFile::data()
 {
     if ( !m_data.data() )
     {
 #if defined(Q_WS_X11) || defined(Q_WS_QWS)
         const char *rawData = (const char *)mmap( 0, size(), PROT_READ,
                                                   MAP_SHARED, handle(), 0 );
         if ( rawData )
         {
             m_data.setRawData( rawData, size() );
             return m_data;
         }
         else
-            qDebug( "MemFile: mmap() failed!" );
+        odebug << "MemFile: mmap() failed!" << oendl;
         // fallback
 #endif
         m_data = readAll();
     }
     return m_data;
 }
 
diff --git a/core/multimedia/opieplayer/om3u.cpp b/core/multimedia/opieplayer/om3u.cpp
index ae89518..95ed03c 100644
--- a/core/multimedia/opieplayer/om3u.cpp
+++ b/core/multimedia/opieplayer/om3u.cpp
@@ -10,153 +10,155 @@
 :`=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
 ..}^=.=       =       ;      General Public License for more
 ++=   -.     .`     .:       details.
  :     =  ...= . :.=-
  -.   .:....=;==+<;          You should have received a copy of the GNU
   -_. . .   )=.  =           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 "om3u.h"
 
+/* OPIE */
+#include <opie2/odebug.h>
 
 
 static inline QString fullBaseName ( const QFileInfo &fi )
 {
   QString str = fi. fileName ( );
   return str. left ( str. findRev ( '.' ));
 }
 
 
 //extern PlayListWidget *playList;
 
 Om3u::Om3u( const QString &filePath, int mode)
       : QStringList (){
-//qDebug("<<<<<<<new m3u "+filePath);
+//odebug << "<<<<<<<new m3u "+filePath << oendl;
   f.setName(filePath);
   f.open(mode);
 }
 
 Om3u::~Om3u(){}
 
 void Om3u::readM3u() {
-//    qDebug("<<<<<<reading m3u "+f.name());
+//    odebug << "<<<<<<reading m3u "+f.name() << oendl;
    QTextStream t(&f);
          t.setEncoding(QTextStream::UnicodeUTF8);
    QString s;
    while ( !t.atEnd() ) {
       s=t.readLine();
-      //                qDebug(s);
+      //                odebug << s << oendl;
       if( s.find( "#", 0, TRUE) == -1 ) {
          if( s.left(2) == "E:" || s.left(2) == "P:" ) {
             s = s.right( s.length() -2 );
             QFileInfo f( s );
             QString name = fullBaseName ( f );
             name = name.right( name.length() - name.findRev( "\\", -1, TRUE )  -1 );
             s=s.replace( QRegExp( "\\" ), "/" );
             append(s);
-            //                    qDebug(s);
+            //                    odebug << s << oendl;
          } else { // is url
             s.replace( QRegExp( "%20" )," " );
             QString name;
             //                     if( name.left( 4 ) == "http" ) {
             //                         name = s.right( s.length() - 7 );
             //                     } else {
             name = s;
             //                     }
             append(name);
-            //                    qDebug(name);
+            //                    odebug << name << oendl;
          }
       }
    }
 }
 
 void Om3u::readPls() { //it's a pls file
         QTextStream t( &f );
                                 t.setEncoding(QTextStream::UnicodeUTF8);
         QString s;
         while ( !t.atEnd() ) {
             s = t.readLine();
             if( s.left(4)  == "File" ) {
                 s = s.right( s.length() - 6 );
                 s.replace( QRegExp( "%20" )," ");
-//                qDebug( "adding " + s + " to playlist" );
+//                odebug << "adding " + s + " to playlist" << oendl;
                 // numberofentries=2
                 // File1=http
                 // Title
                 // Length
                 // Version
                 // File2=http
                 s = s.replace( QRegExp( "\\" ), "/" );
                 QFileInfo f( s );
                 QString name = fullBaseName ( f );
                 if( name.left( 4 ) == "http" ) {
                     name = s.right( s.length() - 7);
                 }  else {
                     name = s;
                 }
                 name = name.right( name.length() - name.findRev( "\\", -1, TRUE) - 1 );
                 if( s.at( s.length() - 4) == '.') // if this is probably a file
                 append(s);
                 else { //if its a url
                     if( name.right( 1 ).find( '/' ) == -1) {
                         s += "/";
                     }
                     append(s);
                 }
             }
         }
 }
 
 void Om3u::write() { //writes list to m3u file
   QString list;
         QTextStream t(&f);
   t.setEncoding(QTextStream::UnicodeUTF8);
   if(count()>0) {
     for ( QStringList::ConstIterator it = begin(); it != end(); ++it ) {
-       //      qDebug(*it);
+       //      odebug << *it << oendl;
                                 t << *it << "\n";
     }
   }
 //    f.close();
 }
 
 void Om3u::add(const QString &filePath) { //adds to m3u file
     append(filePath);
 }
 
 void Om3u::remove(const QString &filePath) { //removes from m3u list
   QString list, currentFile;
   if(count()>0) {
     for ( QStringList::ConstIterator it = begin(); it != end(); ++it ) {
       currentFile=*it;
-      //        qDebug(*it);
+      //        odebug << *it << oendl;
         
       if( filePath != currentFile)
         list += currentFile+"\n";
     }
     f.writeBlock( list, list.length() );
   }
 }
 
 void Om3u::deleteFile(const QString &filePath) {//deletes m3u file
      f.close();
      f.remove();
 
 }
 
 void Om3u::close() { //closes m3u file
     f.close();
 }
diff --git a/core/multimedia/opieplayer/playlistselection.cpp b/core/multimedia/opieplayer/playlistselection.cpp
index ad831cf..58c3966 100644
--- a/core/multimedia/opieplayer/playlistselection.cpp
+++ b/core/multimedia/opieplayer/playlistselection.cpp
@@ -1,93 +1,98 @@
 /**********************************************************************
 ** Copyright (C) 2000-2002 Trolltech AS.  All rights reserved.
 **
 ** This file is part of the 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.
 **
 **********************************************************************/
 
-#include <qheader.h>
-
 #include "playlistselection.h"
 
+/* OPIE */
+#include <opie2/odebug.h>
+
+/* QT */
+#include <qheader.h>
+
+/* STD */
 #include <stdlib.h>
 
 class PlayListSelectionItem : public QListViewItem {
 public:
     PlayListSelectionItem( QListView *parent, const DocLnk *f ) : QListViewItem( parent ), fl( f ) {
   setText( 0, f->name() );
   setPixmap( 0, f->pixmap() );
     }
 
     ~PlayListSelectionItem() {
     };
 
     const DocLnk *file() const { return fl; }
 
 private:
     const DocLnk *fl;
 };
 
 
 PlayListSelection::PlayListSelection( QWidget *parent, const char *name )
     : QListView( parent, name )
 {
-//    qDebug("starting playlistselector");
+//    odebug << "starting playlistselector" << oendl;
 // #ifdef USE_PLAYLIST_BACKGROUND
 //    setStaticBackground( TRUE );
 //      setBackgroundPixmap( Resource::loadPixmap( "opieplayer/background" ) );
 
 //      setBackgroundPixmap( Resource::loadPixmap( "launcher/opielogo" ) );
 // #endif
 //      addColumn("Title",236);
 //      setAllColumnsShowFocus( TRUE );
      addColumn( tr( "Playlist Selection" ) );
     header()->hide();
 //    setSorting( -1, FALSE );
   // FIXME
 }
 
 
 PlayListSelection::~PlayListSelection() {
 }
 
 
 // #ifdef USE_PLAYLIST_BACKGROUND
 void PlayListSelection::drawBackground( QPainter *p, const QRect &r ) {
-//  qDebug("drawBackground");
+//  odebug << "drawBackground" << oendl;
    p->fillRect( r, QBrush( white ) );
 //        QImage logo = Resource::loadImage( "launcher/opielogo" );
 //          if ( !logo.isNull() )
 //        p->drawImage( (width() - logo.width()) / 2, (height() - logo.height()) / 2, logo );
 }
 // #endif
 
 
 void PlayListSelection::contentsMouseMoveEvent( QMouseEvent *event ) {
     if ( event->state() == QMouseEvent::LeftButton ) {
   QListViewItem *currentItem = selectedItem();
   QListViewItem *itemUnder = itemAt( QPoint( event->pos().x(), event->pos().y() - contentsY() ) );
   if ( currentItem && currentItem->itemAbove() == itemUnder )
       moveSelectedUp();
   else if ( currentItem && currentItem->itemBelow() == itemUnder )
       moveSelectedDown();
     }
 }
 
 
 const DocLnk *PlayListSelection::current() {
     PlayListSelectionItem *item = (PlayListSelectionItem *)selectedItem();
     if ( item )
   return item->file();
@@ -165,44 +170,44 @@ bool PlayListSelection::first() {
 bool PlayListSelection::last() {
     QListViewItem *prevItem = NULL;
     QListViewItem *item = firstChild();
     while ( ( item = item->nextSibling() ) )
   prevItem = item;
     if ( prevItem )
         setSelected( prevItem, TRUE );
     else
   return FALSE;
     ensureItemVisible( selectedItem() );
     return TRUE;
 }
 
 void PlayListSelection::unSelect()
 {
     QListViewItem *item = selectedItem();
     setSelected( currentItem(), FALSE);
 }
 
 void PlayListSelection::writeCurrent( Config& cfg ) {
     cfg.setGroup("PlayList");
     QListViewItem *item = selectedItem();
     if ( item )
         cfg.writeEntry("current", item->text(0) );
-    //    qDebug(item->text(0));
+    //    odebug << item->text(0) << oendl;
 
 }
 
 void  PlayListSelection::setSelectedItem(const QString &strk ) {
 
     unSelect();
     QListViewItemIterator it( this );
     for ( ; it.current(); ++it ) {
-//        qDebug( it.current()->text(0));
+//        odebug << it.current()->text(0) << oendl;
         if( strk == it.current()->text(0)) {
-//             qDebug( "We have a match "+strk);
+//             odebug << "We have a match "+strk << oendl;
             setSelected( it.current(), TRUE);
             ensureItemVisible( it.current() );
             return;
         }
     }
 //     setSelected( item, TRUE );
 //     ensureItemVisible( selectedItem() );
 }
diff --git a/core/multimedia/opieplayer/playlistwidget.cpp b/core/multimedia/opieplayer/playlistwidget.cpp
index 3609f5d..d85ce50 100644
--- a/core/multimedia/opieplayer/playlistwidget.cpp
+++ b/core/multimedia/opieplayer/playlistwidget.cpp
@@ -1,65 +1,67 @@
 /**********************************************************************
 ** 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.
 **
 **********************************************************************/
 // code added by L. J. Potter Sat 03-02-2002 06:17:54
 #define QTOPIA_INTERNAL_FSLP
 
-#include <qtoolbar.h>
+#include "playlistselection.h"
+#include "playlistwidget.h"
+#include "mediaplayerstate.h"
+#include "inputDialog.h"
+#include "audiowidget.h"
+#include "videowidget.h"
+
+/* OPIE */
 #include <qpe/qpemenubar.h>
 #include <qpe/lnkproperties.h>
+#include <opie2/odebug.h>
 
+/* QT */
+#include <qtoolbar.h>
 #include <qaction.h>
 #include <qlayout.h>
 #include <qmessagebox.h>
-
 //#include <qtimer.h>
 
-#include "playlistselection.h"
-#include "playlistwidget.h"
-#include "mediaplayerstate.h"
-
-#include "inputDialog.h"
-
+/* STD */
 #include <stdlib.h>
-#include "audiowidget.h"
-#include "videowidget.h"
 
 #include <unistd.h>
 #include <sys/file.h>
 #include <sys/ioctl.h>
 #include <sys/soundcard.h>
 
 // for setBacklight()
 #include <linux/fb.h>
 #include <sys/types.h>
 #include <sys/stat.h>
 #include <stdlib.h>
 
 #define BUTTONS_ON_TOOLBAR
 #define SIDE_BUTTONS
 #define CAN_SAVE_LOAD_PLAYLISTS
 
 extern AudioWidget *audioUI;
 extern VideoWidget *videoUI;
 extern MediaPlayerState *mediaPlayerState;
 
 static inline QString fullBaseName ( const QFileInfo &fi )
 {
   QString str = fi. fileName ( );
   return str. left ( str. findRev ( '.' ));
@@ -368,49 +370,49 @@ void PlayListWidget::readConfig( Config& cfg ) {
     for ( int i = 0; i < noOfFiles; i++ ) {
         QString entryName;
         entryName.sprintf( "File%i", i + 1 );
         QString linkFile = cfg.readEntry( entryName );
         DocLnk lnk( linkFile );
         if ( lnk.isValid() ) {
             d->selectedFiles->addToSelection( lnk );
         }
     }
     d->selectedFiles->setSelectedItem( currentString);
 }
 
 
 void PlayListWidget::writeConfig( Config& cfg ) const {
 
     d->selectedFiles->writeCurrent( cfg);
     cfg.setGroup("PlayList");
     int noOfFiles = 0;
     d->selectedFiles->first();
     do {
         const DocLnk *lnk = d->selectedFiles->current();
         if ( lnk ) {
             QString entryName;
             entryName.sprintf( "File%i", noOfFiles + 1 );
-//            qDebug(entryName);
+//            odebug << entryName << oendl;
             cfg.writeEntry( entryName, lnk->linkFile() );
               // if this link does exist, add it so we have the file
               // next time...
             if ( !QFile::exists( lnk->linkFile() ) ) {
                   // the way writing lnks doesn't really check for out
                   // of disk space, but check it anyway.
 //                  if ( !lnk->writeLink() ) {
 //                      QMessageBox::critical( 0, tr("Out of space"),
 //                                             tr( "There was a problem saving "
 //                                                 "the playlist.\n"
 //                                                 "Your playlist "
 //                                                 "may be missing some entries\n"
 //                                                 "the next time you start it." )
 //                                             );
 //                  }
 
             }      
             noOfFiles++;
         }
     }
     while ( d->selectedFiles->next() );
     cfg.writeEntry("NumberOfFiles", noOfFiles );
 }
 
@@ -462,130 +464,130 @@ void PlayListWidget::addAllMusicToList() {
     writeCurrentM3u();
     d->selectedFiles->first();
 }
 
 
 void PlayListWidget::addAllVideoToList() {
     QListIterator<DocLnk> dit( vFiles.children() );
     for ( ; dit.current(); ++dit )
         if(QFileInfo( dit.current()->file()).exists())
             d->selectedFiles->addToSelection( **dit );
     tabWidget->setCurrentPage(0);
     
     writeCurrentM3u();
     d->selectedFiles->first();
 }
 
 
 void PlayListWidget::setDocument(const QString& fileref) {
    fromSetDocument = true;
    d->setDocumentUsed = TRUE;
    setDocumentEx(fileref);
 }
 
 void PlayListWidget::setDocumentEx(const QString& fileref) {
-   qDebug("opieplayer receive "+fileref);
+   odebug << "opieplayer receive "+fileref << oendl;
    clearList();
    DocLnk lnk;
    QFileInfo fileInfo(fileref);
    if ( !fileInfo.exists() ) {
       QMessageBox::critical( 0, tr( "Invalid File" ),
                              tr( "There was a problem in getting the file." ) );
       return;
    }
-   //   qDebug("<<<<<<<<<<<<<<<<<<<<<<setDocument "+fileref);
+   //   odebug << "<<<<<<<<<<<<<<<<<<<<<<setDocument "+fileref << oendl;
    QString extension = fileInfo.extension(false);
      if( extension.find( "m3u", 0, false) != -1) { //is m3u
         readm3u( fileref);
      }
   else if( extension.find( "pls", 0, false) != -1 ) { //is pls
       readPls( fileref);
    }
    else if( fileref.find("playlist",0,TRUE) != -1) {//is playlist
       clearList();
       lnk.setName( fileInfo.baseName() ); //sets name
       lnk.setFile( fileref ); //sets file name
       lnk.setIcon("Sound");
       //addToSelection( lnk );
 
       loadList( lnk);
       d->selectedFiles->first();
    } else {
       if( fileref.find(".desktop",0,TRUE) != -1) {
          lnk = DocLnk(fileref);
       } else {
          lnk.setName( fileInfo.baseName() ); //sets name
          lnk.setFile( fileref ); //sets file name
          lnk.setIcon("Sound");
       }
 
       addToSelection( lnk );
       //        addToSelection( DocLnk( fileref ) );
       lnk.removeLinkFile();
       //        qApp->processEvents();
    }
       setCaption(tr("OpiePlayer"));
       d->setDocumentUsed = TRUE;
      d->selectedFiles->setSelected(d->selectedFiles->firstChild(),true );
       mediaPlayerState->setPlaying( FALSE );
       qApp->processEvents();
       mediaPlayerState->setPlaying( TRUE );
 
 }
 
 
 void PlayListWidget::setActiveWindow() {
-   //        qDebug("SETTING active window");
+   //        odebug << "SETTING active window" << oendl;
       // When we get raised we need to ensure that it switches views
     char origView = mediaPlayerState->view();
     mediaPlayerState->setView( 'l' ); // invalidate
     mediaPlayerState->setView( origView ); // now switch back
 }
 
 
 void PlayListWidget::useSelectedDocument() {
     d->setDocumentUsed = FALSE;
 }
 
 
 const DocLnk *PlayListWidget::current() { // this is fugly
    switch (tabWidget->currentPageIndex()) {
    case 0: //playlist
    {
-      //          qDebug("playlist");
+      //          odebug << "playlist" << oendl;
       if ( mediaPlayerState->playlist() ) {
          return d->selectedFiles->current();
       }
       else if ( d->setDocumentUsed && d->current ) {
          return d->current;
       } else {
          return &(d->files->selectedDocument());
       }
    }
    break;
    case 1://audio
    {
-      //          qDebug("audioView");
+      //          odebug << "audioView" << oendl;
       QListIterator<DocLnk> dit( files.children() );
       for ( ; dit.current(); ++dit ) {
          if( dit.current()->name() == audioView->currentItem()->text(0) && !insanityBool) {
             insanityBool=TRUE;
             return dit;
          }
       }
    }           
    break;
    case 2: // video
    {
       QListIterator<DocLnk> Vdit( vFiles.children() );
       for ( ; Vdit.current(); ++Vdit ) {
          if( Vdit.current()->name() == videoView->currentItem()->text(0) && !insanityBool) {
             insanityBool=TRUE;
             return Vdit;
          }
       }
    }
    break;
    };
    return 0;
 }
 
@@ -639,53 +641,53 @@ bool PlayListWidget::next() {
 
 
 bool PlayListWidget::first() {
    if ( mediaPlayerState->playlist() )
       return d->selectedFiles->first();
    else
       return mediaPlayerState->looping();
 }
 
 
 bool PlayListWidget::last() {
    if ( mediaPlayerState->playlist() )
       return d->selectedFiles->last();
    else
       return mediaPlayerState->looping();
 }
 
 
 void PlayListWidget::saveList() {
    writem3u();
 }
 
 void PlayListWidget::loadList( const DocLnk & lnk) {
    QString name = lnk.name();
-   //  qDebug("<<<<<<<<<<<<<<<<<<<<<<<<currentList is "+name);
+   //  odebug << "<<<<<<<<<<<<<<<<<<<<<<<<currentList is "+name << oendl;
 
    if( name.length()>0) {
       setCaption("OpiePlayer: "+name);
-      //       qDebug("<<<<<<<<<<<<load list "+ lnk.file());
+      //       odebug << "<<<<<<<<<<<<load list "+ lnk.file() << oendl;
       clearList();
       readm3u(lnk.file());
       tabWidget->setCurrentPage(0);
    }
 }
 
 void PlayListWidget::setPlaylist( bool shown ) {
    if ( shown ) 
       d->playListFrame->show();
    else
       d->playListFrame->hide();
 }
 
 void PlayListWidget::setView( char view ) {
    if ( view == 'l' )
       QPEApplication::showWidget( this );
    else
       hide();
 }
 
 void PlayListWidget::addSelected() {
    DocLnk lnk;
    QString filename;
    switch (tabWidget->currentPageIndex()) {
@@ -797,49 +799,49 @@ void PlayListWidget::tabChanged(QWidget *) {
       d->tbAddToList->setEnabled(TRUE);
    }
    break;
    case 3:
    {
       if( tbDeletePlaylist->isHidden())
          tbDeletePlaylist->show();
       playLists->reread();
    }
    break;
    };
 }
 
 void PlayListWidget::btnPlay(bool b) {
    //    mediaPlayerState->setPlaying(b);
    switch ( tabWidget->currentPageIndex()) {
    case 0:
    {
       //            if( d->selectedFiles->current()->file().find(" ",0,TRUE) != -1
       //                if( d->selectedFiles->current()->file().find("%20",0,TRUE) != -1) {
       //                 QMessageBox::message("Note","You are trying to play\na malformed url.");
       //            } else {
       mediaPlayerState->setPlaying(b);
       insanityBool=FALSE;
-      qDebug("insanity");              
+      odebug << "insanity" << oendl;
       //          }
    }
    break;
    case 1:
    {
       //          d->selectedFiles->unSelect();
       addToSelection( audioView->currentItem() );
       mediaPlayerState->setPlaying( b);
       d->selectedFiles->removeSelected( );
       d->selectedFiles->unSelect();
       tabWidget->setCurrentPage(1);
       insanityBool=FALSE;         
    }//          audioView->clearSelection();
    break;
    case 2:
    {
           
       addToSelection( videoView->currentItem() );
       mediaPlayerState->setPlaying( b);
       //          qApp->processEvents();
       d->selectedFiles->removeSelected( );
       d->selectedFiles->unSelect();
       tabWidget->setCurrentPage(2);
       insanityBool=FALSE;
@@ -930,512 +932,512 @@ void PlayListWidget::listDelete() {
       populateAudioView();
    }
    break;
    case 2:
    {
       //           file = videoView->selectedItem()->text(0);
       //           for ( int i = 0; i < noOfFiles; i++ ) {
       //               QString entryName;
       //               entryName.sprintf( "File%i", i + 1 );
       //               QString linkFile = cfg.readEntry( entryName );
       //                   AppLnk lnk( AppLnk(linkFile));
       //               if( lnk.name() == file ) {
       //                   LnkProperties prop( &lnk);
       // //  connect(&prop, SIGNAL(select(const AppLnk*)), this, SLOT(externalSelected(const AppLnk*)));
       //                   prop.showMaximized();
       //                   prop.exec();
       //               }
       //            }
    }
    break;
    };
 }
 
 void PlayListWidget::scanForAudio() {
-   //    qDebug("scan for audio");
+   //    odebug << "scan for audio" << oendl;
    files.detachChildren();
    QListIterator<DocLnk> sdit( files.children() );
    for ( ; sdit.current(); ++sdit ) {
       delete sdit.current();
    }
    Global::findDocuments( &files, audioMimes);
    audioScan = true;
 }
 void PlayListWidget::scanForVideo() {
-   //    qDebug("scan for video");
+   //    odebug << "scan for video" << oendl;
    vFiles.detachChildren();
    QListIterator<DocLnk> sdit( vFiles.children() );
    for ( ; sdit.current(); ++sdit ) {
       delete sdit.current();
    }
    Global::findDocuments(&vFiles, "video/*");
    videoScan = true;
 }
 
 void PlayListWidget::populateAudioView() {
 
    audioView->clear();
    StorageInfo storageInfo;
    const QList<FileSystem> &fs = storageInfo.fileSystems();
    if(!audioScan) scanForAudio();
 
    QListIterator<DocLnk> dit( files.children() );
    QListIterator<FileSystem> it ( fs );
 
    QString storage;
    for ( ; dit.current(); ++dit ) {
       for( ; it.current(); ++it ){
          const QString name = (*it)->name();
          const QString path = (*it)->path();
          if(dit.current()->file().find(path) != -1 ) storage=name;
       }
 
       QListViewItem * newItem;
       if ( QFile( dit.current()->file()).exists() || dit.current()->file().left(4) == "http" ) {
          long size;
          if( dit.current()->file().left(4) == "http" )
             size=0;
          else 
             size = QFile( dit.current()->file() ).size();
-         //            qDebug(dit.current()->name());
+         //            odebug << dit.current()->name() << oendl;
          newItem= /*(void)*/ new QListViewItem( audioView, dit.current()->name(),
                                                 QString::number(size ), storage, dit.current()->file());
          newItem->setPixmap(0, Resource::loadPixmap( "opieplayer/musicfile" ));
       }
    }
 
 }
 
 void PlayListWidget::populateVideoView() {
     videoView->clear();
     StorageInfo storageInfo;
     const QList<FileSystem> &fs = storageInfo.fileSystems();
 
     if(!videoScan ) scanForVideo();
 
     QListIterator<DocLnk> Vdit( vFiles.children() );
     QListIterator<FileSystem> it ( fs );
     videoView->clear();
     QString storage;
     for ( ; Vdit.current(); ++Vdit ) {
         for( ; it.current(); ++it ){
             const QString name = (*it)->name();
             const QString path = (*it)->path();
             if( Vdit.current()->file().find(path) != -1 ) storage=name;
         }
 
         QListViewItem * newItem;
         if ( QFile( Vdit.current()->file()).exists() ) {
             newItem= /*(void)*/ new QListViewItem( videoView, Vdit.current()->name(),
                    QString::number( QFile( Vdit.current()->file() ).size() ),
                                                    storage, Vdit.current()->file());
             newItem->setPixmap(0, Resource::loadPixmap( "opieplayer/videofile" ));
         }
     }
 }
 
 void PlayListWidget::openFile() {
    QString filename, name;
    InputDialog *fileDlg;
    fileDlg = new InputDialog(this,tr("Open file or URL"),TRUE, 0);
    fileDlg->exec();
    if( fileDlg->result() == 1 ) {
       filename = fileDlg->text();
-      //        qDebug( "Selected filename is " + filename );
+      //        odebug << "Selected filename is " + filename << oendl;
       DocLnk lnk;
       Config cfg( "OpiePlayer" );
       cfg.setGroup("PlayList");
 
       QString m3uFile;
       m3uFile = filename;
       if(filename.left(4) == "http") {
          if(filename.find(":",8,TRUE) != -1) { //found a port
 
             m3uFile = filename;
             if( m3uFile.right( 1 ).find( '/' ) == -1) {
                m3uFile += "/";
             }
             filename = m3uFile;
          }
          lnk.setName( m3uFile ); //sets name
          lnk.setFile( filename ); //sets file name
          lnk.setIcon("opieplayer2/musicfile");
          d->selectedFiles->addToSelection(  lnk );
          writeCurrentM3u();
       }
       else if( filename.right( 3) == "m3u" ) {
          readm3u( filename );
 
       } else if( filename.right(3) == "pls" ) {
          readPls( filename );
       } else {
          lnk.setName( fullBaseName ( QFileInfo(filename)) ); //sets name
          lnk.setFile( filename ); //sets file name
          d->selectedFiles->addToSelection(  lnk);
          lnk.removeLinkFile();
          writeCurrentM3u();
       }
    }
             
    if( fileDlg ) {
       delete fileDlg;
    }
 }
 
 
 /*
 reads m3u and shows files/urls to playlist widget */
 void PlayListWidget::readm3u( const QString &filename ) { 
-   //    qDebug( "read m3u filename " + filename );
+   //    odebug << "read m3u filename " + filename << oendl;
 
    Om3u *m3uList;
    QString s, name;
    m3uList = new Om3u( filename, IO_ReadOnly );
    m3uList->readM3u();
    DocLnk lnk;
    for ( QStringList::ConstIterator it = m3uList->begin(); it != m3uList->end(); ++it ) {
       s = *it;
-      //          qDebug("reading "+ s);
+      //          odebug << "reading "+ s << oendl;
       if(s.left(4)=="http") {
          lnk.setName( s ); //sets file name
          lnk.setIcon("opieplayer2/musicfile");
 
          //          if(s.right(4) != '.' || s.right(5) != '.')
          if(s.right(4) != '.' || s.right(5) != '.' )
             if( s.right(1) != "/")
                lnk.setFile( s+"/"); //if url with no extension
             else
                lnk.setFile( s ); //sets file name
             
       }  else {
          //               if( QFileInfo( s ).exists() ) {
          lnk.setName( fullBaseName ( QFileInfo(s)));
          //                 if(s.right(4) == '.')   {//if regular file
          if(s.left(1) != "/")  { 
-            //            qDebug("set link "+QFileInfo(filename).dirPath()+"/"+s);
+            //            odebug << "set link "+QFileInfo(filename).dirPath()+"/"+s << oendl;
             lnk.setFile( QFileInfo(filename).dirPath()+"/"+s);
             lnk.setIcon("SoundPlayer");
          } else {
-            //            qDebug("set link2 "+s);
+            //            odebug << "set link2 "+s << oendl;
             lnk.setFile( s);
             lnk.setIcon("SoundPlayer");
          }
       }
       d->selectedFiles->addToSelection( lnk );
    }
    Config config( "OpiePlayer" );
    config.setGroup( "PlayList" );
 
    config.writeEntry("CurrentPlaylist",filename);
    config.write();
    currentPlayList=filename;
 
 //    m3uList->write();
    m3uList->close();
    if(m3uList) delete m3uList;
 
    d->selectedFiles->setSelectedItem( s);
    setCaption(tr("OpiePlayer: ")+ fullBaseName ( QFileInfo(filename)));
     
 }
 
 /*
 reads pls and adds files/urls to playlist  */
 void PlayListWidget::readPls( const QString &filename ) {
 
-   //    qDebug( "pls filename is " + filename );
+   //    odebug << "pls filename is " + filename << oendl;
    Om3u *m3uList;
    QString s, name;
    m3uList = new Om3u( filename, IO_ReadOnly );
    m3uList->readPls();
 
    for ( QStringList::ConstIterator it = m3uList->begin(); it != m3uList->end(); ++it ) {
       s = *it;
       //        s.replace( QRegExp( "%20" )," " );
       DocLnk lnk( s );
       QFileInfo f( s );
       QString name = fullBaseName ( f);
 
       if( name.left( 4 ) == "http" ) {
          name = s.right( s.length() - 7);
       }  else {
          name = s;
       }
 
       name = name.right( name.length() - name.findRev( "\\", -1, TRUE) - 1 );
 
       lnk.setName( name );
       if( s.at( s.length() - 4) == '.') {// if this is probably a file
          lnk.setFile( s );
       } else { //if its a url
          if( name.right( 1 ).find( '/' ) == -1) {
             s += "/";
          }
          lnk.setFile( s );
       }
       lnk.setType( "audio/x-mpegurl" );
 
       lnk.writeLink();
       d->selectedFiles->addToSelection( lnk );
    }
 
    m3uList->close();
    if(m3uList) delete m3uList;
 }
 
 /*
  writes current playlist to current m3u file */
 void PlayListWidget::writeCurrentM3u() {
-   //  qDebug("writing to current m3u");
+   //  odebug << "writing to current m3u" << oendl;
   Config cfg( "OpiePlayer" );
   cfg.setGroup("PlayList");
   currentPlayList = cfg.readEntry("CurrentPlaylist","");
   Om3u *m3uList;
   m3uList = new Om3u( currentPlayList, IO_ReadWrite | IO_Truncate );
 
   if( d->selectedFiles->first()) {
   do {
-     //      qDebug( "writeCurrentM3u " +d->selectedFiles->current()->file());
+     //      odebug << "writeCurrentM3u " +d->selectedFiles->current()->file() << oendl;
     m3uList->add( d->selectedFiles->current()->file() );
   }
   while ( d->selectedFiles->next() );
-  //    qDebug( "<<<<<<<<<<<<>>>>>>>>>>>>>>>>>" );
+  //    odebug << "<<<<<<<<<<<<>>>>>>>>>>>>>>>>>" << oendl;
   m3uList->write();
   m3uList->close();
 
   if(m3uList) delete m3uList;
   }
 }
 
   /*
  writes current playlist to m3u file */
 void PlayListWidget::writem3u() {
    InputDialog *fileDlg;
    fileDlg = new InputDialog( this, tr( "Save m3u Playlist " ), TRUE, 0);
    fileDlg->exec();
    QString name, filename, list;
    Om3u *m3uList;
 
    if( fileDlg->result() == 1 ) {
       name = fileDlg->text();
-      //        qDebug( filename );
+      //        odebug << filename << oendl;
       if( name.find("/",0,true) != -1) {// assume they specify a file path
          filename = name;
          name = name.right(name.length()- name.findRev("/",-1,true) - 1 );
       }
       else //otherwise dump it somewhere noticable
          filename = QPEApplication::documentDir() + "/" + name;
 
       if( filename.right( 3 ) != "m3u" ) //needs filename extension
          filename += ".m3u";
         
       if( d->selectedFiles->first()) {
          m3uList = new Om3u(filename, IO_ReadWrite | IO_Truncate);
 
          do {
             m3uList->add( d->selectedFiles->current()->file());
          }
          while ( d->selectedFiles->next() );
-         //    qDebug( list );
+         //    odebug << list << oendl;
          m3uList->write();
          m3uList->close();
          if(m3uList) delete m3uList;
         
          if(fileDlg) delete fileDlg;
 
          DocLnk lnk;
          lnk.setFile( filename);
          lnk.setIcon("opieplayer2/playlist2");
          lnk.setName( name); //sets file name
 
-         // qDebug(filename);
+         // odebug << filename << oendl;
          Config config( "OpiePlayer" );
          config.setGroup( "PlayList" );
     
          config.writeEntry("CurrentPlaylist",filename);
          currentPlayList=filename;
 
          if(!lnk.writeLink()) {
-            //            qDebug("Writing doclink did not work");
+            //            odebug << "Writing doclink did not work" << oendl;
          }
 
          setCaption(tr("OpiePlayer: ") + name);
       }
    }
 }
 
 
 void PlayListWidget::keyReleaseEvent( QKeyEvent *e)
 {
     switch ( e->key() ) {
 ////////////////////////////// Zaurus keys
       case Key_F9: //activity
 //           if(audioUI->isHidden())
 //             audioUI->showMaximized();
           break;
       case Key_F10: //contacts
 //           if( videoUI->isHidden())
 //             videoUI->showMaximized();
           break;
       case Key_F11: //menu
           break;
       case Key_F12: //home
 //           doBlank();
           break;
       case Key_F13: //mail
 //           doUnblank();
           break;
       case Key_Q: //add to playlist
           addSelected();
           break;
       case Key_R: //remove from playlist
           removeSelected();
           break;
 //       case Key_P: //play
-//           qDebug("Play");
+//           odebug << "Play" << oendl;
 //           playSelected();
 //           break;
       case Key_Space:
 //          playSelected(); puh
           break;
       case Key_1:
           tabWidget->setCurrentPage(0);
           break;
       case Key_2:
           tabWidget->setCurrentPage(1);
           break;
     case Key_3:
       tabWidget->setCurrentPage(2);
       break;
     case Key_4:
       tabWidget->setCurrentPage(3);         
       break;
     case Key_Down:
       if ( !d->selectedFiles->next() )
         d->selectedFiles->first();
 
       break;
     case Key_Up:
       if ( !d->selectedFiles->prev() )
         //        d->selectedFiles->last();
 
       break;
       
     }
 }
 
 void PlayListWidget::keyPressEvent( QKeyEvent *)
 {
-//    qDebug("Key press");
+//    odebug << "Key press" << oendl;
 //     switch ( e->key() ) {
 // ////////////////////////////// Zaurus keys
 //       case Key_A: //add to playlist
-//           qDebug("Add");
+//           odebug << "Add" << oendl;
 //           addSelected();
 //           break;
 //       case Key_R: //remove from playlist
 //           removeSelected();
 //           break;
 //       case Key_P: //play
-//           qDebug("Play");
+//           odebug << "Play" << oendl;
 //           playSelected();
 //           break;
 //       case Key_Space:
-//           qDebug("Play");
+//           odebug << "Play" << oendl;
 //           playSelected();
 //           break;
 //     }
 }
 
 void PlayListWidget::doBlank() {
-   //    qDebug("do blanking");
+   //    odebug << "do blanking" << oendl;
 #ifdef QT_QWS_DEVFS
    fd=open("/dev/fb/0",O_RDWR);
 #else
    fd=open("/dev/fb0",O_RDWR);
 #endif
    if (fd != -1) {
       ioctl(fd,FBIOBLANK,1);
       //            close(fd);
    }
 }
 
 void PlayListWidget::doUnblank() {
    // this crashes opieplayer with a segfault
    //      int fd;
    //       fd=open("/dev/fb0",O_RDWR);
-   //    qDebug("do unblanking");
+   //    odebug << "do unblanking" << oendl;
    if (fd != -1) {
       ioctl(fd,FBIOBLANK,0);
       close(fd);
    }
    QCopEnvelope h("QPE/System", "setBacklight(int)");
    h <<-3;// v[1]; // -3 Force on
 }
 
 void PlayListWidget::populateSkinsMenu() {
    int item = 0;
    defaultSkinIndex = 0;
    QString skinName;
    Config cfg( "OpiePlayer" );
    cfg.setGroup("Options" );
    QString skin = cfg.readEntry( "Skin", "default" );
 
    QDir skinsDir( QPEApplication::qpeDir() + "/pics/opieplayer2/skins" );
    skinsDir.setFilter( QDir::Dirs );
    skinsDir.setSorting(QDir::Name );
    const QFileInfoList *skinslist = skinsDir.entryInfoList();
    QFileInfoListIterator it( *skinslist );
    QFileInfo *fi;
    while ( ( fi = it.current() ) ) {
       skinName =  fi->fileName();
-      //        qDebug(  fi->fileName() );
+      //        odebug << fi->fileName() << oendl;
       if( skinName != "." &&  skinName != ".." && skinName !="CVS" )  {
          item = skinsMenu->insertItem( fi->fileName() ) ;
       }
       if( skinName == "default" ) {
          defaultSkinIndex = item;
       }
       if( skinName == skin ) {
          skinsMenu->setItemChecked( item, TRUE );
       }
       ++it;
    }
 }
 
 void PlayListWidget::skinsMenuActivated( int item ) {
    for( int i = defaultSkinIndex; i > defaultSkinIndex - skinsMenu->count(); i-- ) {
       skinsMenu->setItemChecked( i, FALSE );
    }
    skinsMenu->setItemChecked( item, TRUE );
 
    Config cfg( "OpiePlayer" );
    cfg.setGroup("Options");
    cfg.writeEntry("Skin", skinsMenu->text( item ) );
 }
 
 void PlayListWidget::qcopReceive(const QCString &msg, const QByteArray &data) {
-   //   qDebug("qcop message "+msg );
+   //   odebug << "qcop message "+msg << oendl;
    QDataStream stream ( data, IO_ReadOnly );
    if ( msg == "play()" ) { //plays current selection
       btnPlay( true);
    } else if ( msg == "stop()" ) {
       mediaPlayerState->setPlaying( false);
    } else if ( msg == "togglePause()" ) {
       mediaPlayerState->togglePaused();
    } else if ( msg == "next()" ) { //select next in lis
       mediaPlayerState->setNext();      
    } else if ( msg == "prev()" ) { //select previous in list
       mediaPlayerState->setPrev();      
    } else if ( msg == "toggleLooping()" ) { //loop or not loop
       mediaPlayerState->toggleLooping();
    } else if ( msg == "toggleShuffled()" ) { //shuffled or not shuffled
       mediaPlayerState->toggleShuffled();
    } else if ( msg == "volUp()" ) { //volume more
       //       emit moreClicked();
       //       emit moreReleased();
    } else if ( msg == "volDown()" ) { //volume less
       //       emit lessClicked();
       //       emit lessReleased();
    } else if ( msg == "play(QString)" ) { //play this now
       QString file;
       stream >> file;
diff --git a/core/multimedia/opieplayer/videowidget.cpp b/core/multimedia/opieplayer/videowidget.cpp
index 164458b..e851044 100644
--- a/core/multimedia/opieplayer/videowidget.cpp
+++ b/core/multimedia/opieplayer/videowidget.cpp
@@ -1,52 +1,57 @@
 /**********************************************************************
  ** 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.
  **
  **********************************************************************/
+
+#include "videowidget.h"
+#include "mediaplayerstate.h"
+
+/* OPIE */
 #include <qpe/resource.h>
 #include <qpe/mediaplayerplugininterface.h>
 #include <qpe/config.h>
 #include <qpe/qpeapplication.h>
+#include <opie2/odebug.h>
 
+/* QT */
 #include <qdir.h>
 #include <qslider.h>
-#include "videowidget.h"
-#include "mediaplayerstate.h"
 
 
 #ifdef Q_WS_QWS
 # define USE_DIRECT_PAINTER
 # include <qdirectpainter_qws.h>
 # include <qgfxraster_qws.h>
 #endif
 
 
 extern MediaPlayerState *mediaPlayerState;
 
 
 static const int xo = 2; // movable x offset
 static const int yo = 0; // movable y offset
 
 
 struct MediaButton {
 //     int  xPos, yPos;
    bool isToggle, isHeld, isDown;
 //     int  controlType;
 };
 
 
 // Layout information for the videoButtons (and if it is a toggle button or not)
@@ -61,90 +66,90 @@ MediaButton videoButtons[] = {
 };
 
 //static const int numButtons = (sizeof(videoButtons)/sizeof(MediaButton));
 
 const char *skinV_mask_file_names[7] = {
    "stop","play","back","fwd","up","down","full"
 };
 
 static const int numVButtons = (sizeof(videoButtons)/sizeof(MediaButton));
 
 VideoWidget::VideoWidget(QWidget* parent, const char* name, WFlags f) :
    QWidget( parent, name, f ), scaledWidth( 0 ), scaledHeight( 0 )
 {
    setCaption( tr("OpiePlayer") );
    Config cfg("OpiePlayer");
 
    cfg.setGroup("Options");
    skin = cfg.readEntry("Skin","default");
 
    QString skinPath;
    skinPath = "opieplayer2/skins/" + skin;
     if(!QDir(QString(getenv("OPIEDIR")) +"/pics/"+skinPath).exists())
       skinPath = "opieplayer2/skins/default";
 
-    //   qDebug("skin path " + skinPath);
+    //   odebug << "skin path " + skinPath << oendl;
 
 //     QString skinPath = "opieplayer2/skins/" + skin;
 
    pixBg = new QPixmap( Resource::loadPixmap( QString("%1/background").arg(skinPath) ) );
    imgUp = new QImage( Resource::loadImage( QString("%1/skinV_up").arg(skinPath) ) );
    imgDn = new QImage( Resource::loadImage( QString("%1/skinV_down").arg(skinPath) ) );
 
    imgButtonMask = new QImage( imgUp->width(), imgUp->height(), 8, 255 );
    imgButtonMask->fill( 0 );
 
    for ( int i = 0; i < 7; i++ ) {
       QString filename = QString( QPEApplication::qpeDir() + "/pics/" + skinPath +
                                   "/skinV_mask_" + skinV_mask_file_names[i] + ".png" );
-      //      qDebug("loading "+filename);
+      //      odebug << "loading "+filename << oendl;
       masks[i] = new QBitmap( filename );
 
       if ( !masks[i]->isNull() ) {
          QImage imgMask = masks[i]->convertToImage();
          uchar **dest = imgButtonMask->jumpTable();
          for ( int y = 0; y < imgUp->height(); y++ ) {
             uchar *line = dest[y];
             for ( int x = 0; x < imgUp->width(); x++ ) {
                if ( !qRed( imgMask.pixel( x, y ) ) )
                   line[x] = i + 1;
             }
          }
       }
    }
-   //   qDebug("finished loading first pics");
+   //   odebug << "finished loading first pics" << oendl;
    for ( int i = 0; i < 7; i++ ) {
       buttonPixUp[i] = NULL;
       buttonPixDown[i] = NULL;
    }
 
 
                 QWidget *d = QApplication::desktop();
                 int width = d->width();
                 int height = d->height();
 
     if( (width != pixBg->width() ) || (height != pixBg->height() ) ) {
-        //                      qDebug("<<<<<<<< scale image >>>>>>>>>>>>");
+//              odebug << "<<<<<<<< scale image >>>>>>>>>>>>" << oendl;
                                 QImage img;
                                 img = pixBg->convertToImage();
                                 pixBg->convertFromImage( img.smoothScale( width, height));
                 }
    setBackgroundPixmap( *pixBg );
 
    currentFrame = new QImage( 220 + 2, 160, (QPixmap::defaultDepth() == 16) ? 16 : 32 );
 
    slider = new QSlider( Qt::Horizontal, this );
    slider->setMinValue( 0 );
    slider->setMaxValue( 1 );
    slider->setBackgroundPixmap( Resource::loadPixmap( backgroundPix ) );
    slider->setFocusPolicy( QWidget::NoFocus );
 //    slider->setGeometry( QRect( 7, 250, 220, 20 ) );
 
    connect( slider,         SIGNAL( sliderPressed() ),      this, SLOT( sliderPressed() ) );
    connect( slider,         SIGNAL( sliderReleased() ),     this, SLOT( sliderReleased() ) );
 
    connect( mediaPlayerState, SIGNAL( lengthChanged(long) ),  this, SLOT( setLength(long) ) );
    connect( mediaPlayerState, SIGNAL( positionChanged(long) ),this, SLOT( setPosition(long) ) );
    connect( mediaPlayerState, SIGNAL( positionUpdated(long) ),this, SLOT( setPosition(long) ) );
    connect( mediaPlayerState, SIGNAL( viewChanged(char) ),    this, SLOT( setView(char) ) );
 //   connect( mediaPlayerState, SIGNAL( pausedToggled(bool) ),  this, SLOT( setPaused(bool) ) );
    connect( mediaPlayerState, SIGNAL( playingToggled(bool) ), this, SLOT( setPlaying(bool) ) );
@@ -332,62 +337,62 @@ void VideoWidget::mouseMoveEvent( QMouseEvent *event ) {
 
                 switch (i) {
                 case VideoVolUp:
                     emit moreClicked();
                     return;
                 case VideoVolDown:
                     emit lessClicked();
                     return;
                 }
             } else if ( !isOnButton && videoButtons[i].isHeld ) {
                         videoButtons[i].isHeld = FALSE;
                         toggleButton(i);
             }
         } else {
 
             if ( videoButtons[i].isHeld ) {
                 videoButtons[i].isHeld = FALSE;
                 if ( !videoButtons[i].isToggle ) {
                     setToggleButton( i, FALSE );
                 }
 
                 switch(i) {
 
                 case VideoPlay: {
-                   //                   qDebug("play");
+                   //                   odebug << "play" << oendl;
                    if(  !mediaPlayerState->playing()) {
                       mediaPlayerState->setPlaying( true);
                       setToggleButton( i-1, false );
                       setToggleButton( i, false );
                       return;
                    }
                    if( mediaPlayerState->isPaused ) {
-                      //                      qDebug("isPaused");
+                      //                      odebug << "isPaused" << oendl;
                       setToggleButton( i, FALSE );
                       mediaPlayerState->setPaused( FALSE );
                         return;
                     } else if( !mediaPlayerState->isPaused ) {
-                       //                       qDebug("is not paused");
+                       //                       odebug << "is not paused" << oendl;
                         setToggleButton( i, TRUE );
                         mediaPlayerState->setPaused( TRUE );
                         return;
                     } else {
                         return;
                     }
                 }
 
                 case VideoStop:  mediaPlayerState->setPlaying( FALSE ); setToggleButton( i+1, true); setToggleButton( i, true ); return;
                 case VideoNext:  mediaPlayerState->setNext(); return;
                 case VideoPrevious:    mediaPlayerState->setPrev(); return;
                 case VideoVolUp:      emit moreReleased(); return;
                 case VideoVolDown:    emit lessReleased(); return;
                 case VideoFullscreen: mediaPlayerState->setFullscreen( TRUE ); makeVisible(); return;
                 }
             }
         }
     }
 }
 
 
 void VideoWidget::mousePressEvent( QMouseEvent *event ) {
    mouseMoveEvent( event );
 }
@@ -437,49 +442,49 @@ void VideoWidget::paintEvent( QPaintEvent * pe) {
          p.translate( -pe->rect().topLeft().x(), -pe->rect().topLeft().y() );
          p.drawTiledPixmap( pe->rect(), *pixBg, pe->rect().topLeft() );
          for ( int i = 0; i < numVButtons; i++ ) {
             paintButton( &p, i );
          }
          QPainter p2( this );
          p2.drawPixmap( pe->rect().topLeft(), pix );
       } else {
          QPainter p( this );
          for ( int i = 0; i < numVButtons; i++ )
             paintButton( &p, i );
       }
       slider->repaint( TRUE );
    }
 }
 
 
 void VideoWidget::closeEvent( QCloseEvent* ) {
    mediaPlayerState->setList();
 }
 
 
 bool VideoWidget::playVideo() {
    bool result = FALSE;
-//   qDebug("<<<<<<<<<<<<<<<< play video");
+//   odebug << "<<<<<<<<<<<<<<<< play video" << oendl;
    int stream = 0;
 
    int sw = mediaPlayerState->curDecoder()->videoWidth( stream );
    int sh = mediaPlayerState->curDecoder()->videoHeight( stream );
    int dd = QPixmap::defaultDepth();
    int w = height();
    int h = width();
 
    ColorFormat format = (dd == 16) ? RGB565 : BGRA8888;
 
    if ( mediaPlayerState->fullscreen() )
    {
 #ifdef USE_DIRECT_PAINTER
       QDirectPainter p(this);
 
       if ( ( qt_screen->transformOrientation() == 3 ) &&
            ( ( dd == 16 ) || ( dd == 32 ) ) && ( p.numRects() == 1 ) )
       {
 
          w = 320;
          h = 240;
 
          if ( mediaPlayerState->scaled() )
          {
diff --git a/core/multimedia/opieplayer/vorbis/libtremorplugin.cpp b/core/multimedia/opieplayer/vorbis/libtremorplugin.cpp
index 53c4b2b..0002213 100644
--- a/core/multimedia/opieplayer/vorbis/libtremorplugin.cpp
+++ b/core/multimedia/opieplayer/vorbis/libtremorplugin.cpp
@@ -1,272 +1,277 @@
 /****************************************************************************
 * libtremorplugin.cpp
 *
 * Copyright (C) 2002 Latchesar Ionkov <lucho@ionkov.net>
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * 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 General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 ****************************************************************************/
 // fixed and adapted for opieplayer 2003 ljp <llornkcor@handhelds.org>
 
+#include "libtremorplugin.h"
+
+/* OPIE */
+#include <opie2/odebug.h>
+
+/* QT */
+#include <qmap.h>
+
+/* STD */
 #include <stdio.h>
 #include <stdarg.h>
 #include <stdlib.h>
 #include <sys/types.h>
 #include <sys/stat.h>
 #include <fcntl.h>
 #include <unistd.h>
 #include <string.h>
 #include <errno.h>
 #include <time.h>
 #include <locale.h>
 #include <math.h>
 #include <assert.h>
 
-#include <qmap.h>
-
-#include "libtremorplugin.h"
-
 
 extern "C" {
 #include "tremor/ivorbisfile.h"
 }
 
 
 #define MPEG_BUFFER_SIZE    65536
 //#define debugMsg(a) qDebug(a)
 #define debugMsg(a)
 
 
 class LibTremorPluginData {
 public:
   char* filename;
   FILE* f;
   OggVorbis_File vf;
   vorbis_info* vi;
   vorbis_comment* vc;
   bool bos;
   int csection;
   QString finfo;
 };
 
 
 LibTremorPlugin::LibTremorPlugin() {
-qDebug("<<<<<<<<<<<<<TREMOR!!!!!>>>>>>>>>>>>>>>>>>");
+odebug << "<<<<<<<<<<<<<TREMOR!!!!!>>>>>>>>>>>>>>>>>>" << oendl;
  d = new LibTremorPluginData;
   d->f = 0;
   d->vi = 0;
   d->vc = 0;
   d->bos = 0;
   d->csection = 0;
   d->finfo = "";
 }
 
 
 LibTremorPlugin::~LibTremorPlugin() {
   close();
   delete d;
 }
 
 
 bool LibTremorPlugin::isFileSupported( const QString& path ) {
     debugMsg( "LibTremorPlugin::isFileSupported" );
 
     // Mpeg file extensions
     //  "mp2","mp3","m1v","m2v","m2s","mpg","vob","mpeg",ac3"
     // Other media extensions
     //  "wav","mid","mod","s3m","ogg","avi","mov","sid"
 
     char *ext = strrchr( path.latin1(), '.' );
 
     // Test file extension
     if ( ext ) {
   if ( strncasecmp(ext, ".ogg", 4) == 0 )
       return TRUE;
     }
 
     return FALSE;
 }
 
 
 bool LibTremorPlugin::open( const QString& path ) {
   debugMsg( "LibTremorPlugin::open" );
 
   d->filename = (char*) path.latin1();
   d->f = fopen( d->filename, "r" );
   if (d->f == 0) {
-    qDebug("error opening %s", d->filename );
+    odebug << "error opening " << d->filename << "" << oendl;
     return FALSE;
   }
 
   if (ov_open(d->f, &d->vf, NULL, 0) < 0) {
-    qDebug("error opening %s", d->filename);
+    odebug << "error opening " << d->filename << "" << oendl;
     return FALSE;
   }
 
   d->vc = ov_comment(&d->vf, -1);
   d->vi = ov_info(&d->vf, -1);
   d->bos = false;
 
   QString comments[] = { "title", "artist", "album", "year", "tracknumber", "" };
   QString cdescr[] = { "Title", "Artist", "Album", "Year", "Track", "" };
 
 
   QMap<QString, QString> cmap;
   char** cptr = d->vc->user_comments;
 
   while (*cptr != 0) {
     QString s(*cptr);
     int n = s.find('=');
 
     if (n < 0) {
       continue;
     }
 
     QString key = s.left(n).lower();
     QString value = s.mid(n+1);
 
     cmap[key] = value;
     cptr++;
   }
 
   d->finfo = "";
   for(int i = 0; !comments[i].isEmpty(); i++) {
     QString v = cmap[comments[i].lower()];
 
     if (!v.isEmpty()) {
       if (!d->finfo.isEmpty()) {
         d->finfo += ", ";
       }
 
       d->finfo += cdescr[i] + ": " + v;
     }
   }
 
-  qDebug("finfo: " + d->finfo);
+  odebug << "finfo: " + d->finfo << oendl;
 
   return TRUE;
 }
 
 
 bool LibTremorPlugin::close() {
     debugMsg( "LibTremorPlugin::close" );
 
     int result = TRUE;
 
     if (fclose(d->f) == -1) {
-        qDebug("error closing file %s", d->filename);
+        odebug << "error closing file " << d->filename << "" << oendl;
   result = FALSE;
     }
 
     d->f = 0;
     d->finfo = "";
 
     return result;
 }
 
 
 bool LibTremorPlugin::isOpen() {
   debugMsg( "LibTremorPlugin::isOpen" );
   return ( d->f != 0 );
 }
 
 
 const QString &LibTremorPlugin::fileInfo() {
   return d->finfo;
 }
 
 int LibTremorPlugin::audioStreams() {
   debugMsg( "LibTremorPlugin::audioStreams" );
   return 1;
 }
 
 
 int LibTremorPlugin::audioChannels( int ) {
-  qDebug( "LibTremorPlugin::audioChannels: %i", d->vi->channels );
+  odebug << "LibTremorPlugin::audioChannels: " << d->vi->channels << "" << oendl;
   return d->vi->channels;
 }
 
 
 int LibTremorPlugin::audioFrequency( int ) {
-  qDebug( "LibTremorPlugin::audioFrequency: %ld", d->vi->rate );
+  odebug << "LibTremorPlugin::audioFrequency: " << d->vi->rate << "" << oendl;
   return d->vi->rate;
 }
 
 
 int LibTremorPlugin::audioSamples( int ) {
     debugMsg( "LibTremorPlugin::audioSamples" );
     return (int) ov_pcm_total(&d->vf,-1);
 }
 
 
 bool LibTremorPlugin::audioSetSample( long, int ) {
     debugMsg( "LibTremorPlugin::audioSetSample" );
     return FALSE;
 }
 
 
 long LibTremorPlugin::audioGetSample( int ) {
     debugMsg( "LibTremorPlugin::audioGetSample" );
     return 0;
 }
 
 
 bool LibTremorPlugin::audioReadSamples( short *output, int, long samples, long& samplesMade, int ) {
-//  qDebug( "<<<<<<<<<<<<LibTremorPlugin::audioReadStereoSamples %d", samples );
+//  odebug << "<<<<<<<<<<<<LibTremorPlugin::audioReadStereoSamples " << samples << "" << oendl;
 
   int old_section = d->csection;
 
   char* buf = (char*) output;
   int length = samples * 4;
 
   if ( samples == 0 )
     return false;
 
   while (length > 0) {
     if (d->bos) {
       d->vi = ov_info(&d->vf, -1);
       d->vc = ov_comment(&d->vf, -1);
     }
 
     int n = 4096;
     if (length < n) {
       n = length;
     }
 
     long ret = ov_read(&d->vf, buf, n, &d->csection);
-//    qDebug("%d", ret);
+//    odebug << "" << ret << "" << oendl;
     if (ret == 0) {
       break;
     } else if (ret < 0) {
       return true;
     }
 
     if (old_section != d->csection) {
       d->bos = true;
     }
 
     buf += ret;
     length -= ret;
 
   }
 
   samplesMade = samples;
 
   return true;
 }
 
 double LibTremorPlugin::getTime() {
     debugMsg( "LibTremorPlugin::getTime" );
     return 0.0;
 }
diff --git a/core/multimedia/opieplayer/wavplugin/wavplugin.cpp b/core/multimedia/opieplayer/wavplugin/wavplugin.cpp
index 4e82900..7f3a0a8 100644
--- a/core/multimedia/opieplayer/wavplugin/wavplugin.cpp
+++ b/core/multimedia/opieplayer/wavplugin/wavplugin.cpp
@@ -1,52 +1,60 @@
 /**********************************************************************
 ** 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.
 **
 **********************************************************************/
 // L.J.Potter added changes Fri 02-15-2002
 
+
+#include "wavplugin.h"
+
+/* OPIE */
+#include <opie2/odebug.h>
+
+/* QT */
+#include <qfile.h>
+
+/* STD */
 #include <stdio.h>
 #include <stdarg.h>
 #include <stdlib.h>
 #include <errno.h>
 #include <unistd.h>
-#include <qfile.h>
-#include "wavplugin.h"
 
 //#define debugMsg(a)     qDebug(a)
 #define debugMsg(a)
 
 
 struct RiffChunk {
     char id[4];
     Q_UINT32 size;
     char data[4];
 };
 
 
 struct ChunkData {
     Q_INT16 formatTag;
     Q_INT16 channels;
     Q_INT32 samplesPerSec;
     Q_INT32 avgBytesPerSec;
     Q_INT16 blockAlign;
     Q_INT16 wBitsPerSample;
 };
 
 
 const int sound_buffer_size = 512; // 4096; // you got to be kidding right?
 
@@ -55,56 +63,56 @@ class WavPluginData {
 public:
     QFile *input;
 
     int wavedata_remaining;
     ChunkData chunkdata;
     RiffChunk chunk;
     uchar data[sound_buffer_size+32]; // +32 to handle badly aligned input data
     int out,max;
     int samples_due;
     int samples;
 
     WavPluginData() {
   max = out = sound_buffer_size;
   wavedata_remaining = 0;
   samples_due = 0;
   samples = -1;
     }
 
     // expands out samples to the frequency of 44kHz //not any more
     bool add( short *output, long count, long& done, bool stereo )
     {
   done = 0;
 
   if ( input == 0 ) {
-      qDebug("no input");
+      odebug << "no input" << oendl;
       return FALSE;
   }
 
         while ( count ) {
             int l,r;
             if ( getSample(l, r) == FALSE ) {
-                qDebug("didn't get sample");
+                odebug << "didn't get sample" << oendl;
                 return FALSE;
             }
               samples_due += chunkdata.samplesPerSec;
               printf("samples due %d\r", samples_due);
               fflush(stdout);
              while ( count && (samples_due > chunkdata.samplesPerSec) ) {
                 *output++ = l;
                 if ( stereo )
                     *output++ = r;
                 samples_due -= chunkdata.samplesPerSec;
                 count--;
                 done++;
             }
         }
         return TRUE;
     }
 
     bool initialise() {
   if ( input == 0 )
       return FALSE;
 
   wavedata_remaining = -1;
 
   while ( wavedata_remaining == -1 ) {
@@ -114,59 +122,59 @@ public:
       if ( t != n ) {
     if ( t == -1 )
         return FALSE;
     return TRUE;
       }
       if ( qstrncmp(chunk.id,"data",4) == 0 ) {
     samples = wavedata_remaining = chunk.size;
       } else if ( qstrncmp(chunk.id,"RIFF",4) == 0 ) {
     char d[4];
     if ( input->readBlock(d,4) != 4 ) {
         return FALSE;
     }
     if ( qstrncmp(d,"WAVE",4) != 0 ) {
         // skip
         if ( chunk.size > 1000000000 || !input->at(input->at()+chunk.size-4) ) {
       return FALSE;
         }
     }
       } else if ( qstrncmp(chunk.id,"fmt ",4) == 0 ) {
     if ( input->readBlock((char*)&chunkdata,sizeof(chunkdata)) != sizeof(chunkdata) ) {
         return FALSE;
     }
 #define WAVE_FORMAT_PCM 1
     if ( chunkdata.formatTag != WAVE_FORMAT_PCM ) {
-        qDebug("WAV file: UNSUPPORTED FORMAT %d",chunkdata.formatTag);
+        odebug << "WAV file: UNSUPPORTED FORMAT " << chunkdata.formatTag << "" << oendl;
         return FALSE;
     }
       } else {
     // ignored chunk
     if ( chunk.size > 1000000000 || !input->at(input->at()+chunk.size) ) {
         return FALSE;
     }
       }
   } // while
-  qDebug("bits %d", chunkdata.wBitsPerSample);
+  odebug << "bits " << chunkdata.wBitsPerSample << "" << oendl;
   return TRUE;
     }
 
 
     // gets a sample from the file
     bool getSample(int& l, int& r)
     {
   l = r = 0;
 
   if ( input == 0 )
       return FALSE;
 
   if ( (wavedata_remaining < 0) || !max )
       return FALSE;
 
   if ( out >= max ) {
       max = input->readBlock( (char*)data, (uint)QMIN(sound_buffer_size,wavedata_remaining) );
 
       wavedata_remaining -= max;
 
       out = 0;
       if ( max <= 0 ) {
     max = 0;
     return TRUE;
@@ -186,157 +194,157 @@ public:
       } else {
     r = ((short*)data)[out/2];
     out += 2;
       }
   }
   return TRUE;
     } // getSample
 
 };
 
 
 WavPlugin::WavPlugin() {
     d = new WavPluginData;
     d->input = 0;
 }
 
 
 WavPlugin::~WavPlugin() {
     close();
     delete d;
 }
 
 
 bool WavPlugin::isFileSupported( const QString& path ) {
-//    qDebug( "WavPlugin::isFileSupported" );
+//    odebug << "WavPlugin::isFileSupported" << oendl;
 
     char *ext = strrchr( path.latin1(), '.' );
 
     // Test file extension
     if ( ext ) {
   if ( strncasecmp(ext, ".raw", 4) == 0 )
       return TRUE;
   if ( strncasecmp(ext, ".wav", 4) == 0 )
       return TRUE;
   if ( strncasecmp(ext, ".wave", 4) == 0 )
       return TRUE;
     }
 
     return FALSE;
 }
 
 
 bool WavPlugin::open( const QString& path ) {
-//    qDebug( "WavPlugin::open" );
+//    odebug << "WavPlugin::open" << oendl;
 
     d->max = d->out = sound_buffer_size;
     d->wavedata_remaining = 0;
     d->samples_due = 0;
 
     d->input = new QFile( path );
     if ( d->input->open(IO_ReadOnly) == FALSE ) {
-  qDebug("couldn't open file");
+  odebug << "couldn't open file" << oendl;
   delete d->input;
   d->input = 0;
   return FALSE;
     }
 
     d->initialise();
     qApp->processEvents();
 
     return TRUE;
 }
 
 
 bool WavPlugin::close() {
-//    qDebug( "WavPlugin::close" );
+//    odebug << "WavPlugin::close" << oendl;
 
     d->input->close();
     delete d->input;
     d->input = 0;
     return TRUE;
 }
 
 
 bool WavPlugin::isOpen() {
-//    qDebug( "WavPlugin::isOpen" );
+//    odebug << "WavPlugin::isOpen" << oendl;
     return ( d->input != 0 );
 }
 
 
 int WavPlugin::audioStreams() {
-//    qDebug( "WavPlugin::audioStreams" );
+//    odebug << "WavPlugin::audioStreams" << oendl;
     return 1;
 }
 
 
 int WavPlugin::audioChannels( int ) {
-//    qDebug( "WavPlugin::audioChannels" );
+//    odebug << "WavPlugin::audioChannels" << oendl;
     return d->chunkdata.channels;// 2; // ### Always scale audio to stereo samples
 }
 
 
 int WavPlugin::audioFrequency( int ) {
-//    qDebug( "WavPlugin::audioFrequency %d", d->chunkdata.samplesPerSec );
+//    odebug << "WavPlugin::audioFrequency " << d->chunkdata.samplesPerSec << "" << oendl;
     return  d->chunkdata.samplesPerSec; //44100; // ### Always scale to frequency of 44100
 }
 
 
 int WavPlugin::audioSamples( int ) {
-//    qDebug( "WavPlugin::audioSamples" );
+//    odebug << "WavPlugin::audioSamples" << oendl;
     return d->samples / d->chunkdata.channels/2; // ### Scaled samples will be made stereo,
         // Therefore if source is mono we will double the number of samples
 }
 
 
 bool WavPlugin::audioSetSample( long, int ) {
-//    qDebug( "WavPlugin::audioSetSample" );
+//    odebug << "WavPlugin::audioSetSample" << oendl;
     return FALSE;
 }
 
 
 long WavPlugin::audioGetSample( int ) {
-//    qDebug( "WavPlugin::audioGetSample" );
+//    odebug << "WavPlugin::audioGetSample" << oendl;
     return 0;
 }
 
 /*
 bool WavPlugin::audioReadSamples( short *, int, long, int ) {
     debugMsg( "WavPlugin::audioReadSamples" );
     return FALSE;
 }
 
 
 bool WavPlugin::audioReReadSamples( short *, int, long, int ) {
     debugMsg( "WavPlugin::audioReReadSamples" );
     return FALSE;
 }
 
 
 bool WavPlugin::audioReadMonoSamples( short *output, long samples, long& samplesMade, int ) {
     debugMsg( "WavPlugin::audioReadMonoSamples" );
     return !d->add( output, samples, samplesMade, FALSE );
 }
 
 
 bool WavPlugin::audioReadStereoSamples( short *output, long samples, long& samplesMade, int ) {
     debugMsg( "WavPlugin::audioReadStereoSamples" );
     return !d->add( output, samples, samplesMade, TRUE );
 }
 */
 
 bool WavPlugin::audioReadSamples( short *output, int channels, long samples, long& samplesMade, int ) {
-//    qDebug( "WavPlugin::audioReadSamples" );
+//    odebug << "WavPlugin::audioReadSamples" << oendl;
     return d->add( output, samples, samplesMade, channels != 1 );
 }
 
 double WavPlugin::getTime() {
-//    qDebug( "WavPlugin::getTime" ); //this is a stupid hack here!!
+//    odebug << "WavPlugin::getTime" << oendl;  //this is a stupid hack here!!
   return d->chunkdata.wBitsPerSample; /*0.0*/;
 }
 
 // int WavPlugin::audioBitsPerSample( int ) {
-// //    qDebug( "WavPlugin::audioFormat %d", d->chunkdata.wBitsPerSample );
+// //    odebug << "WavPlugin::audioFormat " << d->chunkdata.wBitsPerSample << "" << oendl;
 //     return d->chunkdata.wBitsPerSample; // 
 // }