avmedia/source/macavf/player.mm

   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 "player.hxx"
  21 #include "framegrabber.hxx"
  22 #include "window.hxx"
  23
  24 #include <cmath> // for log10()
  25
  26 using namespace ::com::sun::star;
  27
  28 @implementation MacAVObserverObject
  29
  30 - (void)observeValueForKeyPath:(NSString*)pKeyPath ofObject:(id)pObject change:(NSDictionary*)pChangeDict context:(void*)pContext
  31 {
  32     (void) pObject;
  33     NSString* pDictStr = [NSString stringWithFormat:@"%@", pChangeDict];
  34     OSL_TRACE( "MacAVObserver::onKeyChange k=\"%s\" c=%s", [pKeyPath UTF8String], [pDictStr UTF8String]);
  35     avmedia::macavf::MacAVObserverHandler* pHandler = static_cast<avmedia::macavf::MacAVObserverHandler*>(pContext);
  36     pHandler->handleObservation( pKeyPath );
  37 }
  38
  39 - (void)onNotification:(NSNotification*)pNotification
  40 {
  41     NSString* pNoteName = (NSString*)[pNotification name];
  42     OSL_TRACE( "MacAVObserver::onNotification key=\"%s\"", [pNoteName UTF8String]);
  43     HandlersForObject::iterator it = maHandlersForObject.find( [pNotification object]);
  44     if( it != maHandlersForObject.end() )
  45         (*it).second->handleObservation( pNoteName );
  46 }
  47
  48 - (void)setHandlerForObject:(NSObject*)pObject handler:(avmedia::macavf::MacAVObserverHandler*)pHandler
  49 {
  50     maHandlersForObject[ pObject] = pHandler;
  51 }
  52
  53 - (void)removeHandlerForObject:(NSObject*)pObject
  54 {
  55     maHandlersForObject.erase( pObject);
  56 }
  57
  58 @end
  59
  60
  61 namespace avmedia { namespace macavf {
  62
  63 MacAVObserverObject* MacAVObserverHandler::mpMacAVObserverObject = NULL;
  64
  65 MacAVObserverObject* MacAVObserverHandler::getObserver()
  66 {
  67     if( !mpMacAVObserverObject)
  68     {
  69         mpMacAVObserverObject = [MacAVObserverObject alloc];
  70         [mpMacAVObserverObject retain];
  71     }
  72     return mpMacAVObserverObject;
  73 }
  74
  75
  76 // ----------------
  77 // - Player -
  78 // ----------------
  79
  80 Player::Player( const uno::Reference< lang::XMultiServiceFactory >& rxMgr )
  81 :   mxMgr( rxMgr )
  82 ,   mpPlayer( NULL )
  83 ,   mfUnmutedVolume( 0 )
  84 ,   mfStopTime( DBL_MAX )
  85 ,   mbMuted( false )
  86 ,   mbLooping( false )
  87 {}
  88
  89 // ------------------------------------------------------------------------------
  90
  91 Player::~Player()
  92 {
  93     if( !mpPlayer )
  94         return;
  95     // remove the observers
  96     [mpPlayer removeObserver:getObserver() forKeyPath:@"currentItem.status"];
  97     AVPlayerItem* pOldPlayerItem = [mpPlayer currentItem];
  98     [[NSNotificationCenter defaultCenter] removeObserver:getObserver()
  99         name:AVPlayerItemDidPlayToEndTimeNotification
 100         object:pOldPlayerItem];
 101     [getObserver() removeHandlerForObject:pOldPlayerItem];
 102     // release the AVPlayer
 103     CFRelease( mpPlayer );
 104 }
 105
 106 // ------------------------------------------------------------------------------
 107
 108 bool Player::handleObservation( NSString* pKeyPath )
 109 {
 110     OSL_TRACE( "AVPlayer::handleObservation key=\"%s\"", [pKeyPath UTF8String]);
 111     if( [pKeyPath isEqualToString:AVPlayerItemDidPlayToEndTimeNotification])
 112     {
 113         OSL_TRACE( "AVPlayer replay=%d", mbLooping);
 114         if( mbLooping )
 115             setMediaTime( 0.0);
 116     }
 117     return true;
 118 }
 119
 120 // ------------------------------------------------------------------------------
 121
 122 bool Player::create( const ::rtl::OUString& rURL )
 123 {
 124     // get the media asset
 125     NSString* aNSStr = [NSString stringWithCharacters:rURL.getStr() length:rURL.getLength()];
 126     NSURL* aNSURL = [NSURL URLWithString: [aNSStr stringByAddingPercentEscapesUsingEncoding:NSUTF8StringEncoding]];
 127     // get the matching AVPlayerItem
 128     AVPlayerItem* pPlayerItem = [AVPlayerItem playerItemWithURL:aNSURL];
 129
 130     // create or update the AVPlayer with the new AVPlayerItem
 131     if( !mpPlayer )
 132     {
 133         mpPlayer = [AVPlayer playerWithPlayerItem:pPlayerItem];
 134         CFRetain( mpPlayer );
 135         [mpPlayer setActionAtItemEnd:AVPlayerActionAtItemEndNone];
 136     }
 137     else
 138     {
 139         // remove the obsoleted observers
 140         AVPlayerItem* pOldPlayerItem = [mpPlayer currentItem];
 141         [mpPlayer removeObserver:getObserver() forKeyPath:@"currentItem.status"];
 142         [getObserver() removeHandlerForObject:pOldPlayerItem];
 143         [[NSNotificationCenter defaultCenter] removeObserver:getObserver()
 144             name:AVPlayerItemDidPlayToEndTimeNotification
 145             object:pOldPlayerItem];
 146         // replace the playeritem
 147         [mpPlayer replaceCurrentItemWithPlayerItem:pPlayerItem];
 148     }
 149
 150     // observe the status of the current player item
 151     [mpPlayer addObserver:getObserver() forKeyPath:@"currentItem.status" options:0 context:this];
 152
 153     // observe playback-end needed for playback looping
 154     [[NSNotificationCenter defaultCenter] addObserver:getObserver()
 155         selector:@selector(onNotification:)
 156         name:AVPlayerItemDidPlayToEndTimeNotification
 157         object:pPlayerItem];
 158     [getObserver() setHandlerForObject:pPlayerItem handler:this];
 159
 160     return true;
 161 }
 162
 163 // ------------------------------------------------------------------------------
 164
 165 void SAL_CALL Player::start()
 166     throw (uno::RuntimeException)
 167 {
 168     if( !mpPlayer )
 169         return;
 170 #if 0
 171     const AVPlayerStatus eStatus = [mpPlayer status];
 172     OSL_TRACE ("Player::start status=%d", (int)eStatus);
 173     if( eStatus == AVPlayerStatusReadyToPlay)
 174 #endif
 175     {
 176         [mpPlayer play];
 177     }
 178     // else // TODO: delay until it becomes ready
 179 }
 180
 181 // ------------------------------------------------------------------------------
 182
 183 void SAL_CALL Player::stop()
 184     throw (uno::RuntimeException)
 185 {
 186     if( !mpPlayer )
 187         return;
 188     const bool bPlaying = isPlaying();
 189     OSL_TRACE ("Player::stop() playing=%d", bPlaying);
 190     if( bPlaying )
 191         [mpPlayer pause];
 192 }
 193
 194 // ------------------------------------------------------------------------------
 195
 196 sal_Bool SAL_CALL Player::isPlaying()
 197     throw (uno::RuntimeException)
 198 {
 199     if( !mpPlayer )
 200         return false;
 201     const float fRate = [mpPlayer rate];
 202     return (fRate != 0.0);
 203 }
 204
 205 // ------------------------------------------------------------------------------
 206
 207 double SAL_CALL Player::getDuration()
 208     throw (uno::RuntimeException)
 209 {
 210     // slideshow checks for non-zero duration, so cheat here
 211     double duration = 0.01;
 212
 213     if( mpPlayer )
 214     {
 215         AVPlayerItem* pItem = [mpPlayer currentItem];
 216         if( [pItem status] == AVPlayerItemStatusReadyToPlay )
 217             duration = CMTimeGetSeconds( [pItem duration] );
 218         else // fall back to AVAsset's best guess
 219             duration = CMTimeGetSeconds( [[pItem asset] duration] );
 220     }
 221
 222     return duration;
 223 }
 224
 225 // ------------------------------------------------------------------------------
 226
 227 void SAL_CALL Player::setMediaTime( double fTime )
 228     throw (uno::RuntimeException)
 229 {
 230     OSL_TRACE ("Player::setMediaTime( %.3fsec)", fTime);
 231     if( mpPlayer )
 232         [mpPlayer seekToTime: CMTimeMakeWithSeconds(fTime,1000) ];
 233 }
 234
 235 // ------------------------------------------------------------------------------
 236
 237 double SAL_CALL Player::getMediaTime()
 238     throw (uno::RuntimeException)
 239 {
 240     if( !mpPlayer )
 241         return 0.0;
 242
 243     const double position = CMTimeGetSeconds( [mpPlayer currentTime] );
 244     OSL_TRACE( "Player::getMediaTime() = %.3fsec", position);
 245     if( position >= mfStopTime )
 246         if( isPlaying() )
 247             stop();
 248
 249     return position;
 250 }
 251
 252 // ------------------------------------------------------------------------------
 253
 254 void SAL_CALL Player::setStopTime( double fTime )
 255     throw (uno::RuntimeException)
 256 {
 257     OSL_TRACE ("Player::setStopTime( %.3fsec)", fTime);
 258     mfStopTime = fTime;
 259 }
 260
 261 // ------------------------------------------------------------------------------
 262
 263 double SAL_CALL Player::getStopTime()
 264     throw (uno::RuntimeException)
 265 {
 266     return mfStopTime;
 267 }
 268
 269 // ------------------------------------------------------------------------------
 270
 271 void SAL_CALL Player::setPlaybackLoop( sal_Bool bSet )
 272     throw (uno::RuntimeException)
 273 {
 274     OSL_TRACE ("Player::setPlaybackLoop( %d)", bSet );
 275     mbLooping = bSet;
 276 }
 277
 278 // ------------------------------------------------------------------------------
 279
 280 sal_Bool SAL_CALL Player::isPlaybackLoop()
 281     throw (uno::RuntimeException)
 282 {
 283     const bool bRet = mbLooping;
 284     OSL_TRACE ("Player::isPlaybackLoop() = %d", bRet );
 285     return bRet;
 286 }
 287
 288 // ------------------------------------------------------------------------------
 289
 290 void SAL_CALL Player::setMute( sal_Bool bSet )
 291     throw (uno::RuntimeException)
 292 {
 293     OSL_TRACE( "Player::setMute(%d), was-muted: %d unmuted-volume: %.3f", bSet, mbMuted, mfUnmutedVolume );
 294
 295     if( !mpPlayer )
 296         return;
 297
 298     mbMuted = bSet;
 299     [mpPlayer setMuted:mbMuted];
 300 }
 301
 302 // ------------------------------------------------------------------------------
 303
 304 sal_Bool SAL_CALL Player::isMute()
 305     throw (uno::RuntimeException)
 306 {
 307     OSL_TRACE ("Player::isMuted() = %d", mbMuted);
 308     return mbMuted;
 309 }
 310
 311 // ------------------------------------------------------------------------------
 312
 313 void SAL_CALL Player::setVolumeDB( sal_Int16 nVolumeDB )
 314     throw (uno::RuntimeException)
 315 {
 316     // -40dB <-> AVPlayer volume 0.0
 317     //   0dB <-> AVPlayer volume 1.0
 318     mfUnmutedVolume = (nVolumeDB <= -40) ? 0.0 : pow( 10.0, nVolumeDB / 20.0 );
 319     OSL_TRACE( "Player::setVolume(%ddB), muted=%d, unmuted-volume: %.3f", nVolumeDB, mbMuted, mfUnmutedVolume );
 320
 321     // change volume
 322     if( !mbMuted && mpPlayer )
 323         [mpPlayer setVolume:mfUnmutedVolume];
 324 }
 325
 326 // ------------------------------------------------------------------------------
 327
 328 sal_Int16 SAL_CALL Player::getVolumeDB()
 329     throw (uno::RuntimeException)
 330 {
 331     if( !mpPlayer )
 332         return 0;
 333
 334     // get the actual volume
 335     const float fVolume = [mpPlayer volume];
 336
 337     // convert into Dezibel value
 338     // -40dB <-> AVPlayer volume 0.0
 339     //   0dB <-> AVPlayer volume 1.0
 340     const int nVolumeDB = (fVolume <= 0) ? -40 : lrint( 20.0*log10(fVolume));
 341
 342     return (sal_Int16)nVolumeDB;
 343 }
 344
 345 // ------------------------------------------------------------------------------
 346
 347 awt::Size SAL_CALL Player::getPreferredPlayerWindowSize()
 348     throw (uno::RuntimeException)
 349 {
 350     awt::Size aSize( 0, 0 ); // default size
 351
 352     AVAsset* pMovie = [[mpPlayer currentItem] asset];
 353     NSArray* pVideoTracks = [pMovie tracksWithMediaType:AVMediaTypeVideo];
 354     if ([pVideoTracks count] > 0)
 355     {
 356         AVAssetTrack* pFirstVideoTrack = (AVAssetTrack*) [pVideoTracks objectAtIndex:0];
 357         const CGSize aPrefSize = [pFirstVideoTrack naturalSize];
 358         aSize = awt::Size( aPrefSize.width, aPrefSize.height );
 359     }
 360
 361     return aSize;
 362 }
 363
 364 // ------------------------------------------------------------------------------
 365
 366 uno::Reference< ::media::XPlayerWindow > SAL_CALL Player::createPlayerWindow( const uno::Sequence< uno::Any >& aArguments )
 367     throw (uno::RuntimeException)
 368 {
 369     // get the preferred window size
 370     const awt::Size aSize( getPreferredPlayerWindowSize() );
 371     OSL_TRACE( "Player::createPlayerWindow %dx%d argsLength: %d", aSize.Width, aSize.Height, aArguments.getLength() );
 372
 373     // get the parent view
 374     sal_IntPtr nNSViewPtr = 0;
 375     aArguments[0] >>= nNSViewPtr;
 376     NSView* pParentView = reinterpret_cast<NSView*>(nNSViewPtr);
 377
 378     // check the window parameters
 379     uno::Reference< ::media::XPlayerWindow > xRet;
 380     if( (aSize.Width <= 0) || (aSize.Height <= 0) || (pParentView == NULL) )
 381          return xRet;
 382
 383     // create the window
 384     ::avmedia::macavf::Window* pWindow = new ::avmedia::macavf::Window( mxMgr, *this, pParentView );
 385     xRet = pWindow;
 386     return xRet;
 387 }
 388
 389 // ------------------------------------------------------------------------------
 390
 391 uno::Reference< media::XFrameGrabber > SAL_CALL Player::createFrameGrabber()
 392     throw (uno::RuntimeException)
 393 {
 394     uno::Reference< media::XFrameGrabber > xRet;
 395     OSL_TRACE ("Player::createFrameGrabber");
 396
 397     FrameGrabber* pGrabber = new FrameGrabber( mxMgr );
 398     AVAsset* pMovie = [[mpPlayer currentItem] asset];
 399     if( pGrabber->create( pMovie ) )
 400         xRet = pGrabber;
 401
 402     return xRet;
 403 }
 404
 405 // ------------------------------------------------------------------------------
 406
 407 ::rtl::OUString SAL_CALL Player::getImplementationName(  )
 408     throw (uno::RuntimeException)
 409 {
 410     return ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( AVMEDIA_MACAVF_PLAYER_IMPLEMENTATIONNAME ) );
 411 }
 412
 413 // ------------------------------------------------------------------------------
 414
 415 sal_Bool SAL_CALL Player::supportsService( const ::rtl::OUString& ServiceName )
 416     throw (uno::RuntimeException)
 417 {
 418     return ServiceName.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM ( AVMEDIA_MACAVF_PLAYER_SERVICENAME ) );
 419 }
 420
 421 // ------------------------------------------------------------------------------
 422
 423 uno::Sequence< ::rtl::OUString > SAL_CALL Player::getSupportedServiceNames(  )
 424     throw (uno::RuntimeException)
 425 {
 426     uno::Sequence< ::rtl::OUString > aRet(1);
 427     aRet[0] = ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM ( AVMEDIA_MACAVF_PLAYER_SERVICENAME ) );
 428
 429     return aRet;
 430 }
 431
 432 } // namespace macavf
 433 } // namespace avmedia
 434
 435 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */