avmedia/source/quicktime/player.cxx

   1 /*************************************************************************
   2  *
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * Copyright 2008 by Sun Microsystems, Inc.
   6  *
   7  * OpenOffice.org - a multi-platform office productivity suite
   8  *
   9  * $RCSfile: player.cxx,v $
  10  * $Revision: 1.5 $
  11  *
  12  * This file is part of OpenOffice.org.
  13  *
  14  * OpenOffice.org is free software: you can redistribute it and/or modify
  15  * it under the terms of the GNU Lesser General Public License version 3
  16  * only, as published by the Free Software Foundation.
  17  *
  18  * OpenOffice.org is distributed in the hope that it will be useful,
  19  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  20  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  21  * GNU Lesser General Public License version 3 for more details
  22  * (a copy is included in the LICENSE file that accompanied this code).
  23  *
  24  * You should have received a copy of the GNU Lesser General Public License
  25  * version 3 along with OpenOffice.org.  If not, see
  26  * <http://www.openoffice.org/license.html>
  27  * for a copy of the LGPLv3 License.
  28  *
  29  ************************************************************************/
  30
  31 #include <math.h>
  32
  33 #include "player.hxx"
  34 #include "framegrabber.hxx"
  35 #include "window.hxx"
  36
  37 // dbg_dump for development
  38 #if OSL_DEBUG_LEVEL > 1
  39 #include <rtl/strbuf.hxx>
  40 #include <rtl/ustring.hxx>
  41
  42 const sal_Char *dbg_dump(const rtl::OString &rStr)
  43 {
  44     static rtl::OStringBuffer aStr;
  45
  46     aStr = rtl::OStringBuffer(rStr);
  47     aStr.append(static_cast<char>(0));
  48     return aStr.getStr();
  49 }
  50
  51 const sal_Char *dbg_dump(const rtl::OUString &rStr)
  52 {
  53     return dbg_dump(rtl::OUStringToOString(rStr, RTL_TEXTENCODING_UTF8));
  54 }
  55
  56 const sal_Char *dbg_dump(rtl_String *pStr)
  57 {
  58     return dbg_dump(rtl::OString(pStr));
  59 }
  60
  61 const sal_Char *dbg_dump(rtl_uString *pStr)
  62 {
  63     return dbg_dump(rtl::OUString(pStr));
  64 }
  65
  66 #endif
  67
  68 using namespace ::com::sun::star;
  69
  70 namespace avmedia { namespace quicktime {
  71
  72 // ----------------
  73 // - Player -
  74 // ----------------
  75
  76 Player::Player( const uno::Reference< lang::XMultiServiceFactory >& rxMgr ) :
  77     mxMgr( rxMgr ),
  78     mpMovie( nil ),
  79     /* GST
  80     mbFakeVideo (sal_False ),
  81     */
  82     mnUnmutedVolume( 0 ),
  83     mnStopTime( DBL_MAX ),  //max double
  84     mbMuted( false ),
  85     mbLooping( false ),
  86     mbInitialized( false ),
  87     mnWindowID( 0 ),
  88     mnDuration( 0 ),
  89     mnWidth( 0 ),
  90     mnHeight( 0 ),
  91     mnVersion( 0 ),
  92     maSizeCondition( osl_createCondition() )
  93 {
  94     OSErr result;
  95
  96     NSApplicationLoad();
  97     NSAutoreleasePool* pool     = [[NSAutoreleasePool alloc] init];
  98     // check the version of QuickTime installed
  99     result = Gestalt(gestaltQuickTime,&mnVersion);
 100     if ((result == noErr) && (mnVersion >= QT701))
 101     {
 102       // we have version 7.01 or later, initialize
 103       mpMovie = [QTMovie movie];
 104       [mpMovie retain];
 105       mbInitialized = true;
 106     }
 107     [pool release];
 108 }
 109
 110 // ------------------------------------------------------------------------------
 111
 112 Player::~Player()
 113 {
 114     if( mbInitialized )
 115     {
 116         if( mpMovie )
 117         {
 118             [mpMovie release];
 119             mpMovie = nil;
 120         }
 121
 122     }
 123 }
 124
 125
 126 // ------------------------------------------------------------------------------
 127
 128 bool Player::create( const ::rtl::OUString& rURL )
 129 {
 130     bool    bRet = false;
 131     NSAutoreleasePool* pool     = [[NSAutoreleasePool alloc] init];
 132     NSString* aNSStr = [[[NSString alloc] initWithCharacters: rURL.getStr() length: rURL.getLength()]stringByAddingPercentEscapesUsingEncoding:NSUTF8StringEncoding] ;
 133 //      NSString * aNSStringEscaped = [aNSStr stringByAddingPercentEscapesUsingEncoding:NSUTF8StringEncoding];
 134     NSURL* aURL = [NSURL URLWithString:aNSStr ];
 135
 136     // create the Movie
 137
 138     if( mbInitialized )
 139     {
 140
 141         mpMovie = [mpMovie initWithURL:aURL error:nil];
 142         if(mpMovie)
 143         {
 144             [mpMovie retain];
 145             maURL = rURL;
 146             bRet = true;
 147         }
 148     }
 149
 150     [pool release];
 151
 152     return bRet;
 153 }
 154
 155 // ------------------------------------------------------------------------------
 156
 157 void SAL_CALL Player::start(  )
 158     throw (uno::RuntimeException)
 159 {
 160   OSL_TRACE ("Player::start");
 161
 162   if ( mbInitialized && mpMovie )
 163     {
 164       [mpMovie play];
 165     }
 166 }
 167
 168 // ------------------------------------------------------------------------------
 169
 170 void SAL_CALL Player::stop(  )
 171     throw (uno::RuntimeException)
 172 {
 173     OSL_TRACE ("Player::stop");
 174     if ( mpMovie )
 175     {
 176       [mpMovie stop];
 177     }
 178
 179 }
 180
 181 // ------------------------------------------------------------------------------
 182
 183 sal_Bool SAL_CALL Player::isPlaying()
 184     throw (uno::RuntimeException)
 185 {
 186     bool bRet = false;
 187
 188     if ( mbInitialized )
 189     {
 190         if ([mpMovie rate] != 0)
 191         {
 192             bRet = true;
 193         }
 194     }
 195
 196     return bRet;
 197 }
 198
 199 // ------------------------------------------------------------------------------
 200
 201 double SAL_CALL Player::getDuration(  )
 202     throw (uno::RuntimeException)
 203 {
 204     // slideshow checks for non-zero duration, so cheat here
 205     double duration = 0.01;
 206
 207     if ( mpMovie ) // && mnDuration > 0 ) {
 208     {
 209         QTTime structDuration =  [mpMovie duration] ;
 210         duration = (double)structDuration.timeValue / (double)structDuration.timeScale;
 211     }
 212
 213     return duration;
 214 }
 215
 216 // ------------------------------------------------------------------------------
 217
 218 void SAL_CALL Player::setMediaTime( double fTime )
 219     throw (uno::RuntimeException)
 220 {
 221     OSL_TRACE ("Player::setMediaTime");
 222
 223   if ( mpMovie )
 224   {
 225       [mpMovie setCurrentTime: QTMakeTimeWithTimeInterval(fTime)];
 226   }
 227 }
 228
 229 // ------------------------------------------------------------------------------
 230
 231 double SAL_CALL Player::getMediaTime(  )
 232     throw (uno::RuntimeException)
 233 {
 234   double position = 0.0;
 235
 236   if ( mpMovie )
 237   {
 238       QTTime structDuration =  [mpMovie currentTime] ;
 239       position = (double)structDuration.timeValue / (double)structDuration.timeScale;
 240   }
 241
 242   if(isPlaying() && position>mnStopTime)
 243   {
 244       stop();
 245   }
 246
 247
 248   return position;
 249 }
 250
 251 // ------------------------------------------------------------------------------
 252
 253 void SAL_CALL Player::setStopTime( double fTime )
 254     throw (uno::RuntimeException)
 255 {
 256     OSL_TRACE ("Player::setStopTime %f", fTime);
 257
 258     mnStopTime = fTime;
 259
 260 }
 261
 262 // ------------------------------------------------------------------------------
 263
 264 double SAL_CALL Player::getStopTime(  )
 265     throw (uno::RuntimeException)
 266 {
 267     double fRet = 0.0;
 268
 269     fRet = mnStopTime;
 270
 271     return fRet;
 272 }
 273
 274 // ------------------------------------------------------------------------------
 275
 276 void SAL_CALL Player::setRate( double fRate )
 277     throw (uno::RuntimeException)
 278 {
 279     OSL_TRACE ("Player::setRate");
 280
 281     // Quicktime: 0 = stop, 1 = normal speed, 2 = double speed, -1 = normal speed backwards
 282     if ( mpMovie )
 283     {
 284         [mpMovie setRate: fRate];
 285     }
 286 }
 287
 288 // ------------------------------------------------------------------------------
 289
 290 double SAL_CALL Player::getRate(  )
 291     throw (uno::RuntimeException)
 292 {
 293     // Quicktime: 0 = stop, 1 = normal speed, 2 = double speed, -1 = normal speed backwards
 294     double rate = 1.0;
 295
 296     OSL_TRACE ("Player::getRate");
 297
 298     if ( mpMovie )
 299     {
 300         rate = (double) [mpMovie rate];
 301     }
 302
 303     return rate;
 304 }
 305
 306 // ------------------------------------------------------------------------------
 307
 308 void SAL_CALL Player::setPlaybackLoop( sal_Bool bSet )
 309     throw (uno::RuntimeException)
 310 {
 311     OSL_TRACE ("Player::setPlaybackLoop? %s", bSet?"True":"False" );
 312
 313     if(bSet)
 314     {
 315         [mpMovie setAttribute:[NSNumber numberWithBool:YES] forKey: QTMovieLoopsAttribute]  ;
 316     }
 317     else
 318     {
 319          [mpMovie setAttribute:[NSNumber numberWithBool:NO] forKey: QTMovieLoopsAttribute]  ;
 320     }
 321 }
 322
 323 // ------------------------------------------------------------------------------
 324
 325 sal_Bool SAL_CALL Player::isPlaybackLoop(  )
 326     throw (uno::RuntimeException)
 327 {
 328     bool bRet = [[mpMovie attributeForKey:QTMovieLoopsAttribute] boolValue];
 329
 330     OSL_TRACE ("Player::isPlaybackLoop ? %s", bRet?"True":"False" );
 331
 332     return bRet;
 333 }
 334
 335 // ------------------------------------------------------------------------------
 336
 337 void SAL_CALL Player::setMute( sal_Bool bSet )
 338     throw (uno::RuntimeException)
 339 {
 340     OSL_TRACE( "set mute: %d muted: %d unmuted volume: %lf", bSet, mbMuted, mnUnmutedVolume );
 341
 342     // change the volume to 0 or the unmuted volume
 343     if(  mpMovie && mbMuted != bSet )
 344     {
 345         [mpMovie setMuted: bSet ];
 346         mbMuted = bSet;
 347     }
 348
 349 }
 350
 351 // ------------------------------------------------------------------------------
 352
 353 sal_Bool SAL_CALL Player::isMute(  )
 354     throw (uno::RuntimeException)
 355 {
 356     OSL_TRACE ("Player::isMuted");
 357
 358     return mbMuted;
 359 }
 360
 361 // ------------------------------------------------------------------------------
 362
 363 void SAL_CALL Player::setVolumeDB( sal_Int16 nVolumeDB )
 364     throw (uno::RuntimeException)
 365 {
 366     // OOo db volume -40 = QTVolume 0
 367     // OOo db volume 0   = QTvolume 1
 368     if(nVolumeDB==-40)
 369     {
 370         mnUnmutedVolume = 0;
 371     }
 372     else
 373     {
 374         mnUnmutedVolume = pow( 10.0, nVolumeDB / 20.0 );
 375     }
 376
 377     OSL_TRACE( "set volume: %d gst volume: %f", nVolumeDB, mnUnmutedVolume );
 378
 379     // change volume
 380     if( !mbMuted && mpMovie )
 381     {
 382         [mpMovie setVolume: mnUnmutedVolume ];
 383     }
 384 }
 385
 386 // ------------------------------------------------------------------------------
 387
 388 sal_Int16 SAL_CALL Player::getVolumeDB(  )
 389     throw (uno::RuntimeException)
 390 {
 391     sal_Int16 nVolumeDB = 0.0;
 392
 393     if( mpMovie )
 394       {
 395           float volume = 0.0;
 396
 397           volume = [mpMovie volume];
 398           if(volume>0)            //protect from log10(0)
 399           {
 400               nVolumeDB = (sal_Int16) ( 20.0*log10 ( volume ) );
 401           }
 402           else
 403           {
 404               nVolumeDB = -40 ;  // QT zero volume is no volume, -40db
 405           }
 406       }
 407
 408     return nVolumeDB;
 409 }
 410
 411 // ------------------------------------------------------------------------------
 412
 413 awt::Size SAL_CALL Player::getPreferredPlayerWindowSize(  )
 414     throw (uno::RuntimeException)
 415 {
 416     NSSize  nsSize = [[mpMovie attributeForKey:QTMovieNaturalSizeAttribute] sizeValue];
 417     awt::Size aSize( nsSize.width, nsSize.height );
 418     return aSize;
 419 }
 420
 421
 422 // ------------------------------------------------------------------------------
 423
 424 uno::Reference< ::media::XPlayerWindow > SAL_CALL Player::createPlayerWindow( const uno::Sequence< uno::Any >& aArguments )
 425     throw (uno::RuntimeException)
 426 {
 427     uno::Reference< ::media::XPlayerWindow >    xRet;
 428     awt::Size                                   aSize( getPreferredPlayerWindowSize() );
 429     NSSize                                      nsSize( NSMakeSize(aSize.Width, aSize.Height) );
 430
 431     OSL_TRACE( "Player::createPlayerWindow %d %d length: %d", aSize.Width, aSize.Height, aArguments.getLength() );
 432
 433     if( aSize.Width > 0 && aSize.Height > 0 )
 434     {
 435         sal_IntPtr nPtr = NULL;
 436         aArguments[0] >>= nPtr;
 437         NSView* pParentView = reinterpret_cast< NSView * >(nPtr);
 438
 439         ::avmedia::quicktime::Window* pWindow = new ::avmedia::quicktime::Window( mxMgr, *this, pParentView );
 440         xRet = pWindow;
 441     }
 442
 443     return xRet;
 444 }
 445
 446 // ------------------------------------------------------------------------------
 447
 448 uno::Reference< media::XFrameGrabber > SAL_CALL Player::createFrameGrabber(  )
 449     throw (::com::sun::star::uno::RuntimeException)
 450 {
 451   uno::Reference< media::XFrameGrabber > xRet;
 452   OSL_TRACE ("Player::createFrameGrabber");
 453
 454   if( maURL.getLength() > 0 )
 455   {
 456       FrameGrabber* pGrabber = new FrameGrabber( mxMgr );
 457
 458       xRet = pGrabber;
 459
 460       if( !pGrabber->create( maURL ) )
 461       {
 462           xRet.clear();
 463       }
 464   }
 465
 466   return xRet;
 467 }
 468
 469 // ------------------------------------------------------------------------------
 470
 471 ::rtl::OUString SAL_CALL Player::getImplementationName(  )
 472     throw (uno::RuntimeException)
 473 {
 474     return ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( AVMEDIA_QUICKTIME_PLAYER_IMPLEMENTATIONNAME ) );
 475 }
 476
 477 // ------------------------------------------------------------------------------
 478
 479 sal_Bool SAL_CALL Player::supportsService( const ::rtl::OUString& ServiceName )
 480     throw (uno::RuntimeException)
 481 {
 482     return ServiceName.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM ( AVMEDIA_QUICKTIME_PLAYER_SERVICENAME ) );
 483 }
 484
 485 // ------------------------------------------------------------------------------
 486
 487 uno::Sequence< ::rtl::OUString > SAL_CALL Player::getSupportedServiceNames(  )
 488     throw (uno::RuntimeException)
 489 {
 490     uno::Sequence< ::rtl::OUString > aRet(1);
 491     aRet[0] = ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM ( AVMEDIA_QUICKTIME_PLAYER_SERVICENAME ) );
 492
 493     return aRet;
 494 }
 495
 496 } // namespace quicktime
 497 } // namespace avmedia