You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
300 lines
6.7 KiB
300 lines
6.7 KiB
/* This file is part of the KDE project
|
|
Copyright (C) 2004 Matthias Kretz <kretz@kde.org>
|
|
|
|
This library is free software; you can redistribute it and/or
|
|
modify it under the terms of the GNU Library General Public
|
|
License version 2 as published by the Free Software Foundation.
|
|
|
|
This library is distributed in the hope that it will be useful,
|
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
|
Library General Public License for more details.
|
|
|
|
You should have received a copy of the GNU Library General Public License
|
|
along with this library; see the file COPYING.LIB. If not, write to
|
|
the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
|
|
Boston, MA 02110-1301, USA.
|
|
|
|
*/
|
|
|
|
#include "statetest.h"
|
|
|
|
#include <kdemm/factory.h>
|
|
#include <kdemm/channel.h>
|
|
#include <kdemm/player.h>
|
|
|
|
#include <kaboutdata.h>
|
|
#include <kcmdlineargs.h>
|
|
#include <kapplication.h>
|
|
#include <kdebug.h>
|
|
#include <kurl.h>
|
|
#include <cstdlib>
|
|
|
|
using namespace KDE::Multimedia;
|
|
|
|
kdbgstream& operator<<( kdbgstream & stream, const Player::State state )
|
|
{
|
|
switch( state )
|
|
{
|
|
case Player::NoMedia:
|
|
stream << "NoMedia";
|
|
break;
|
|
case Player::Loading:
|
|
stream << "Loading";
|
|
break;
|
|
case Player::Stopped:
|
|
stream << "Stopped";
|
|
break;
|
|
case Player::Playing:
|
|
stream << "Playing";
|
|
break;
|
|
case Player::Buffering:
|
|
stream << "Buffering";
|
|
break;
|
|
case Player::Paused:
|
|
stream << "Paused";
|
|
break;
|
|
}
|
|
|
|
return stream;
|
|
}
|
|
|
|
void StateTester::run( const KURL & url )
|
|
{
|
|
/*
|
|
check for correct states:
|
|
|
|
- after construction:
|
|
NoMedia
|
|
|
|
- load()
|
|
NoMedia -> NoMedia, (only? for remote files: Loading -> NoMedia, Stopped ), Stopped
|
|
|
|
- play()
|
|
Stopped, Paused -> Playing (except: Stopped -> Stopped)
|
|
|
|
- when playing:
|
|
Playing -> Buffering -> Playing
|
|
|
|
- pause()
|
|
Playing -> Paused
|
|
|
|
- stop()
|
|
Playing, Paused -> Stopped
|
|
*/
|
|
|
|
f = Factory::self();
|
|
kdDebug() << "using backend: " << f->backendName() <<
|
|
"\n Comment: " << f->backendComment() <<
|
|
"\n Version: " << f->backendVersion() << endl;
|
|
|
|
c = f->createChannel( "teststates" );
|
|
p = f->createPlayer();
|
|
p->setOutputChannel( c );
|
|
connect( p, TQT_SIGNAL( stateChanged( KDE::Multimedia::Player::State, KDE::Multimedia::Player::State ) ),
|
|
TQT_SLOT( stateChanged( KDE::Multimedia::Player::State, KDE::Multimedia::Player::State ) ) );
|
|
connect( p, TQT_SIGNAL( finished() ), kapp, TQT_SLOT( quit() ) );
|
|
|
|
if( p->state() != Player::NoMedia )
|
|
kdDebug() << p->state() << " should be NoMedia" << endl;
|
|
|
|
kdDebug() << "loading " << url << endl;
|
|
|
|
if( ! p->load( url ) )
|
|
kdDebug() << "load failed" << endl;
|
|
if( p->state() == Player::Loading )
|
|
kdDebug() << "wait until Player finished Loading" << endl;
|
|
else if( p->state() == Player::Stopped )
|
|
testplaying();
|
|
else if( p->state() == Player::NoMedia )
|
|
{
|
|
kdDebug() << "could not load media. exiting." << endl;
|
|
exit( 0 );
|
|
}
|
|
}
|
|
|
|
void StateTester::stateChanged( Player::State newstate, Player::State oldstate )
|
|
{
|
|
kdDebug() << "stateChanged( new = " << newstate << ", old = " << oldstate << " )" << endl;
|
|
switch( oldstate )
|
|
{
|
|
case Player::NoMedia:
|
|
switch( newstate )
|
|
{
|
|
case Player::NoMedia:
|
|
case Player::Loading:
|
|
case Player::Stopped:
|
|
return;
|
|
default:
|
|
break;
|
|
}
|
|
case Player::Loading:
|
|
switch( newstate )
|
|
{
|
|
case Player::NoMedia:
|
|
return;
|
|
case Player::Stopped:
|
|
testplaying();
|
|
return;
|
|
default:
|
|
break;
|
|
}
|
|
case Player::Stopped:
|
|
switch( newstate )
|
|
{
|
|
case Player::Playing:
|
|
case Player::Stopped:
|
|
return;
|
|
default:
|
|
break;
|
|
}
|
|
case Player::Playing:
|
|
switch( newstate )
|
|
{
|
|
case Player::Buffering:
|
|
//testbuffering();
|
|
case Player::Paused:
|
|
case Player::Stopped:
|
|
return;
|
|
default:
|
|
break;
|
|
}
|
|
case Player::Buffering:
|
|
switch( newstate )
|
|
{
|
|
case Player::Playing:
|
|
case Player::Stopped:
|
|
case Player::Paused:
|
|
return;
|
|
default:
|
|
break;
|
|
}
|
|
case Player::Paused:
|
|
switch( newstate )
|
|
{
|
|
case Player::Playing:
|
|
case Player::Stopped:
|
|
case Player::Buffering:
|
|
return;
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
|
|
wrongStateChange();
|
|
}
|
|
|
|
void StateTester::testplaying()
|
|
{
|
|
if( ! p->play() )
|
|
kdDebug() << "play failed" << endl;
|
|
if( p->state() == Player::Stopped )
|
|
{
|
|
kdDebug() << "could not play media. exiting." << endl;
|
|
exit( 0 );
|
|
}
|
|
else if( p->state() == Player::Playing )
|
|
{
|
|
if( ! p->pause() )
|
|
{
|
|
kdDebug() << "pause failed" << endl;
|
|
if( p->state() != Player::Playing )
|
|
wrongStateChange();
|
|
}
|
|
else
|
|
{
|
|
if( p->state() != Player::Paused )
|
|
wrongStateChange();
|
|
if( ! p->play() )
|
|
{
|
|
kdDebug() << "play failed" << endl;
|
|
if( p->state() != Player::Paused )
|
|
wrongStateChange();
|
|
kdError() << "what now? play shouldn't fail here" << endl;
|
|
exit( 1 );
|
|
}
|
|
if( p->state() != Player::Playing )
|
|
wrongStateChange();
|
|
}
|
|
// it's playing now
|
|
if( ! p->stop() )
|
|
{
|
|
kdDebug() << "stop failed" << endl;
|
|
if( p->state() != Player::Playing )
|
|
wrongStateChange();
|
|
}
|
|
else
|
|
{
|
|
if( p->state() != Player::Stopped )
|
|
wrongStateChange();
|
|
if( ! p->play() )
|
|
{
|
|
kdDebug() << "play failed" << endl;
|
|
if( p->state() != Player::Stopped )
|
|
wrongStateChange();
|
|
kdError() << "play shouldn't fail after it worked before. exiting." << endl;
|
|
exit( 1 );
|
|
}
|
|
}
|
|
// it's playing again
|
|
if( ! p->pause() )
|
|
{
|
|
kdDebug() << "pause failed. exiting." << endl;
|
|
exit( 1 );
|
|
}
|
|
if( p->state() != Player::Paused )
|
|
wrongStateChange();
|
|
if( ! p->stop() )
|
|
{
|
|
kdDebug() << "stop failed" << endl;
|
|
if( p->state() != Player::Paused )
|
|
wrongStateChange();
|
|
exit( 1 );
|
|
}
|
|
if( p->state() != Player::Stopped )
|
|
wrongStateChange();
|
|
// do further checking, calling load again
|
|
kdDebug() << "success! playing the last 1/5 of the file now and quit on the finished signal" << endl;
|
|
p->play();
|
|
p->seek( p->totalTime() * 4 / 5 );
|
|
}
|
|
}
|
|
|
|
void StateTester::wrongStateChange()
|
|
{
|
|
kdError() << "wrong state change in backend!" << endl;
|
|
exit( 1 );
|
|
}
|
|
|
|
static const KCmdLineOptions options[] =
|
|
{
|
|
{ "+url", I18N_NOOP( "media file to play" ), 0 },
|
|
KCmdLineLastOption // End of options.
|
|
};
|
|
|
|
int main( int argc, char ** argv )
|
|
{
|
|
KAboutData about( "kdemmtest", "KDE Multimedia Test",
|
|
"0.1", "Testprogram",
|
|
KAboutData::License_LGPL, 0 );
|
|
about.addAuthor( "Matthias Kretz", 0, "kretz@kde.org" );
|
|
KCmdLineArgs::init( argc, argv, &about );
|
|
KCmdLineArgs::addCmdLineOptions( options );
|
|
KApplication app; // we need it for KTrader
|
|
|
|
StateTester tester;
|
|
if( KCmdLineArgs::parsedArgs()->count() > 0 )
|
|
tester.run( KCmdLineArgs::parsedArgs()->url( 0 ) );
|
|
else
|
|
{
|
|
KCmdLineArgs::usage();
|
|
exit( 2 );
|
|
}
|
|
|
|
return app.exec();
|
|
}
|
|
|
|
#include "statetest.moc"
|
|
|
|
// vim: sw=4 ts=4 noet
|