avmedia/source/viewer/mediawindowbase_impl.cxx

   1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
   2 /*
   3  * This file is part of the LibreOffice project.
   4  *
   5  * This Source Code Form is subject to the terms of the Mozilla Public
   6  * License, v. 2.0. If a copy of the MPL was not distributed with this
   7  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
   8  *
   9  * This file incorporates work covered by the following license notice:
  10  *
  11  *   Licensed to the Apache Software Foundation (ASF) under one or more
  12  *   contributor license agreements. See the NOTICE file distributed
  13  *   with this work for additional information regarding copyright
  14  *   ownership. The ASF licenses this file to you under the Apache
  15  *   License, Version 2.0 (the "License"); you may not use this file
  16  *   except in compliance with the License. You may obtain a copy of
  17  *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
  18  */
  19
  20 #include "mediawindowbase_impl.hxx"
  21 #include <avmedia/mediaitem.hxx>
  22 #include "mediamisc.hxx"
  23 #include "mediawindow.hrc"
  24 #include <rtl/ustring.hxx>
  25 #include <tools/urlobj.hxx>
  26 #include <comphelper/processfactory.hxx>
  27 #include <com/sun/star/lang/XMultiServiceFactory.hpp>
  28 #include <com/sun/star/lang/XComponent.hpp>
  29 #include <com/sun/star/media/XManager.hpp>
  30
  31 using namespace ::com::sun::star;
  32
  33 namespace avmedia { namespace priv {
  34
  35 // -----------------------
  36 // - MediaWindowBaseImpl -
  37 // -----------------------
  38
  39
  40 MediaWindowBaseImpl::MediaWindowBaseImpl( MediaWindow* pMediaWindow )
  41     : mpMediaWindow( pMediaWindow )
  42 {
  43 }
  44
  45 // ---------------------------------------------------------------------
  46
  47 MediaWindowBaseImpl::~MediaWindowBaseImpl()
  48 {
  49 }
  50
  51 // -------------------------------------------------------------------------
  52
  53 uno::Reference< media::XPlayer > MediaWindowBaseImpl::createPlayer( const OUString& rURL )
  54 {
  55     uno::Reference< media::XPlayer > xPlayer;
  56     uno::Reference< uno::XComponentContext > xContext( ::comphelper::getProcessComponentContext() );
  57
  58     static const char * aServiceManagers[] = {
  59         AVMEDIA_MANAGER_SERVICE_NAME,
  60 // a fallback path just for gstreamer which has
  61 // two significant versions deployed at once ...
  62 #ifdef AVMEDIA_MANAGER_SERVICE_NAME_OLD
  63         AVMEDIA_MANAGER_SERVICE_NAME_OLD
  64 #endif
  65     };
  66
  67     for( sal_uInt32 i = 0; !xPlayer.is() && i < SAL_N_ELEMENTS( aServiceManagers ); ++i )
  68     {
  69         const OUString aServiceName( aServiceManagers[ i ],
  70                                           strlen( aServiceManagers[ i ] ),
  71                                           RTL_TEXTENCODING_ASCII_US );
  72
  73         try {
  74             uno::Reference< media::XManager > xManager (
  75                     xContext->getServiceManager()->createInstanceWithContext(aServiceName, xContext),
  76                     uno::UNO_QUERY );
  77             if( xManager.is() )
  78                 xPlayer = uno::Reference< media::XPlayer >( xManager->createPlayer( rURL ),
  79                                                             uno::UNO_QUERY );
  80             else
  81                 SAL_WARN( "avmedia",
  82                           "failed to create media player service " << aServiceName );
  83         } catch ( const uno::Exception &e ) {
  84             SAL_WARN( "avmedia",
  85                       "couldn't create media player " AVMEDIA_MANAGER_SERVICE_NAME
  86                       ", exception '" << e.Message << '\'');
  87         }
  88     }
  89
  90     return xPlayer;
  91 }
  92
  93 void MediaWindowBaseImpl::setURL( const OUString& rURL,
  94         OUString const& rTempURL)
  95 {
  96     if( rURL != getURL() )
  97     {
  98         if( mxPlayer.is() )
  99             mxPlayer->stop();
 100
 101         if( mxPlayerWindow.is() )
 102         {
 103             mxPlayerWindow->setVisible( false );
 104             mxPlayerWindow.clear();
 105         }
 106
 107         mxPlayer.clear();
 108         mTempFileURL = OUString();
 109
 110         if (!rTempURL.isEmpty())
 111         {
 112             maFileURL = rURL;
 113             mTempFileURL = rTempURL;
 114         }
 115         else
 116         {
 117             INetURLObject aURL( rURL );
 118
 119             if (aURL.GetProtocol() != INET_PROT_NOT_VALID)
 120                 maFileURL = aURL.GetMainURL(INetURLObject::DECODE_UNAMBIGUOUS);
 121             else
 122                 maFileURL = rURL;
 123         }
 124
 125         mxPlayer = createPlayer(
 126                 (!mTempFileURL.isEmpty()) ? mTempFileURL : maFileURL );
 127         onURLChanged();
 128     }
 129 }
 130
 131 // ---------------------------------------------------------------------
 132
 133 void MediaWindowBaseImpl::onURLChanged()
 134 {
 135 }
 136
 137 // ---------------------------------------------------------------------
 138
 139 const OUString& MediaWindowBaseImpl::getURL() const
 140 {
 141     return maFileURL;
 142 }
 143
 144 // ---------------------------------------------------------------------
 145
 146 bool MediaWindowBaseImpl::isValid() const
 147 {
 148     return( getPlayer().is() );
 149 }
 150
 151 // ---------------------------------------------------------------------
 152
 153 void MediaWindowBaseImpl::stopPlayingInternal( bool bStop )
 154 {
 155     if( isPlaying() )
 156     {
 157         bStop ? mxPlayer->stop() : mxPlayer->start();
 158     }
 159 }
 160
 161 // ---------------------------------------------------------------------
 162
 163 MediaWindow* MediaWindowBaseImpl::getMediaWindow() const
 164 {
 165     return mpMediaWindow;
 166 }
 167
 168 // ---------------------------------------------------------------------
 169
 170 uno::Reference< media::XPlayer > MediaWindowBaseImpl::getPlayer() const
 171 {
 172     return mxPlayer;
 173 }
 174
 175 // ---------------------------------------------------------------------
 176
 177 uno::Reference< media::XPlayerWindow > MediaWindowBaseImpl::getPlayerWindow() const
 178 {
 179     return mxPlayerWindow;
 180 }
 181
 182 // ---------------------------------------------------------------------
 183
 184 void MediaWindowBaseImpl::setPlayerWindow( const uno::Reference< media::XPlayerWindow >& rxPlayerWindow )
 185 {
 186     mxPlayerWindow = rxPlayerWindow;
 187 }
 188
 189 // ---------------------------------------------------------------------
 190
 191 void MediaWindowBaseImpl::cleanUp()
 192 {
 193     uno::Reference< lang::XComponent > xComponent( mxPlayer, uno::UNO_QUERY );
 194     if( xComponent.is() ) // this stops the player
 195         xComponent->dispose();
 196
 197     mxPlayer.clear();
 198
 199     mpMediaWindow = NULL;
 200 }
 201
 202 // ---------------------------------------------------------------------
 203
 204 Size MediaWindowBaseImpl::getPreferredSize() const
 205 {
 206     Size aRet;
 207
 208     if( mxPlayer.is() )
 209     {
 210         awt::Size aPrefSize( mxPlayer->getPreferredPlayerWindowSize() );
 211
 212         aRet.Width() = aPrefSize.Width;
 213         aRet.Height() = aPrefSize.Height;
 214     }
 215
 216     return aRet;
 217 }
 218
 219 // ---------------------------------------------------------------------
 220
 221 bool MediaWindowBaseImpl::setZoom( ::com::sun::star::media::ZoomLevel eLevel )
 222 {
 223     return( mxPlayerWindow.is() ? mxPlayerWindow->setZoomLevel( eLevel ) : false );
 224 }
 225
 226 // -------------------------------------------------------------------------
 227
 228 ::com::sun::star::media::ZoomLevel MediaWindowBaseImpl::getZoom() const
 229 {
 230     return( mxPlayerWindow.is() ? mxPlayerWindow->getZoomLevel() : media::ZoomLevel_NOT_AVAILABLE );
 231 }
 232
 233 // ---------------------------------------------------------------------
 234
 235 bool MediaWindowBaseImpl::start()
 236 {
 237     return( mxPlayer.is() ? ( mxPlayer->start(), true ) : false );
 238 }
 239
 240 // ---------------------------------------------------------------------
 241
 242 void MediaWindowBaseImpl::stop()
 243 {
 244     if( mxPlayer.is() )
 245         mxPlayer->stop();
 246 }
 247
 248 // ---------------------------------------------------------------------
 249
 250 bool MediaWindowBaseImpl::isPlaying() const
 251 {
 252     return( mxPlayer.is() && mxPlayer->isPlaying() );
 253 }
 254
 255 // ---------------------------------------------------------------------
 256
 257 double MediaWindowBaseImpl::getDuration() const
 258 {
 259     return( mxPlayer.is() ? mxPlayer->getDuration() : 0.0 );
 260 }
 261
 262 // ---------------------------------------------------------------------
 263
 264 void MediaWindowBaseImpl::setMediaTime( double fTime )
 265 {
 266     if( mxPlayer.is() )
 267         mxPlayer->setMediaTime( fTime );
 268 }
 269
 270 // ---------------------------------------------------------------------
 271
 272 double MediaWindowBaseImpl::getMediaTime() const
 273 {
 274     return( mxPlayer.is() ? mxPlayer->getMediaTime() : 0.0 );
 275 }
 276
 277 // ---------------------------------------------------------------------
 278
 279 double MediaWindowBaseImpl::getRate() const
 280 {
 281     return( mxPlayer.is() ? mxPlayer->getRate() : 0.0 );
 282 }
 283
 284 // ---------------------------------------------------------------------
 285
 286 void MediaWindowBaseImpl::setPlaybackLoop( bool bSet )
 287 {
 288     if( mxPlayer.is() )
 289         mxPlayer->setPlaybackLoop( bSet );
 290 }
 291
 292 // ---------------------------------------------------------------------
 293
 294 bool MediaWindowBaseImpl::isPlaybackLoop() const
 295 {
 296     return( mxPlayer.is() ? mxPlayer->isPlaybackLoop() : false );
 297 }
 298
 299 // ---------------------------------------------------------------------
 300
 301 void MediaWindowBaseImpl::setMute( bool bSet )
 302 {
 303     if( mxPlayer.is() )
 304         mxPlayer->setMute( bSet );
 305 }
 306
 307 // ---------------------------------------------------------------------
 308
 309 bool MediaWindowBaseImpl::isMute() const
 310 {
 311     return( mxPlayer.is() ? mxPlayer->isMute() : false );
 312 }
 313
 314 // ---------------------------------------------------------------------
 315
 316 void MediaWindowBaseImpl::setVolumeDB( sal_Int16 nVolumeDB )
 317 {
 318     if( mxPlayer.is() )
 319         mxPlayer->setVolumeDB( nVolumeDB );
 320 }
 321
 322 // ---------------------------------------------------------------------
 323
 324 sal_Int16 MediaWindowBaseImpl::getVolumeDB() const
 325 {
 326     return( mxPlayer.is() ? mxPlayer->getVolumeDB() : 0 );
 327 }
 328
 329 // -------------------------------------------------------------------------
 330
 331 void MediaWindowBaseImpl::updateMediaItem( MediaItem& rItem ) const
 332 {
 333     if( isPlaying() )
 334         rItem.setState( ( getRate() > 1.0 ) ? MEDIASTATE_PLAYFFW : MEDIASTATE_PLAY );
 335     else
 336         rItem.setState( ( 0.0 == getMediaTime() ) ? MEDIASTATE_STOP : MEDIASTATE_PAUSE );
 337
 338     rItem.setDuration( getDuration() );
 339     rItem.setTime( getMediaTime() );
 340     rItem.setLoop( isPlaybackLoop() );
 341     rItem.setMute( isMute() );
 342     rItem.setVolumeDB( getVolumeDB() );
 343     rItem.setZoom( getZoom() );
 344     rItem.setURL( getURL(), &mTempFileURL );
 345 }
 346
 347 // -------------------------------------------------------------------------
 348
 349 void MediaWindowBaseImpl::executeMediaItem( const MediaItem& rItem )
 350 {
 351     const sal_uInt32 nMaskSet = rItem.getMaskSet();
 352
 353     // set URL first
 354     if( nMaskSet & AVMEDIA_SETMASK_URL )
 355         setURL( rItem.getURL(), rItem.getTempURL() );
 356
 357     // set different states next
 358     if( nMaskSet & AVMEDIA_SETMASK_TIME )
 359         setMediaTime( ::std::min( rItem.getTime(), getDuration() ) );
 360
 361     if( nMaskSet & AVMEDIA_SETMASK_LOOP )
 362         setPlaybackLoop( rItem.isLoop() );
 363
 364     if( nMaskSet & AVMEDIA_SETMASK_MUTE )
 365         setMute( rItem.isMute() );
 366
 367     if( nMaskSet & AVMEDIA_SETMASK_VOLUMEDB )
 368         setVolumeDB( rItem.getVolumeDB() );
 369
 370     if( nMaskSet & AVMEDIA_SETMASK_ZOOM )
 371         setZoom( rItem.getZoom() );
 372
 373     // set play state at last
 374     if( nMaskSet & AVMEDIA_SETMASK_STATE )
 375     {
 376         switch( rItem.getState() )
 377         {
 378             case( MEDIASTATE_PLAY ):
 379             case( MEDIASTATE_PLAYFFW ):
 380             {
 381
 382                 if( !isPlaying() )
 383                     start();
 384             }
 385             break;
 386
 387             case( MEDIASTATE_PAUSE ):
 388             {
 389                 if( isPlaying() )
 390                     stop();
 391             }
 392             break;
 393
 394             case( MEDIASTATE_STOP ):
 395             {
 396                 if( isPlaying() )
 397                 {
 398                     setMediaTime( 0.0 );
 399                     stop();
 400                     setMediaTime( 0.0 );
 401                 }
 402             }
 403             break;
 404         }
 405     }
 406 }
 407
 408 } // namespace priv
 409 } // namespace avemdia
 410
 411 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */