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     uno::Reference< lang::XMultiServiceFactory > xFactory( ::comphelper::getProcessServiceFactory() );
  50 }
  51
  52 // -------------------------------------------------------------------------
  53
  54 uno::Reference< media::XPlayer > MediaWindowBaseImpl::createPlayer( const ::rtl::OUString& rURL )
  55 {
  56     uno::Reference< media::XPlayer > xPlayer;
  57     uno::Reference< lang::XMultiServiceFactory > xFactory( ::comphelper::getProcessServiceFactory() );
  58
  59     if( xFactory.is() )
  60     {
  61         static const char * aServiceManagers[] = {
  62             AVMEDIA_MANAGER_SERVICE_NAME,
  63 // a fallback path just for gstreamer which has
  64 // two significant versions deployed at once ...
  65 #ifdef AVMEDIA_MANAGER_SERVICE_NAME_OLD
  66             AVMEDIA_MANAGER_SERVICE_NAME_OLD
  67 #endif
  68         };
  69
  70         for( sal_uInt32 i = 0; !xPlayer.is() && i < SAL_N_ELEMENTS( aServiceManagers ); ++i )
  71         {
  72             const rtl::OUString aServiceName( aServiceManagers[ i ],
  73                                               strlen( aServiceManagers[ i ] ),
  74                                               RTL_TEXTENCODING_ASCII_US );
  75
  76             uno::Reference< ::com::sun::star::media::XManager > xManager;
  77
  78             try {
  79                 xManager = uno::Reference< ::com::sun::star::media::XManager >(
  80                         xFactory->createInstance( aServiceName ), uno::UNO_QUERY );
  81                 if( xManager.is() )
  82                     xPlayer = uno::Reference< media::XPlayer >( xManager->createPlayer( rURL ),
  83                                                                 uno::UNO_QUERY );
  84                 else
  85                     SAL_WARN( "avmedia",
  86                               "failed to create media player service " << aServiceName );
  87             } catch ( const uno::Exception &e ) {
  88                 SAL_WARN(
  89                          "avmedia",
  90                          "couldn't create media player " AVMEDIA_MANAGER_SERVICE_NAME
  91                          ", exception '" << e.Message << '\'');
  92             }
  93         }
  94     }
  95
  96     return xPlayer;
  97 }
  98
  99 void MediaWindowBaseImpl::setURL( const OUString& rURL,
 100         OUString const& rTempURL)
 101 {
 102     if( rURL != getURL() )
 103     {
 104         if( mxPlayer.is() )
 105             mxPlayer->stop();
 106
 107         if( mxPlayerWindow.is() )
 108         {
 109             mxPlayerWindow->setVisible( false );
 110             mxPlayerWindow.clear();
 111         }
 112
 113         mxPlayer.clear();
 114         mTempFileURL = OUString();
 115
 116         if (rTempURL.getLength())
 117         {
 118             maFileURL = rURL;
 119             mTempFileURL = rTempURL;
 120         }
 121         else
 122         {
 123             INetURLObject aURL( rURL );
 124
 125             if (aURL.GetProtocol() != INET_PROT_NOT_VALID)
 126                 maFileURL = aURL.GetMainURL(INetURLObject::DECODE_UNAMBIGUOUS);
 127             else
 128                 maFileURL = rURL;
 129         }
 130
 131         mxPlayer = createPlayer(
 132                 (mTempFileURL.getLength()) ? mTempFileURL : maFileURL );
 133         onURLChanged();
 134     }
 135 }
 136
 137 // ---------------------------------------------------------------------
 138
 139 void MediaWindowBaseImpl::onURLChanged()
 140 {
 141 }
 142
 143 // ---------------------------------------------------------------------
 144
 145 const OUString& MediaWindowBaseImpl::getURL() const
 146 {
 147     return maFileURL;
 148 }
 149
 150 // ---------------------------------------------------------------------
 151
 152 bool MediaWindowBaseImpl::isValid() const
 153 {
 154     return( getPlayer().is() );
 155 }
 156
 157 // ---------------------------------------------------------------------
 158
 159 void MediaWindowBaseImpl::stopPlayingInternal( bool bStop )
 160 {
 161     if( isPlaying() )
 162     {
 163         bStop ? mxPlayer->stop() : mxPlayer->start();
 164     }
 165 }
 166
 167 // ---------------------------------------------------------------------
 168
 169 MediaWindow* MediaWindowBaseImpl::getMediaWindow() const
 170 {
 171     return mpMediaWindow;
 172 }
 173
 174 // ---------------------------------------------------------------------
 175
 176 uno::Reference< media::XPlayer > MediaWindowBaseImpl::getPlayer() const
 177 {
 178     return mxPlayer;
 179 }
 180
 181 // ---------------------------------------------------------------------
 182
 183 uno::Reference< media::XPlayerWindow > MediaWindowBaseImpl::getPlayerWindow() const
 184 {
 185     return mxPlayerWindow;
 186 }
 187
 188 // ---------------------------------------------------------------------
 189
 190 void MediaWindowBaseImpl::setPlayerWindow( const uno::Reference< media::XPlayerWindow >& rxPlayerWindow )
 191 {
 192     mxPlayerWindow = rxPlayerWindow;
 193 }
 194
 195 // ---------------------------------------------------------------------
 196
 197 void MediaWindowBaseImpl::cleanUp()
 198 {
 199     uno::Reference< lang::XComponent > xComponent( mxPlayer, uno::UNO_QUERY );
 200     if( xComponent.is() ) // this stops the player
 201         xComponent->dispose();
 202
 203     mxPlayer.clear();
 204
 205     mpMediaWindow = NULL;
 206 }
 207
 208 // ---------------------------------------------------------------------
 209
 210 Size MediaWindowBaseImpl::getPreferredSize() const
 211 {
 212     Size aRet;
 213
 214     if( mxPlayer.is() )
 215     {
 216         awt::Size aPrefSize( mxPlayer->getPreferredPlayerWindowSize() );
 217
 218         aRet.Width() = aPrefSize.Width;
 219         aRet.Height() = aPrefSize.Height;
 220     }
 221
 222     return aRet;
 223 }
 224
 225 // ---------------------------------------------------------------------
 226
 227 bool MediaWindowBaseImpl::setZoom( ::com::sun::star::media::ZoomLevel eLevel )
 228 {
 229     return( mxPlayerWindow.is() ? mxPlayerWindow->setZoomLevel( eLevel ) : false );
 230 }
 231
 232 // -------------------------------------------------------------------------
 233
 234 ::com::sun::star::media::ZoomLevel MediaWindowBaseImpl::getZoom() const
 235 {
 236     return( mxPlayerWindow.is() ? mxPlayerWindow->getZoomLevel() : ::com::sun::star::media::ZoomLevel_NOT_AVAILABLE );
 237 }
 238
 239 // ---------------------------------------------------------------------
 240
 241 bool MediaWindowBaseImpl::start()
 242 {
 243     return( mxPlayer.is() ? ( mxPlayer->start(), true ) : false );
 244 }
 245
 246 // ---------------------------------------------------------------------
 247
 248 void MediaWindowBaseImpl::stop()
 249 {
 250     if( mxPlayer.is() )
 251         mxPlayer->stop();
 252 }
 253
 254 // ---------------------------------------------------------------------
 255
 256 bool MediaWindowBaseImpl::isPlaying() const
 257 {
 258     return( mxPlayer.is() && mxPlayer->isPlaying() );
 259 }
 260
 261 // ---------------------------------------------------------------------
 262
 263 double MediaWindowBaseImpl::getDuration() const
 264 {
 265     return( mxPlayer.is() ? mxPlayer->getDuration() : 0.0 );
 266 }
 267
 268 // ---------------------------------------------------------------------
 269
 270 void MediaWindowBaseImpl::setMediaTime( double fTime )
 271 {
 272     if( mxPlayer.is() )
 273         mxPlayer->setMediaTime( fTime );
 274 }
 275
 276 // ---------------------------------------------------------------------
 277
 278 double MediaWindowBaseImpl::getMediaTime() const
 279 {
 280     return( mxPlayer.is() ? mxPlayer->getMediaTime() : 0.0 );
 281 }
 282
 283 // ---------------------------------------------------------------------
 284
 285 double MediaWindowBaseImpl::getRate() const
 286 {
 287     return( mxPlayer.is() ? mxPlayer->getRate() : 0.0 );
 288 }
 289
 290 // ---------------------------------------------------------------------
 291
 292 void MediaWindowBaseImpl::setPlaybackLoop( bool bSet )
 293 {
 294     if( mxPlayer.is() )
 295         mxPlayer->setPlaybackLoop( bSet );
 296 }
 297
 298 // ---------------------------------------------------------------------
 299
 300 bool MediaWindowBaseImpl::isPlaybackLoop() const
 301 {
 302     return( mxPlayer.is() ? mxPlayer->isPlaybackLoop() : false );
 303 }
 304
 305 // ---------------------------------------------------------------------
 306
 307 void MediaWindowBaseImpl::setMute( bool bSet )
 308 {
 309     if( mxPlayer.is() )
 310         mxPlayer->setMute( bSet );
 311 }
 312
 313 // ---------------------------------------------------------------------
 314
 315 bool MediaWindowBaseImpl::isMute() const
 316 {
 317     return( mxPlayer.is() ? mxPlayer->isMute() : false );
 318 }
 319
 320 // ---------------------------------------------------------------------
 321
 322 void MediaWindowBaseImpl::setVolumeDB( sal_Int16 nVolumeDB )
 323 {
 324     if( mxPlayer.is() )
 325         mxPlayer->setVolumeDB( nVolumeDB );
 326 }
 327
 328 // ---------------------------------------------------------------------
 329
 330 sal_Int16 MediaWindowBaseImpl::getVolumeDB() const
 331 {
 332     return( mxPlayer.is() ? mxPlayer->getVolumeDB() : 0 );
 333 }
 334
 335 // -------------------------------------------------------------------------
 336
 337 void MediaWindowBaseImpl::updateMediaItem( MediaItem& rItem ) const
 338 {
 339     if( isPlaying() )
 340         rItem.setState( ( getRate() > 1.0 ) ? MEDIASTATE_PLAYFFW : MEDIASTATE_PLAY );
 341     else
 342         rItem.setState( ( 0.0 == getMediaTime() ) ? MEDIASTATE_STOP : MEDIASTATE_PAUSE );
 343
 344     rItem.setDuration( getDuration() );
 345     rItem.setTime( getMediaTime() );
 346     rItem.setLoop( isPlaybackLoop() );
 347     rItem.setMute( isMute() );
 348     rItem.setVolumeDB( getVolumeDB() );
 349     rItem.setZoom( getZoom() );
 350     rItem.setURL( getURL(), &mTempFileURL );
 351 }
 352
 353 // -------------------------------------------------------------------------
 354
 355 void MediaWindowBaseImpl::executeMediaItem( const MediaItem& rItem )
 356 {
 357     const sal_uInt32 nMaskSet = rItem.getMaskSet();
 358
 359     // set URL first
 360     if( nMaskSet & AVMEDIA_SETMASK_URL )
 361         setURL( rItem.getURL(), rItem.getTempURL() );
 362
 363     // set different states next
 364     if( nMaskSet & AVMEDIA_SETMASK_TIME )
 365         setMediaTime( ::std::min( rItem.getTime(), getDuration() ) );
 366
 367     if( nMaskSet & AVMEDIA_SETMASK_LOOP )
 368         setPlaybackLoop( rItem.isLoop() );
 369
 370     if( nMaskSet & AVMEDIA_SETMASK_MUTE )
 371         setMute( rItem.isMute() );
 372
 373     if( nMaskSet & AVMEDIA_SETMASK_VOLUMEDB )
 374         setVolumeDB( rItem.getVolumeDB() );
 375
 376     if( nMaskSet & AVMEDIA_SETMASK_ZOOM )
 377         setZoom( rItem.getZoom() );
 378
 379     // set play state at last
 380     if( nMaskSet & AVMEDIA_SETMASK_STATE )
 381     {
 382         switch( rItem.getState() )
 383         {
 384             case( MEDIASTATE_PLAY ):
 385             case( MEDIASTATE_PLAYFFW ):
 386             {
 387
 388                 if( !isPlaying() )
 389                     start();
 390             }
 391             break;
 392
 393             case( MEDIASTATE_PAUSE ):
 394             {
 395                 if( isPlaying() )
 396                     stop();
 397             }
 398             break;
 399
 400             case( MEDIASTATE_STOP ):
 401             {
 402                 if( isPlaying() )
 403                 {
 404                     setMediaTime( 0.0 );
 405                     stop();
 406                     setMediaTime( 0.0 );
 407                 }
 408             }
 409             break;
 410         }
 411     }
 412 }
 413
 414 } // namespace priv
 415 } // namespace avemdia
 416
 417 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */