avmedia/source/opengl/oglplayer.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
  10 #include "oglplayer.hxx"
  11 #include "oglframegrabber.hxx"
  12 #include "oglwindow.hxx"
  13
  14 #include <cppuhelper/supportsservice.hxx>
  15 #include <tools/stream.hxx>
  16 #include <vcl/graph.hxx>
  17 #include <vcl/graphicfilter.hxx>
  18 #include <tools/urlobj.hxx>
  19 #include <vcl/opengl/OpenGLHelper.hxx>
  20
  21 #include <cassert>
  22
  23 using namespace com::sun::star;
  24 using namespace libgltf;
  25
  26 namespace avmedia { namespace ogl {
  27
  28 OGLPlayer::OGLPlayer()
  29     : Player_BASE(m_aMutex)
  30     , m_pHandle(NULL)
  31     , m_xContext(OpenGLContext::Create())
  32     , m_pOGLWindow(NULL)
  33     , m_bIsRendering(false)
  34 {
  35 }
  36
  37 OGLPlayer::~OGLPlayer()
  38 {
  39     osl::MutexGuard aGuard(m_aMutex);
  40     if( m_pHandle )
  41     {
  42         m_xContext->makeCurrent();
  43         gltf_renderer_release(m_pHandle);
  44         m_xContext->dispose();
  45     }
  46     releaseInputFiles();
  47 }
  48
  49 static bool lcl_LoadFile( glTFFile* io_pFile, const OUString& rURL)
  50 {
  51     SvFileStream aStream( rURL, StreamMode::READ );
  52     if( !aStream.IsOpen() )
  53         return false;
  54
  55     const sal_Int64 nBytes = aStream.remainingSize();
  56     char* pBuffer = new char[nBytes];
  57     aStream.Read( pBuffer, nBytes );
  58     aStream.Close();
  59
  60     io_pFile->buffer = pBuffer;
  61     io_pFile->size = nBytes;
  62
  63     return true;
  64 }
  65
  66 bool OGLPlayer::create( const OUString& rURL )
  67 {
  68     osl::MutexGuard aGuard(m_aMutex);
  69
  70     m_sURL = rURL;
  71
  72     // Convert URL to a system path
  73     const INetURLObject aURLObj(m_sURL);
  74     const std::string sFilePath = OUStringToOString( aURLObj.getFSysPath(INetURLObject::FSYS_DETECT), RTL_TEXTENCODING_UTF8 ).getStr();
  75
  76     // Load *.json file and init renderer
  77     m_pHandle = gltf_renderer_init(sFilePath, m_vInputFiles);
  78
  79     if( !m_pHandle )
  80     {
  81         SAL_WARN("avmedia.opengl", "gltf_renderer_init returned an invalid glTFHandle");
  82         return false;
  83     }
  84
  85     // Load external resources
  86     for( size_t i = 0; i < m_vInputFiles.size(); ++i )
  87     {
  88         glTFFile& rFile = m_vInputFiles[i];
  89         if( !rFile.filename.empty() )
  90         {
  91             const OUString sFilesURL =
  92                 INetURLObject::GetAbsURL(m_sURL,OStringToOUString(OString(rFile.filename.c_str()),RTL_TEXTENCODING_UTF8));
  93             if( rFile.type == GLTF_IMAGE )
  94             {
  95                 // Load images as bitmaps
  96                 GraphicFilter aFilter;
  97                 Graphic aGraphic;
  98                 if( aFilter.ImportGraphic(aGraphic, INetURLObject(sFilesURL)) != GRFILTER_OK )
  99                 {
 100                     rFile.buffer = 0;
 101                     rFile.imagewidth = 0;
 102                     rFile.imageheight = 0;
 103                     SAL_WARN("avmedia.opengl", "Can't load texture file: " + sFilesURL);
 104                     return false;
 105                 }
 106                 BitmapEx aBitmapEx = aGraphic.GetBitmapEx();
 107                 rFile.buffer = new char[4 * aBitmapEx.GetSizePixel().Width() * aBitmapEx.GetSizePixel().Height()];
 108                 OpenGLHelper::ConvertBitmapExToRGBATextureBuffer(aBitmapEx, reinterpret_cast<sal_uInt8*>(rFile.buffer), true);
 109                 rFile.imagewidth = aBitmapEx.GetSizePixel().Width();
 110                 rFile.imageheight = aBitmapEx.GetSizePixel().Height();
 111             }
 112             else if( rFile.type == GLTF_BINARY || rFile.type == GLTF_GLSL )
 113             {
 114                 if( !lcl_LoadFile(&rFile, sFilesURL) )
 115                 {
 116                     rFile.buffer = 0;
 117                     rFile.size = 0;
 118                     SAL_WARN("avmedia.opengl", "Can't load glTF file: " + sFilesURL);
 119                     return false;
 120                 }
 121             }
 122         }
 123     }
 124
 125     // Set timer
 126     m_aTimer.SetTimeout(8); // is 125fps enough for anyone ?
 127     m_aTimer.SetPriority(SchedulerPriority::LOW);
 128     m_aTimer.SetTimeoutHdl(LINK(this,OGLPlayer,TimerHandler));
 129
 130     return true;
 131 }
 132
 133 void OGLPlayer::releaseInputFiles()
 134 {
 135     for (size_t i = 0; i < m_vInputFiles.size() && m_vInputFiles[i].buffer; ++i)
 136     {
 137         delete [] m_vInputFiles[i].buffer;
 138         m_vInputFiles[i].buffer = 0;
 139     }
 140     m_vInputFiles.clear();
 141 }
 142
 143 void SAL_CALL OGLPlayer::start() throw ( uno::RuntimeException, std::exception )
 144 {
 145     osl::MutexGuard aGuard(m_aMutex);
 146     assert(m_pHandle);
 147
 148     if(!m_pOGLWindow)
 149         return;
 150
 151     gltf_animation_resume(m_pHandle);
 152     m_aTimer.Start();
 153     m_bIsRendering = true;
 154 }
 155
 156 void SAL_CALL OGLPlayer::stop() throw ( uno::RuntimeException, std::exception )
 157 {
 158     osl::MutexGuard aGuard(m_aMutex);
 159     assert(m_pHandle);
 160     m_aTimer.Stop();
 161     gltf_animation_stop(m_pHandle);
 162     m_bIsRendering = false;
 163 }
 164
 165 sal_Bool SAL_CALL OGLPlayer::isPlaying() throw ( uno::RuntimeException, std::exception )
 166 {
 167     osl::MutexGuard aGuard(m_aMutex);
 168     assert(m_pHandle);
 169     // Here isPlaying means model is rendered in the window and
 170     // able to interact with the user (e.g. moving camera)
 171     if( getDuration() > 0.0 )
 172         return gltf_animation_is_playing(m_pHandle);
 173     else
 174         return m_bIsRendering;
 175 }
 176
 177 double SAL_CALL OGLPlayer::getDuration() throw ( uno::RuntimeException, std::exception )
 178 {
 179     osl::MutexGuard aGuard(m_aMutex);
 180     assert(m_pHandle);
 181     return gltf_animation_get_duration(m_pHandle);
 182 }
 183
 184 void SAL_CALL OGLPlayer::setMediaTime( double fTime ) throw ( uno::RuntimeException, std::exception )
 185 {
 186     osl::MutexGuard aGuard(m_aMutex);
 187     assert(m_pHandle);
 188     gltf_animation_set_time(m_pHandle, fTime);
 189 }
 190
 191 double SAL_CALL OGLPlayer::getMediaTime() throw ( ::com::sun::star::uno::RuntimeException, std::exception )
 192 {
 193     osl::MutexGuard aGuard(m_aMutex);
 194     assert(m_pHandle);
 195     return gltf_animation_get_time(m_pHandle);
 196 }
 197
 198 void SAL_CALL OGLPlayer::setPlaybackLoop( sal_Bool bSet ) throw ( uno::RuntimeException, std::exception )
 199 {
 200     osl::MutexGuard aGuard(m_aMutex);
 201     assert(m_pHandle);
 202     gltf_animation_set_looping(m_pHandle, bSet);
 203 }
 204
 205 sal_Bool SAL_CALL OGLPlayer::isPlaybackLoop() throw ( uno::RuntimeException, std::exception )
 206 {
 207     osl::MutexGuard aGuard(m_aMutex);
 208     assert(m_pHandle);
 209     return gltf_animation_get_looping(m_pHandle);
 210 }
 211
 212 void SAL_CALL OGLPlayer::setVolumeDB( sal_Int16 /*nVolumDB*/ ) throw ( uno::RuntimeException, std::exception )
 213 {
 214     // OpenGL models have no sound.
 215 }
 216
 217 sal_Int16 SAL_CALL OGLPlayer::getVolumeDB() throw ( uno::RuntimeException, std::exception )
 218 {
 219     // OpenGL models have no sound.
 220     return 0;
 221 }
 222
 223 void SAL_CALL OGLPlayer::setMute( sal_Bool /*bSet*/ ) throw ( uno::RuntimeException, std::exception )
 224 {
 225     // OpenGL models have no sound.
 226 }
 227
 228 sal_Bool SAL_CALL OGLPlayer::isMute() throw ( uno::RuntimeException, std::exception )
 229 {
 230     // OpenGL models have no sound.
 231     return false;
 232 }
 233
 234 awt::Size SAL_CALL OGLPlayer::getPreferredPlayerWindowSize() throw ( uno::RuntimeException, std::exception )
 235 {
 236     return awt::Size( 480, 360 );
 237 }
 238
 239 static bool lcl_CheckOpenGLRequirements()
 240 {
 241     return OpenGLHelper::getGLVersion() >= 3.0;
 242 }
 243
 244 uno::Reference< media::XPlayerWindow > SAL_CALL OGLPlayer::createPlayerWindow( const uno::Sequence< uno::Any >& rArguments )
 245      throw ( uno::RuntimeException, std::exception )
 246 {
 247     osl::MutexGuard aGuard( m_aMutex );
 248
 249     assert( rArguments.getLength() >= 3 );
 250     assert(m_pHandle);
 251
 252     sal_IntPtr pIntPtr = 0;
 253     rArguments[ 2 ] >>= pIntPtr;
 254     SystemChildWindow *pChildWindow = reinterpret_cast< SystemChildWindow* >( pIntPtr );
 255
 256     if( !pChildWindow )
 257     {
 258         SAL_WARN("avmedia.opengl", "Failed to get the SystemChildWindow for rendering!");
 259         return uno::Reference< media::XPlayerWindow >();
 260     }
 261     assert(pChildWindow->GetParent());
 262
 263     if( !m_xContext->init(pChildWindow) )
 264     {
 265         SAL_WARN("avmedia.opengl", "Context initialization failed");
 266         return uno::Reference< media::XPlayerWindow >();
 267     }
 268
 269     if( !m_xContext->supportMultiSampling() )
 270     {
 271         SAL_WARN("avmedia.opengl", "Context does not support multisampling!");
 272         return uno::Reference< media::XPlayerWindow >();
 273     }
 274
 275     if( !lcl_CheckOpenGLRequirements() )
 276     {
 277         SAL_WARN("avmedia.opengl", "Your platform does not have the minimal OpenGL requiremenets!");
 278         return uno::Reference< media::XPlayerWindow >();
 279     }
 280
 281     Size aSize = pChildWindow->GetSizePixel();
 282     m_xContext->setWinSize(aSize);
 283     m_pHandle->viewport.x = 0;
 284     m_pHandle->viewport.y = 0;
 285     m_pHandle->viewport.width = aSize.Width();
 286     m_pHandle->viewport.height = aSize.Height();
 287
 288     // TODO: Use the error codes to print a readable error message
 289     int nRet = gltf_renderer_set_content(m_pHandle, m_vInputFiles);
 290     releaseInputFiles();
 291     if( nRet != 0 )
 292     {
 293         SAL_WARN("avmedia.opengl", "Error occurred while setting up the scene! Error code: " << nRet);
 294         return uno::Reference< media::XPlayerWindow >();
 295     }
 296     // The background color is white by default, but we need to separate the
 297     // OpenGL window from the main window so set background color to grey
 298     glClearColor(0.5f, 0.5f, 0.5f, 0.5f);
 299     m_pOGLWindow = new OGLWindow(*m_pHandle, m_xContext, *pChildWindow->GetParent());
 300     return uno::Reference< media::XPlayerWindow >( m_pOGLWindow );
 301 }
 302
 303 uno::Reference< media::XFrameGrabber > SAL_CALL OGLPlayer::createFrameGrabber()
 304      throw ( uno::RuntimeException, std::exception )
 305 {
 306     osl::MutexGuard aGuard(m_aMutex);
 307     assert(m_pHandle);
 308
 309     if( !m_xContext->init() )
 310     {
 311         SAL_WARN("avmedia.opengl", "Offscreen context initialization failed");
 312         return uno::Reference< media::XFrameGrabber >();
 313     }
 314
 315     if( !m_xContext->supportMultiSampling() )
 316     {
 317         SAL_WARN("avmedia.opengl", "Context does not support multisampling!");
 318         return uno::Reference< media::XFrameGrabber >();
 319     }
 320
 321     if( !lcl_CheckOpenGLRequirements() )
 322     {
 323         SAL_WARN("avmedia.opengl", "Your platform does not have the minimal OpenGL requiremenets!");
 324         return uno::Reference< media::XFrameGrabber >();
 325     }
 326
 327     m_pHandle->viewport.x = 0;
 328     m_pHandle->viewport.y = 0;
 329     m_pHandle->viewport.width = getPreferredPlayerWindowSize().Width;
 330     m_pHandle->viewport.height = getPreferredPlayerWindowSize().Height;
 331
 332     int nRet = gltf_renderer_set_content(m_pHandle, m_vInputFiles);
 333     releaseInputFiles();
 334     if( nRet != 0 )
 335     {
 336         SAL_WARN("avmedia.opengl", "Error occurred while setting up the scene! Error code: " << nRet);
 337         return uno::Reference< media::XFrameGrabber >();
 338     }
 339     glClearColor(0.5f, 0.5f, 0.5f, 0.5f);
 340     OGLFrameGrabber *pFrameGrabber = new OGLFrameGrabber( *m_pHandle );
 341     return uno::Reference< media::XFrameGrabber >( pFrameGrabber );
 342 }
 343
 344 OUString SAL_CALL OGLPlayer::getImplementationName()
 345      throw ( ::com::sun::star::uno::RuntimeException, std::exception )
 346 {
 347     return OUString("com.sun.star.comp.avmedia.Player_OpenGL");
 348 }
 349
 350 sal_Bool SAL_CALL OGLPlayer::supportsService( const OUString& rServiceName )
 351      throw ( uno::RuntimeException, std::exception )
 352 {
 353     return cppu::supportsService(this, rServiceName);
 354 }
 355
 356 uno::Sequence< OUString > SAL_CALL OGLPlayer::getSupportedServiceNames()
 357      throw ( uno::RuntimeException, std::exception )
 358 {
 359     uno::Sequence< OUString > aRet(1);
 360     aRet[0] = "com.sun.star.media.Player_OpenGL";
 361     return aRet;
 362 }
 363
 364 IMPL_LINK_TYPED(OGLPlayer,TimerHandler,Timer*,pTimer,void)
 365 {
 366     if (pTimer == &m_aTimer)
 367     {
 368         osl::MutexGuard aGuard(m_aMutex);
 369         assert(m_pOGLWindow);
 370         m_pOGLWindow->update();
 371     }
 372 }
 373
 374 } // namespace ogl
 375 } // namespace avmedia
 376
 377 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */