avmedia/source/win/player.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 <objbase.h>
  21 #include <strmif.h>
  22 #include <control.h>
  23 #include <uuids.h>
  24 #include <evcode.h>
  25
  26 #include "player.hxx"
  27 #include "framegrabber.hxx"
  28 #include "window.hxx"
  29 #include <cppuhelper/supportsservice.hxx>
  30 #include <o3tl/char16_t2wchar_t.hxx>
  31 #include <osl/file.hxx>
  32
  33 #define AVMEDIA_WIN_PLAYER_IMPLEMENTATIONNAME "com.sun.star.comp.avmedia.Player_DirectX"
  34 #define AVMEDIA_WIN_PLAYER_SERVICENAME "com.sun.star.media.Player_DirectX"
  35
  36 using namespace ::com::sun::star;
  37
  38 namespace avmedia::win {
  39
  40 static LRESULT CALLBACK MediaPlayerWndProc_2( HWND hWnd,UINT nMsg, WPARAM nPar1, LPARAM nPar2 )
  41 {
  42     Player* pPlayer = reinterpret_cast<Player*>(::GetWindowLongPtrW( hWnd, 0 ));
  43     bool    bProcessed = true;
  44
  45     if( pPlayer )
  46     {
  47         switch( nMsg )
  48         {
  49             case WM_GRAPHNOTIFY:
  50                 pPlayer->processEvent();
  51             break;
  52             default:
  53                 bProcessed = false;
  54             break;
  55         }
  56     }
  57     else
  58         bProcessed = false;
  59
  60     return( bProcessed ? 0 : DefWindowProcW( hWnd, nMsg, nPar1, nPar2 ) );
  61 }
  62
  63
  64 Player::Player() :
  65     Player_BASE(m_aMutex),
  66     mpGB( nullptr ),
  67     mpOMF( nullptr ),
  68     mpMC( nullptr ),
  69     mpME( nullptr ),
  70     mpMS( nullptr ),
  71     mpMP( nullptr ),
  72     mpBA( nullptr ),
  73     mpBV( nullptr ),
  74     mpVW( nullptr ),
  75     mpEV( nullptr ),
  76     mnUnmutedVolume( 0 ),
  77     mnFrameWnd( nullptr ),
  78     mbMuted( false ),
  79     mbLooping( false ),
  80     mbAddWindow( true )
  81 {
  82     ::CoInitializeEx( nullptr, COINIT_APARTMENTTHREADED );
  83 }
  84
  85
  86 Player::~Player()
  87 {
  88     if( mnFrameWnd )
  89         ::DestroyWindow( mnFrameWnd );
  90
  91     ::CoUninitialize();
  92 }
  93
  94
  95 void SAL_CALL Player::disposing()
  96 {
  97     ::osl::MutexGuard aGuard(m_aMutex);
  98     stop();
  99     if( mpBA )
 100         mpBA->Release();
 101
 102     if( mpBV )
 103         mpBV->Release();
 104
 105     if( mpVW )
 106         mpVW->Release();
 107
 108     if( mpMP )
 109         mpMP->Release();
 110
 111     if( mpMS )
 112         mpMS->Release();
 113
 114     if( mpME )
 115     {
 116         mpME->SetNotifyWindow( 0, WM_GRAPHNOTIFY, 0);
 117         mpME->Release();
 118     }
 119
 120     if( mpMC )
 121         mpMC->Release();
 122
 123     if( mpEV )
 124         mpEV->Release();
 125
 126     if( mpOMF )
 127         mpOMF->Release();
 128
 129     if( mpGB )
 130         mpGB->Release();
 131 }
 132
 133
 134 bool Player::create( const OUString& rURL )
 135 {
 136     HRESULT hR;
 137     bool    bRet = false;
 138
 139     if( SUCCEEDED( hR = CoCreateInstance( CLSID_FilterGraph, nullptr, CLSCTX_INPROC_SERVER, IID_IGraphBuilder, reinterpret_cast<void**>(&mpGB) ) ) )
 140     {
 141         // Don't use the overlay mixer on Windows Vista
 142         // It disables the desktop composition as soon as RenderFile is called
 143         // also causes some other problems: video rendering is not reliable
 144
 145         // tdf#128057: IGraphBuilder::RenderFile seems to fail to handle file URIs properly when
 146         // they contain encoded characters like "%23"; so pass system path in that case instead.
 147         OUString aFile(rURL);
 148         if (aFile.startsWithIgnoreAsciiCase("file:"))
 149             osl::FileBase::getSystemPathFromFileURL(rURL, aFile);
 150
 151         if( SUCCEEDED( hR = mpGB->RenderFile( o3tl::toW(aFile.getStr()), nullptr ) ) &&
 152             SUCCEEDED( hR = mpGB->QueryInterface( IID_IMediaControl, reinterpret_cast<void**>(&mpMC) ) ) &&
 153             SUCCEEDED( hR = mpGB->QueryInterface( IID_IMediaEventEx, reinterpret_cast<void**>(&mpME) ) ) &&
 154             SUCCEEDED( hR = mpGB->QueryInterface( IID_IMediaSeeking, reinterpret_cast<void**>(&mpMS) ) ) &&
 155             SUCCEEDED( hR = mpGB->QueryInterface( IID_IMediaPosition, reinterpret_cast<void**>(&mpMP) ) ) )
 156         {
 157             // Video interfaces
 158             mpGB->QueryInterface( IID_IVideoWindow, reinterpret_cast<void**>(&mpVW) );
 159             mpGB->QueryInterface( IID_IBasicVideo, reinterpret_cast<void**>(&mpBV) );
 160
 161             // Audio interface
 162             mpGB->QueryInterface( IID_IBasicAudio, reinterpret_cast<void**>(&mpBA) );
 163
 164             if( mpBA )
 165                 mpBA->put_Volume( mnUnmutedVolume );
 166
 167             bRet = true;
 168         }
 169     }
 170
 171     if( bRet )
 172         maURL = rURL;
 173     else
 174         maURL.clear();
 175
 176     return bRet;
 177 }
 178
 179
 180 const IVideoWindow* Player::getVideoWindow() const
 181 {
 182     return mpVW;
 183 }
 184
 185
 186 void Player::setNotifyWnd( HWND nNotifyWnd )
 187 {
 188     mbAddWindow = false;
 189     if( mpME )
 190         mpME->SetNotifyWindow( reinterpret_cast<OAHWND>(nNotifyWnd), WM_GRAPHNOTIFY, reinterpret_cast< LONG_PTR>( this ) );
 191 }
 192
 193
 194 long Player::processEvent()
 195 {
 196     long nCode;
 197     LONG_PTR nParam1, nParam2;
 198
 199     while( mpME && SUCCEEDED( mpME->GetEvent( &nCode, &nParam1, &nParam2, 0 ) ) )
 200     {
 201         if( EC_COMPLETE == nCode )
 202         {
 203             if( mbLooping )
 204             {
 205                 setMediaTime( 0.0 );
 206                 start();
 207             }
 208             else
 209             {
 210                 setMediaTime( getDuration() );
 211                 stop();
 212             }
 213         }
 214
 215         mpME->FreeEventParams( nCode, nParam1, nParam2 );
 216     }
 217
 218     return 0;
 219 }
 220
 221
 222 void SAL_CALL Player::start(  )
 223 {
 224     ::osl::MutexGuard aGuard(m_aMutex);
 225     if( mpMC )
 226     {
 227         if ( mbAddWindow )
 228         {
 229             static WNDCLASSW* mpWndClass = nullptr;
 230             if ( !mpWndClass )
 231             {
 232                 mpWndClass = new WNDCLASSW;
 233
 234                 memset( mpWndClass, 0, sizeof( *mpWndClass ) );
 235                 mpWndClass->hInstance = GetModuleHandleW( nullptr );
 236                 mpWndClass->cbWndExtra = sizeof( DWORD );
 237                 mpWndClass->lpfnWndProc = MediaPlayerWndProc_2;
 238                 mpWndClass->lpszClassName = L"com_sun_star_media_Sound_Player";
 239                 mpWndClass->hbrBackground = static_cast<HBRUSH>(::GetStockObject( BLACK_BRUSH ));
 240                 mpWndClass->hCursor = ::LoadCursor( nullptr, IDC_ARROW );
 241
 242                 RegisterClassW( mpWndClass );
 243             }
 244             if ( !mnFrameWnd )
 245             {
 246                 mnFrameWnd = CreateWindowW( mpWndClass->lpszClassName, nullptr,
 247                                             0,
 248                                             0, 0, 0, 0,
 249                                             nullptr, nullptr, mpWndClass->hInstance, nullptr );
 250                 if ( mnFrameWnd )
 251                 {
 252                     ::ShowWindow(mnFrameWnd, SW_HIDE);
 253                     SetWindowLongPtrW( mnFrameWnd, 0, reinterpret_cast<LONG_PTR>(this) );
 254                     // mpVW->put_Owner( (OAHWND) mnFrameWnd );
 255                     setNotifyWnd( mnFrameWnd );
 256                 }
 257             }
 258         }
 259
 260         mpMC->Run();
 261     }
 262 }
 263
 264
 265 void SAL_CALL Player::stop(  )
 266 {
 267     ::osl::MutexGuard aGuard(m_aMutex);
 268     if( mpMC )
 269         mpMC->Stop();
 270 }
 271
 272
 273 sal_Bool SAL_CALL Player::isPlaying()
 274 {
 275     ::osl::MutexGuard aGuard(m_aMutex);
 276
 277     OAFilterState   eFilterState;
 278     bool            bRet = false;
 279
 280     if( mpMC && SUCCEEDED( mpMC->GetState( 10, &eFilterState ) ) )
 281         bRet = ( State_Running == eFilterState );
 282
 283     return bRet;
 284 }
 285
 286
 287 double SAL_CALL Player::getDuration(  )
 288 {
 289     ::osl::MutexGuard aGuard(m_aMutex);
 290
 291     REFTIME aRefTime( 0.0 );
 292
 293     if( mpMP  )
 294         mpMP->get_Duration( &aRefTime );
 295
 296     return aRefTime;
 297 }
 298
 299
 300 void SAL_CALL Player::setMediaTime( double fTime )
 301 {
 302     ::osl::MutexGuard aGuard(m_aMutex);
 303
 304     if( mpMP  )
 305     {
 306         const bool bPlaying = isPlaying();
 307
 308         mpMP->put_CurrentPosition( fTime );
 309
 310         if( !bPlaying && mpMC )
 311             mpMC->StopWhenReady();
 312     }
 313 }
 314
 315
 316 double SAL_CALL Player::getMediaTime(  )
 317 {
 318     ::osl::MutexGuard aGuard(m_aMutex);
 319
 320     REFTIME aRefTime( 0.0 );
 321
 322     if( mpMP  )
 323         mpMP->get_CurrentPosition( &aRefTime );
 324
 325     return aRefTime;
 326 }
 327
 328
 329 void SAL_CALL Player::setPlaybackLoop( sal_Bool bSet )
 330 {
 331     ::osl::MutexGuard aGuard(m_aMutex);
 332
 333     mbLooping = bSet;
 334 }
 335
 336
 337 sal_Bool SAL_CALL Player::isPlaybackLoop(  )
 338 {
 339     ::osl::MutexGuard aGuard(m_aMutex);
 340
 341     return mbLooping;
 342 }
 343
 344
 345 void SAL_CALL Player::setMute( sal_Bool bSet )
 346 {
 347     ::osl::MutexGuard aGuard(m_aMutex);
 348
 349     if (mpBA && (mbMuted != static_cast<bool>(bSet)))
 350     {
 351         mbMuted = bSet;
 352         mpBA->put_Volume( mbMuted ? -10000 : mnUnmutedVolume );
 353     }
 354 }
 355
 356
 357 sal_Bool SAL_CALL Player::isMute(  )
 358 {
 359     ::osl::MutexGuard aGuard(m_aMutex);
 360
 361     return mbMuted;
 362 }
 363
 364
 365 void SAL_CALL Player::setVolumeDB( sal_Int16 nVolumeDB )
 366 {
 367     ::osl::MutexGuard aGuard(m_aMutex);
 368
 369     mnUnmutedVolume = static_cast< long >( nVolumeDB ) * 100;
 370
 371     if( !mbMuted && mpBA )
 372         mpBA->put_Volume( mnUnmutedVolume );
 373 }
 374
 375
 376 sal_Int16 SAL_CALL Player::getVolumeDB(  )
 377 {
 378     ::osl::MutexGuard aGuard(m_aMutex);
 379
 380     return static_cast< sal_Int16 >( mnUnmutedVolume / 100 );
 381 }
 382
 383
 384 awt::Size SAL_CALL Player::getPreferredPlayerWindowSize(  )
 385 {
 386     ::osl::MutexGuard aGuard(m_aMutex);
 387
 388     awt::Size aSize( 0, 0 );
 389
 390     if( mpBV )
 391     {
 392         long nWidth = 0, nHeight = 0;
 393
 394         mpBV->GetVideoSize( &nWidth, &nHeight );
 395         aSize.Width = nWidth;
 396         aSize.Height = nHeight;
 397     }
 398
 399     return aSize;
 400 }
 401
 402
 403 uno::Reference< ::media::XPlayerWindow > SAL_CALL Player::createPlayerWindow( const uno::Sequence< uno::Any >& aArguments )
 404 {
 405     ::osl::MutexGuard aGuard(m_aMutex);
 406
 407     uno::Reference< ::media::XPlayerWindow >    xRet;
 408     awt::Size                                   aSize( getPreferredPlayerWindowSize() );
 409
 410     if( mpVW && aSize.Width > 0 && aSize.Height > 0 )
 411     {
 412         ::avmedia::win::Window* pWindow = new ::avmedia::win::Window( *this );
 413
 414         xRet = pWindow;
 415
 416         if( !pWindow->create( aArguments ) )
 417             xRet.clear();
 418     }
 419
 420     return xRet;
 421 }
 422
 423
 424 uno::Reference< media::XFrameGrabber > SAL_CALL Player::createFrameGrabber(  )
 425 {
 426     uno::Reference< media::XFrameGrabber > xRet;
 427
 428     if( !maURL.isEmpty() )
 429     {
 430         FrameGrabber* pGrabber = new FrameGrabber();
 431
 432         xRet = pGrabber;
 433
 434         if( !pGrabber->create( maURL ) )
 435             xRet.clear();
 436     }
 437
 438     return xRet;
 439 }
 440
 441
 442 OUString SAL_CALL Player::getImplementationName(  )
 443 {
 444     return AVMEDIA_WIN_PLAYER_IMPLEMENTATIONNAME;
 445 }
 446
 447
 448 sal_Bool SAL_CALL Player::supportsService( const OUString& ServiceName )
 449 {
 450     return cppu::supportsService(this, ServiceName);
 451 }
 452
 453
 454 uno::Sequence< OUString > SAL_CALL Player::getSupportedServiceNames(  )
 455 {
 456     return { AVMEDIA_WIN_PLAYER_SERVICENAME };
 457 }
 458
 459 } // namespace avmedia::win
 460
 461
 462 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */