fixed when playing stream, slider moved and stopped stream when it reached the end

5 files changed, 28 insertions, 20 deletions

diff --git a/core/multimedia/opieplayer/audiowidget.cpp b/core/multimedia/opieplayer/audiowidget.cpp
index 3212001..20345b7 100644
--- a/core/multimedia/opieplayer/audiowidget.cpp
+++ b/core/multimedia/opieplayer/audiowidget.cpp
@@ -1,225 +1,228 @@
 /**********************************************************************
 ** 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/resource.h>
 
 #include <qwidget.h>
 #include <qpixmap.h>
 #include <qbutton.h>
 #include <qpainter.h>
 #include <qframe.h>
 
 #include "audiowidget.h"
 #include "mediaplayerstate.h"
 
 extern MediaPlayerState *mediaPlayerState;
 
 
 static const int xo = -2; // movable x offset
 static const int yo = 22; // movable y offset
 
 
 struct MediaButton {
     int  xPos, yPos;
     int  color;
     bool isToggle, isBig, isHeld, isDown;
 };
 
 
 // Layout information for the audioButtons (and if it is a toggle button or not)
 MediaButton audioButtons[] = {
     { 3*30-15+xo, 3*30-13+yo, 0,  TRUE,  TRUE, FALSE, FALSE }, // play
     {    1*30+xo,    5*30+yo, 2, FALSE, FALSE, FALSE, FALSE }, // stop
     {    5*30+xo,    5*30+yo, 2,  TRUE, FALSE, FALSE, FALSE }, // pause
     {  6*30-5+xo,    3*30+yo, 1, FALSE, FALSE, FALSE, FALSE }, // next
     {  0*30+5+xo,    3*30+yo, 1, FALSE, FALSE, FALSE, FALSE }, // previous
     {    3*30+xo,  0*30+5+yo, 3, FALSE, FALSE, FALSE, FALSE }, // volume up
     {    3*30+xo,  6*30-5+yo, 3, FALSE, FALSE, FALSE, FALSE }, // volume down
     {    5*30+xo,    1*30+yo, 0,  TRUE, FALSE, FALSE, FALSE }, // repeat/loop
     {    1*30+xo,    1*30+yo, 0, FALSE, FALSE, FALSE, FALSE }  // playlist
 };
 
 
 static const int numButtons = (sizeof(audioButtons)/sizeof(MediaButton));
 
 
 AudioWidget::AudioWidget(QWidget* parent, const char* name, WFlags f) :
     QWidget( parent, name, f )
 {
 //    QPEApplication::grabKeyboard();
     setCaption( tr("OpiePlayer") );
     setBackgroundPixmap( Resource::loadPixmap( "opieplayer/metalFinish" ) );
     pixmaps[0] = new QPixmap( Resource::loadPixmap( "opieplayer/mediaButtonsAll" ) );
     pixmaps[1] = new QPixmap( Resource::loadPixmap( "opieplayer/mediaButtonsBig" ) );
     pixmaps[2] = new QPixmap( Resource::loadPixmap( "opieplayer/mediaControls" ) );
     pixmaps[3] = new QPixmap( Resource::loadPixmap( "opieplayer/animatedButton" ) );
 
     songInfo = new Ticker( this );
     songInfo->setFocusPolicy( QWidget::NoFocus );
     songInfo->setGeometry( QRect( 7, 3, 220, 20 ) );
 
     slider = new QSlider( Qt::Horizontal, this );
     slider->setFixedWidth( 220 );
     slider->setFixedHeight( 20 );
     slider->setMinValue( 0 );
     slider->setMaxValue( 1 );
     slider->setBackgroundPixmap( Resource::loadPixmap( "opieplayer/metalFinish" ) );
     slider->setFocusPolicy( QWidget::NoFocus );
     slider->setGeometry( QRect( 7, 262, 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( loopingToggled(bool) ), this, SLOT( setLooping(bool) ) );
     connect( mediaPlayerState, SIGNAL( pausedToggled(bool) ),  this, SLOT( setPaused(bool) ) );
     connect( mediaPlayerState, SIGNAL( playingToggled(bool) ), this, SLOT( setPlaying(bool) ) );
 
+    if( !mediaPlayerState->isStreaming) { // this stops the slider from being moved, thus
+          // does not stop stream when it reaches the end
+    connect( mediaPlayerState, SIGNAL( positionChanged(long) ),this, SLOT( setPosition(long) ) );
+    connect( mediaPlayerState, SIGNAL( positionUpdated(long) ),this, SLOT( setPosition(long) ) );
+    }
     // Intialise state
     setLength( mediaPlayerState->length() );
     setPosition( mediaPlayerState->position() );
     setLooping( mediaPlayerState->fullscreen() );
     setPaused( mediaPlayerState->paused() );
     setPlaying( mediaPlayerState->playing() );
 
 }
 
 
 AudioWidget::~AudioWidget() {
     for ( int i = 0; i < 4; i++ )
   delete pixmaps[i];
 }
 
 
 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 ) {
     updateSlider( i, mediaPlayerState->length() );
 }
 
 
 void AudioWidget::setLength( long max ) {
     updateSlider( mediaPlayerState->position(), max );
 }
 
 
 void AudioWidget::setView( char view ) {
     if ( view == 'a' ) {
   startTimer( 150 );
   showMaximized();
     } else {
   killTimers();
   hide();
     }
 }
 
 
 void AudioWidget::updateSlider( long i, long max ) {
     if ( max == 0 )
   return;
     // Will flicker too much if we don't do this
     // Scale to something reasonable
     int width = slider->width();
     int val = int((double)i * width / max);
     if ( !audioSliderBeingMoved ) {
   if ( slider->value() != val )
       slider->setValue( val );
   if ( slider->maxValue() != width )
       slider->setMaxValue( width );
     }
 }
 
 
 void AudioWidget::setToggleButton( int i, bool down ) {
     if ( down != audioButtons[i].isDown )
   toggleButton( i );
 }
 
 
 void AudioWidget::toggleButton( int i ) {
     audioButtons[i].isDown = !audioButtons[i].isDown;
     QPainter p(this);
     paintButton ( &p, i );
 }
 
 
 void AudioWidget::paintButton( QPainter *p, int i ) {
     int x = audioButtons[i].xPos;
     int y = audioButtons[i].yPos;
     int offset = 22 + 14 * audioButtons[i].isBig + audioButtons[i].isDown;
     int buttonSize = 64 + audioButtons[i].isBig * (90 - 64);
     p->drawPixmap( x, y, *pixmaps[audioButtons[i].isBig], buttonSize * (audioButtons[i].isDown + 2 * audioButtons[i].color), 0, buttonSize, buttonSize );
     p->drawPixmap( x + offset, y + offset, *pixmaps[2], 18 * i, 0, 18, 18 );
 }
 
 
 void AudioWidget::timerEvent( QTimerEvent * ) {
     static int frame = 0;
     if ( !mediaPlayerState->paused() && audioButtons[ AudioPlay ].isDown ) {
   frame = frame >= 7 ? 0 : frame + 1;
   int x = audioButtons[AudioPlay].xPos;
   int y = audioButtons[AudioPlay].yPos;
   QPainter p( this );
   // Optimize to only draw the little bit of the changing images which is different
   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 );
     }
 }
 
 
 void AudioWidget::mouseMoveEvent( QMouseEvent *event ) {
     for ( int i = 0; i < numButtons; i++ ) {
         int size = audioButtons[i].isBig;
         int x = audioButtons[i].xPos;
         int y = audioButtons[i].yPos;
         if ( event->state() == QMouseEvent::LeftButton ) {
               // The test to see if the mouse click is inside the circular button or not
               // (compared with the radius squared to avoid a square-root of our distance)
             int radius = 32 + 13 * size;
             QPoint center = QPoint( x + radius, y + radius );
             QPoint dXY = center - event->pos();
             int dist = dXY.x() * dXY.x() + dXY.y() * dXY.y();
             bool isOnButton = dist <= (radius * radius);
 //      QRect r( x, y, 64 + 22*size, 64 + 22*size );
 //      bool isOnButton = r.contains( event->pos() ); // Rectangular Button code
             if ( isOnButton && !audioButtons[i].isHeld ) {
                 audioButtons[i].isHeld = TRUE;
                 toggleButton(i);
                 qDebug("button toggled1  %d",i);
                 switch (i) {
                   case AudioVolumeUp:   emit moreClicked(); return;
diff --git a/core/multimedia/opieplayer/audiowidget.h b/core/multimedia/opieplayer/audiowidget.h
index d1d72b6..4ffd167 100644
--- a/core/multimedia/opieplayer/audiowidget.h
+++ b/core/multimedia/opieplayer/audiowidget.h
@@ -1,145 +1,145 @@
 /**********************************************************************
 ** 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.
 **
 **********************************************************************/
 
 #ifndef AUDIO_WIDGET_H
 #define AUDIO_WIDGET_H
 
 #include <qwidget.h>
 #include <qpainter.h>
 #include <qdrawutil.h>
 #include <qpixmap.h>
 #include <qstring.h>
 #include <qslider.h>
 #include <qframe.h>
 
 
 class QPixmap;
 
 
 enum AudioButtons {
     AudioPlay,
     AudioStop,
     AudioPause,
     AudioNext,
     AudioPrevious,
     AudioVolumeUp,
     AudioVolumeDown,
     AudioLoop,
     AudioPlayList
 };
 
 
 #define USE_DBLBUF
 
 
 class Ticker : public QFrame {
     Q_OBJECT
 public:
     Ticker( QWidget* parent=0 ) : QFrame( parent ) {
-  setFrameStyle( WinPanel | Sunken );
-  setText( "No Song" );
+        setFrameStyle( WinPanel | Sunken );
+        setText( "No Song" );
     }
     ~Ticker() { }
     void setText( const QString& text ) {
-  pos = 0; // reset it everytime the text is changed
-  scrollText = text;
-  pixelLen = fontMetrics().width( scrollText );
-  killTimers();
-  if ( pixelLen > width() )
-      startTimer( 50 );
-  update();
+        pos = 0; // reset it everytime the text is changed
+        scrollText = text;
+        pixelLen = fontMetrics().width( scrollText );
+        killTimers();
+        if ( pixelLen > width() )
+            startTimer( 50 );
+        update();
     }
 protected:
     void timerEvent( QTimerEvent * ) {
   pos = ( pos + 1 > pixelLen ) ? 0 : pos + 1;
 #ifndef USE_DBLBUF
   scroll( -1, 0, contentsRect() );
 #else
   repaint( FALSE );
 #endif
     }
     void drawContents( QPainter *p ) {
 #ifndef USE_DBLBUF
   for ( int i = 0; i - pos < width() && (i < 1 || pixelLen > width()); i += pixelLen )
       p->drawText( i - pos, 0, INT_MAX, height(), AlignVCenter, scrollText );
 #else
   // Double buffering code.
   // Looks like qvfb makes it look like it flickers but I don't think it really is
   QPixmap pm( width(), height() );
   pm.fill( colorGroup().base() );
   QPainter pmp( &pm );
   for ( int i = 0; i - pos < width() && (i < 1 || pixelLen > width()); i += pixelLen )
       pmp.drawText( i - pos, 0, INT_MAX, height(), AlignVCenter, scrollText );
   p->drawPixmap( 0, 0, pm );
 #endif
     }
 private:
     QString scrollText;
     int pos, pixelLen;
 };
 
 
 class AudioWidget : public QWidget {
     Q_OBJECT
 public:
     AudioWidget( QWidget* parent=0, const char* name=0, WFlags f=0 );
     ~AudioWidget();
     void setTickerText( const QString &text ) { songInfo->setText( text ); }
-
+    bool isStreaming;
 public slots:
     void updateSlider( long, long );
     void sliderPressed( );
     void sliderReleased( );
     void setPaused( bool b)  { setToggleButton( AudioPause, b ); }
     void setLooping( bool b) { setToggleButton( AudioLoop, b ); }
     void setPlaying( bool b) { setToggleButton( AudioPlay, b ); }
     void setPosition( long );
     void setLength( long );
     void setView( char );
 
 signals:
     void moreClicked();
     void lessClicked();
     void moreReleased();
     void lessReleased();
     void sliderMoved(long);
 
 protected:
     void paintEvent( QPaintEvent *pe );
     void showEvent( QShowEvent *se );
     void mouseMoveEvent( QMouseEvent *event );
     void mousePressEvent( QMouseEvent *event );
     void mouseReleaseEvent( QMouseEvent *event );
     void timerEvent( QTimerEvent *event );
     void closeEvent( QCloseEvent *event );
     void keyReleaseEvent( QKeyEvent *e);
 
 private:
     void toggleButton( int );
     void setToggleButton( int, bool );
     void paintButton( QPainter *p, int i );
     QPixmap *pixmaps[4];
     Ticker *songInfo;
     QSlider *slider;
 };
 
 
 #endif // AUDIO_WIDGET_H
 
diff --git a/core/multimedia/opieplayer/loopcontrol.cpp b/core/multimedia/opieplayer/loopcontrol.cpp
index b9f96de..45c2d3e 100644
--- a/core/multimedia/opieplayer/loopcontrol.cpp
+++ b/core/multimedia/opieplayer/loopcontrol.cpp
@@ -111,364 +111,368 @@ LoopControl::LoopControl( QObject *parent, const char *name )
   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." );
   pthread_attr_destroy(&audio_attr);
   pthread_attr_init(&audio_attr);
     }
 #endif
 //qDebug("create audio thread");
     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();
 
     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();
 }
 
 
 void LoopControl::startVideo() {
 
     if ( moreVideo ) {
 
         if ( mediaPlayerState->curDecoder() ) {
 
       if ( hasAudioChannel && !isMuted ) {
 
     current_frame = long( playtime.elapsed() * framerate / 1000 );
 
     if ( prev_frame != -1 && current_frame <= prev_frame )
         return;
 
       } else {
     // Don't skip
     current_frame++;
       }
 
       if ( prev_frame == -1 || current_frame > prev_frame ) {
     if ( current_frame > prev_frame + 1 ) {
         mediaPlayerState->curDecoder()->videoSetFrame( current_frame, stream );
     }
     moreVideo = videoUI->playVideo();
     prev_frame = current_frame;
       }
 
   } else {
 
       moreVideo = FALSE;
       killTimer( videoId );
 
   }
 
     }
 }
 
 
 void LoopControl::startAudio() {
     
 //qDebug("start audio");
     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);
 
       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;
 
-//         if ( ( sampleWaitTime > 2000 ) && ( sampleWaitTime < 20000 ) ) {
-//       usleep( (long)((double)sampleWaitTime * 1000000.0 / freq) );
+// this causes drop outs not sure why its even here
+//          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 );
+//       //mediaPlayerState->curDecoder()->audioSetSample( sampleWeShouldBeAt, stream );
+//       currentSample = sampleWeShouldBeAt;
 //         }
-//       else if ( sampleWaitTime <= -5000 ) {
-//      qDebug("need to catch up by: %li (%i,%li)", -sampleWaitTime, currentSample, sampleWeShouldBeAt );
-//      //mediaPlayerState->curDecoder()->audioSetSample( sampleWeShouldBeAt, stream );
-//      currentSample = sampleWeShouldBeAt;
-//        }
 
       audioDevice->write( audioBuffer, samplesRead * 2 * channels );
       audioSampleCounter = currentSample + samplesRead - 1;
 
       moreAudio = readOk && (audioSampleCounter <= total_audio_samples);
 
   } else {
 
       moreAudio = FALSE;
 
   }
 
     }
 
     audioMutex->unlock();
 }
 
 
 void LoopControl::killTimers() {
 
     audioMutex->lock();
 
     if ( hasVideoChannel ) 
   killTimer( videoId );
     killTimer( sliderId );
     threadOkToGo = FALSE;
 
     audioMutex->unlock();
 }
 
 
 void LoopControl::startTimers() {
 
     audioMutex->lock();
 
     moreVideo = FALSE;
     moreAudio = FALSE;
 
     if ( hasVideoChannel ) {
   moreVideo = TRUE;
   int mSecsBetweenFrames = (int)(100 / framerate); // 10% of the real value
   videoId = startTimer( mSecsBetweenFrames );
     }
 
     if ( hasAudioChannel ) {
   moreAudio = TRUE;
   threadOkToGo = TRUE;
     }
 
     sliderId = startTimer( 300 ); // update slider every 1/3 second
 
     audioMutex->unlock();
 }
 
 
 void LoopControl::setPaused( bool pause ) {
 
     if ( !mediaPlayerState->curDecoder() || !mediaPlayerState->curDecoder()->isOpen() )
   return;
 
     if ( pause ) {
   killTimers();
     } else {
   // Force an update of the position
   mediaPlayerState->setPosition( mediaPlayerState->position() + 1 );
   mediaPlayerState->setPosition( mediaPlayerState->position() - 1 );
   // Just like we never stopped
   startTimers();
     }
 }
 
 
 void LoopControl::stop( bool willPlayAgainShortly ) {
 
 #if defined(Q_WS_QWS) && !defined(QT_NO_COP)
     if ( !willPlayAgainShortly && disabledSuspendScreenSaver ) {
   disabledSuspendScreenSaver = FALSE; 
   // Re-enable the suspend mode
   QCopEnvelope("QPE/System", "setScreenSaverMode(int)" ) << QPEApplication::Enable;
     }
 #endif
 
     if ( mediaPlayerState->curDecoder() && mediaPlayerState->curDecoder()->isOpen() ) {
 
   killTimers();
 
   audioMutex->lock();
 
   mediaPlayerState->curDecoder()->close();
 
   if ( audioDevice ) {
       delete audioDevice;
       delete audioBuffer;
       audioDevice = 0;
       audioBuffer = 0;
   }
 
   audioMutex->unlock();
 
     }
 }
 
 
 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() );
    
     // ### 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;
 
   channels = mediaPlayerState->curDecoder()->audioChannels( astream );
   qDebug( "LC- channels = %d", channels );
   
   if ( !total_audio_samples )
       total_audio_samples = mediaPlayerState->curDecoder()->audioSamples( astream );
 
 //  total_audio_samples += 1000;
 
   mediaPlayerState->setLength( total_audio_samples );
   
   freq = mediaPlayerState->curDecoder()->audioFrequency( astream );
   qDebug( "LC- frequency = %d", freq );
 
   audioSampleCounter = 0;
    int bits_per_sample;
    if ( mediaPlayerState->curDecoder()->pluginName() == QString("LibWavPlugin") ) {
        bits_per_sample =(int) mediaPlayerState->curDecoder()->getTime();
        qDebug("using stupid hack");
    } 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;
 
+    if( fileName.left(7) == "http://")
+        mediaPlayerState->isStreaming = TRUE;
+
     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");
 #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 );
       // Resume playing audio
       moreAudio = TRUE;
   }
     }
 }
 
 
diff --git a/core/multimedia/opieplayer/mediaplayerstate.h b/core/multimedia/opieplayer/mediaplayerstate.h
index ad273f1..06c5556 100644
--- a/core/multimedia/opieplayer/mediaplayerstate.h
+++ b/core/multimedia/opieplayer/mediaplayerstate.h
@@ -1,119 +1,119 @@
 /**********************************************************************
 ** 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.
 **
 **********************************************************************/
 #ifndef MEDIA_PLAYER_STATE_H
 #define MEDIA_PLAYER_STATE_H
 
 
 #include <qobject.h>
 
 
 class MediaPlayerDecoder;
 class Config;
 
 
 class MediaPlayerState : public QObject {
 Q_OBJECT
 public:
     MediaPlayerState( QObject *parent, const char *name );
     ~MediaPlayerState();
 
-    
+    bool isStreaming;    
     bool fullscreen()    { return isFullscreen; }
     bool scaled()    { return isScaled; }
     bool looping()     { return isLooping; }
     bool shuffled()    { return isShuffled; }
     bool playlist()    { return usePlaylist; }
     bool paused()    { return isPaused; }
     bool playing()     { return isPlaying; }
     long position()    { return curPosition; }
     long length()    { return curLength; }
     char view()      { return curView; }
 
     MediaPlayerDecoder *newDecoder( const QString& file );
     MediaPlayerDecoder *curDecoder();
     MediaPlayerDecoder *libMpeg3Decoder(); // ### Yucky hack needed to use libmpeg3plugin to get the
              // number of audio samples if we are using the libmad plugin
 public slots:
     void setFullscreen( bool b ) { if ( isFullscreen == b ) return; isFullscreen = b; emit fullscreenToggled(b); }
     void setScaled( bool b )     { if ( isScaled     == b ) return; isScaled = b;     emit scaledToggled(b); }
     void setLooping( bool b )    { if ( isLooping    == b ) return; isLooping = b;    emit loopingToggled(b); }
     void setShuffled( bool b )   { if ( isShuffled   == b ) return; isShuffled = b;   emit shuffledToggled(b); }
     void setPlaylist( bool b )   { if ( usePlaylist  == b ) return; usePlaylist = b;  emit playlistToggled(b); }
     void setPaused( bool b )   { if ( isPaused     == b ) return; isPaused = b;     emit pausedToggled(b); }
     void setPlaying( bool b )  { if ( isPlaying    == b ) return; isPlaying = b;    emit playingToggled(b); }
     void setPosition( long p )   { if ( curPosition  == p ) return; curPosition = p;  emit positionChanged(p); }
     void updatePosition( long p ){ if ( curPosition  == p ) return; curPosition = p;  emit positionUpdated(p); }
     void setLength( long l )   { if ( curLength    == l ) return; curLength = l;    emit lengthChanged(l); }
     void setView( char v )   { if ( curView      == v ) return; curView = v;      emit viewChanged(v); }
 
     void setPrev()     { emit prev(); }
     void setNext()     { emit next(); }
     void setList()     { setPlaying( FALSE ); setView('l'); }
     void setVideo()    { setView('v'); }
     void setAudio()    { setView('a'); }
 
     void toggleFullscreen()  { setFullscreen( !isFullscreen ); }
     void toggleScaled()    { setScaled( !isScaled); }
     void toggleLooping()   { setLooping( !isLooping); }
     void toggleShuffled()  { setShuffled( !isShuffled); }
     void togglePlaylist()  { setPlaylist( !usePlaylist); }
     void togglePaused()    { setPaused( !isPaused); }
     void togglePlaying()   { setPlaying( !isPlaying); }
 
 signals:
     void fullscreenToggled( bool );
     void scaledToggled( bool );
     void loopingToggled( bool );
     void shuffledToggled( bool );
     void playlistToggled( bool );
     void pausedToggled( bool );
     void playingToggled( bool );
     void positionChanged( long ); // When the slider is moved
     void positionUpdated( long ); // When the media file progresses
     void lengthChanged( long );
     void viewChanged( char );
 
     void prev();
     void next();
 
 private:
     bool isFullscreen;
     bool isScaled;
     bool isLooping;
     bool isShuffled;
     bool usePlaylist;
     bool isPaused;
     bool isPlaying;
     long curPosition;
     long curLength;
     char curView;
 
     MediaPlayerDecoder *decoder;
     MediaPlayerDecoder *libmpeg3decoder;
 //    MediaPlayerDecoder *libwavdecoder;
 
     void loadPlugins();
     void readConfig( Config& cfg );
     void writeConfig( Config& cfg ) const;
 };
 
 
 #endif // MEDIA_PLAYER_STATE_H
 
diff --git a/core/multimedia/opieplayer/playlistwidget.cpp b/core/multimedia/opieplayer/playlistwidget.cpp
index 250645c..ff156f8 100644
--- a/core/multimedia/opieplayer/playlistwidget.cpp
+++ b/core/multimedia/opieplayer/playlistwidget.cpp
@@ -868,154 +868,155 @@ void PlayListWidget::playlistViewPressed( int mouse, QListViewItem *item, const
 {
  switch (mouse) {
       case 1:
           break;
       case 2:{
     QPopupMenu  m;
     m.insertItem( tr( "Play Selected" ), this, SLOT( playSelected() ));
     m.insertItem( tr( "Remove" ), this, SLOT( removeSelected() ));
 //      m.insertSeparator();
     m.exec( QCursor::pos() );
       }
     break;
     };
 
 }
 
 void PlayListWidget::listDelete() {
       Config cfg( "OpiePlayer" );
       cfg.setGroup("PlayList");
       QString currentPlaylist = cfg.readEntry("CurrentPlaylist","");
       QString file;
       int noOfFiles = cfg.readNumEntry("NumberOfFiles", 0 );
     switch ( tabWidget->currentPageIndex()) {
       case 0:
           break;
       case 1:
       {
           file = audioView->selectedItem()->text(0);
 //           Global::findDocuments(&files, "audio/*");
 //           AppLnkSet appFiles;
           QListIterator<DocLnk> dit( files.children() );
           for ( ; dit.current(); ++dit ) {
               if( dit.current()->name() == file) {
 //                  qDebug(file);
                   LnkProperties prop( dit.current() );
 //  connect(&prop, SIGNAL(select(const AppLnk *)), this, SLOT(externalSelected(const AppLnk *)));
                   prop.showMaximized();
                   prop.exec();
               }
           }
      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::populateAudioView() {
 //     if(files)
 //         files.~DocLnkSet();
     StorageInfo storageInfo;
     const QList<FileSystem> &fs = storageInfo.fileSystems();
 
     Global::findDocuments(&files, "audio/*");
     QListIterator<DocLnk> dit( files.children() );
     QListIterator<FileSystem> it ( fs );
     audioView->clear();
     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() ) {
             newItem= /*(void)*/ new QListViewItem( audioView, dit.current()->name(), QString::number( QFile( dit.current()->file()).size() ), storage);
             newItem->setPixmap(0, Resource::loadPixmap( "opieplayer/musicfile" ));
         }
     }
 }
 
 void PlayListWidget::populateVideoView() {
     StorageInfo storageInfo;
     const QList<FileSystem> &fs = storageInfo.fileSystems();
 
     Global::findDocuments(&vFiles, "video/*");
     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);
             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->LineEdit1->text();
 
 //         InputDialog *fileDlg2;
 //         fileDlg2 = new InputDialog(this,tr("Name"),TRUE, 0);
 //         fileDlg2->exec();
 //         if( fileDlg2->result() == 1 ) {
 //             name = fileDlg2->LineEdit1->text();
 //         }
 //http://205.188.234.129:8030
+// http://66.28.68.70:8000
         qDebug(filename);
         DocLnk lnk;
 //     if(filename.left(7) == "http://")
 //         name=  filename.right(filename.length()-filename.find("http://")-7);
 //     else name = filename;
 //     qDebug("name is "+name);
 //     lnk.setComment(filename);
         lnk.setName(filename); //sets file name
         if(filename.right(1) != "/" && filename.right(3) != "mp3" && filename.right(3) != "MP3")
             filename += "/";
         lnk.setFile(filename); //sets File property
 
         lnk.setType("audio/x-mpegurl");
         lnk.setExec("opieplayer");
         lnk.setIcon("opieplayer/MPEGPlayer");
 
         if(!lnk.writeLink()) 
             qDebug("Writing doclink did not work");
         d->selectedFiles->addToSelection(  lnk);
 //     if(fileDlg2)
 //         delete fileDlg2;
     }
 
     if(fileDlg)
         delete fileDlg;
 }