avmedia/source/gstreamer/gstplayer.cxx

   1 /*************************************************************************
   2  *
   3  *  OpenOffice.org - a multi-platform office productivity suite
   4  *
   5  *  $RCSfile$
   6  *
   7  *  $Revision$
   8  *
   9  *  last change: $Author$ $Date$
  10  *
  11  *  The Contents of this file are made available subject to
  12  *  the terms of GNU Lesser General Public License Version 2.1.
  13  *
  14  *
  15  *    GNU Lesser General Public License Version 2.1
  16  *    =============================================
  17  *    Copyright 2005 by Sun Microsystems, Inc.
  18  *    901 San Antonio Road, Palo Alto, CA 94303, USA
  19  *
  20  *    This library is free software; you can redistribute it and/or
  21  *    modify it under the terms of the GNU Lesser General Public
  22  *    License version 2.1, as published by the Free Software Foundation.
  23  *
  24  *    This library is distributed in the hope that it will be useful,
  25  *    but WITHOUT ANY WARRANTY; without even the implied warranty of
  26  *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  27  *    Lesser General Public License for more details.
  28  *
  29  *    You should have received a copy of the GNU Lesser General Public
  30  *    License along with this library; if not, write to the Free Software
  31  *    Foundation, Inc., 59 Temple Place, Suite 330, Boston,
  32  *    MA  02111-1307  USA
  33  *
  34  ************************************************************************/
  35
  36 #include <math.h>
  37
  38 #ifndef __RTL_USTRING_
  39 #include <rtl/string.hxx>
  40 #endif
  41
  42 #include "gstplayer.hxx"
  43 #include "gstframegrabber.hxx"
  44 #include "gstwindow.hxx"
  45
  46 #include <gst/interfaces/xoverlay.h>
  47
  48 #define AVMEDIA_GST_PLAYER_IMPLEMENTATIONNAME "com.sun.star.comp.avmedia.Player_GStreamer"
  49 #define AVMEDIA_GST_PLAYER_SERVICENAME "com.sun.star.media.Player_GStreamer"
  50
  51 #if DEBUG
  52 #define DBG OSL_TRACE
  53 #else
  54 #define DBG(...)
  55 #endif
  56
  57 using namespace ::com::sun::star;
  58
  59 namespace avmedia { namespace gstreamer {
  60
  61 // ----------------
  62 // - Player -
  63 // ----------------
  64
  65 Player::Player( const uno::Reference< lang::XMultiServiceFactory >& rxMgr ) :
  66     mxMgr( rxMgr ),
  67     mpPlaybin( NULL ),
  68     mbFakeVideo (sal_False ),
  69     mnUnmutedVolume( 0 ),
  70     mbPlayPending ( false ),
  71     mbMuted( false ),
  72     mbLooping( false ),
  73     mbInitialized( false ),
  74     mnWindowID( 0 ),
  75     mpXOverlay( NULL ),
  76     mnDuration( 0 ),
  77     mnWidth( 0 ),
  78     mnHeight( 0 ),
  79     maSizeCondition( osl_createCondition() )
  80 {
  81     // Initialize GStreamer library
  82     int argc = 1;
  83     char *arguments[] = { "openoffice.org" };
  84     char** argv = arguments;
  85     GError* pError = NULL;
  86
  87     mbInitialized = gst_init_check( &argc, &argv, &pError );
  88
  89     if (pError != NULL)
  90         // TODO: thow an exception?
  91         g_error_free (pError);
  92 }
  93
  94 // ------------------------------------------------------------------------------
  95
  96 Player::~Player()
  97 {
  98     // Release the elements and pipeline
  99     if( mbInitialized )
 100     {
 101         if( mpPlaybin )
 102         {
 103             gst_element_set_state( mpPlaybin, GST_STATE_NULL );
 104             gst_object_unref( GST_OBJECT( mpPlaybin ) );
 105
 106             mpPlaybin = NULL;
 107         }
 108
 109         if( mpXOverlay ) {
 110             g_object_unref( G_OBJECT ( mpXOverlay ) );
 111             mpXOverlay = NULL;
 112         }
 113     }
 114 }
 115
 116 // ------------------------------------------------------------------------------
 117
 118 static gboolean gst_pipeline_bus_callback( GstBus *, GstMessage *message, gpointer data )
 119 {
 120     Player* pPlayer = (Player *) data;
 121
 122     pPlayer->processMessage( message );
 123
 124     return TRUE;
 125 }
 126
 127 static GstBusSyncReply gst_pipeline_bus_sync_handler( GstBus *, GstMessage * message, gpointer data )
 128 {
 129     Player* pPlayer = (Player *) data;
 130
 131     return pPlayer->processSyncMessage( message );
 132 }
 133
 134 void Player::processMessage( GstMessage *message )
 135 {
 136     //DBG ( "gst message received: src name: %s structure type: %s",
 137     //            gst_object_get_name (message->src),
 138     //            message->structure ? gst_structure_get_name (message->structure) : "<none>");
 139
 140     switch( GST_MESSAGE_TYPE( message ) ) {
 141     case GST_MESSAGE_EOS:
 142         //DBG( "EOS, reset state to NULL" );
 143         gst_element_set_state( mpPlaybin, GST_STATE_READY );
 144         mbPlayPending = false;
 145         if (mbLooping)
 146             start();
 147         break;
 148     case GST_MESSAGE_STATE_CHANGED:
 149         if( message->src == GST_OBJECT( mpPlaybin ) ) {
 150             GstState newstate, pendingstate;
 151
 152             gst_message_parse_state_changed (message, NULL, &newstate, &pendingstate);
 153
 154             if( newstate == GST_STATE_PAUSED &&
 155                 pendingstate == GST_STATE_VOID_PENDING &&
 156                 mpXOverlay )
 157                 gst_x_overlay_expose( mpXOverlay );
 158
 159             if (mbPlayPending)
 160                 mbPlayPending = ((newstate == GST_STATE_READY) || (newstate == GST_STATE_PAUSED));
 161         }
 162     default:
 163         break;
 164     }
 165 }
 166
 167 GstBusSyncReply Player::processSyncMessage( GstMessage *message )
 168 {
 169     DBG( "%p processSyncMessage", this );
 170     //DBG ( "gst message received: src name: %s structure type: %s",
 171     //            gst_object_get_name (message->src),
 172     //            message->structure ? gst_structure_get_name (message->structure) : "<none>");
 173
 174     if (message->structure) {
 175         if( !strcmp( gst_structure_get_name( message->structure ), "prepare-xwindow-id" ) && mnWindowID != 0 ) {
 176             if( mpXOverlay )
 177                 g_object_unref( G_OBJECT ( mpXOverlay ) );
 178             mpXOverlay = GST_X_OVERLAY( GST_MESSAGE_SRC( message ) );
 179             g_object_ref( G_OBJECT ( mpXOverlay ) );
 180             gst_x_overlay_set_xwindow_id( mpXOverlay, mnWindowID );
 181             return GST_BUS_DROP;
 182         }
 183     }
 184
 185     if( GST_MESSAGE_TYPE( message ) == GST_MESSAGE_STATE_CHANGED ) {
 186         if( message->src == GST_OBJECT( mpPlaybin ) ) {
 187             GstState newstate, pendingstate;
 188
 189             gst_message_parse_state_changed (message, NULL, &newstate, &pendingstate);
 190
 191             DBG( "%p state change received, new state %d", this, newstate );
 192             if( newstate == GST_STATE_PAUSED &&
 193                 pendingstate == GST_STATE_VOID_PENDING ) {
 194
 195                 DBG( "%p change to paused received", this );
 196
 197                 if( mnDuration == 0) {
 198                     GstFormat format = GST_FORMAT_TIME;
 199                     gint64 gst_duration = 0L;
 200
 201                     if( gst_element_query_duration( mpPlaybin, &format, &gst_duration) && format == GST_FORMAT_TIME && gst_duration > 0L )
 202                         mnDuration = gst_duration;
 203                 }
 204
 205                 if( mnWidth == 0 ) {
 206                     GList *pStreamInfo = NULL;
 207
 208                     g_object_get( G_OBJECT( mpPlaybin ), "stream-info", &pStreamInfo, NULL );
 209
 210                     for ( ; pStreamInfo != NULL; pStreamInfo = pStreamInfo->next) {
 211                         GObject *pInfo = G_OBJECT( pStreamInfo->data );
 212
 213                         if( !pInfo )
 214                             continue;
 215
 216                         int nType;
 217                         g_object_get( pInfo, "type", &nType, NULL );
 218                         GEnumValue *pValue = g_enum_get_value( G_PARAM_SPEC_ENUM( g_object_class_find_property( G_OBJECT_GET_CLASS( pInfo ), "type" ) )->enum_class,
 219                                                                nType );
 220
 221                         if( !g_strcasecmp( pValue->value_nick, "video" ) ) {
 222                             GstStructure *pStructure;
 223                             GstPad *pPad;
 224
 225                             g_object_get( pInfo, "object", &pPad, NULL );
 226                             pStructure = gst_caps_get_structure( GST_PAD_CAPS( pPad ), 0 );
 227                             if( pStructure ) {
 228                                 gst_structure_get_int( pStructure, "width", &mnWidth );
 229                                 gst_structure_get_int( pStructure, "height", &mnHeight );
 230                                 DBG( "queried size: %d x %d", mnWidth, mnHeight );
 231                             }
 232                         }
 233                     }
 234
 235                     sal_Bool aSuccess = osl_setCondition( maSizeCondition );
 236                     DBG( "%p set condition result: %d", this, aSuccess );
 237                 }
 238             }
 239         }
 240     } else if( GST_MESSAGE_TYPE( message ) == GST_MESSAGE_ERROR ) {
 241         if( mnWidth == 0 ) {
 242             // an error occured, set condition so that OOo thread doesn't wait for us
 243             sal_Bool aSuccess = osl_setCondition( maSizeCondition );
 244             DBG( "%p set condition result: %d", this, aSuccess );
 245         }
 246     }
 247
 248     return GST_BUS_PASS;
 249 }
 250
 251 void Player::preparePlaybin( const ::rtl::OUString& rURL, bool bFakeVideo )
 252 {
 253         GstBus *pBus;
 254
 255         //sal_Bool aSuccess = osl_setCondition( maSizeCondition );
 256         //DBG( "%p set condition result: %d", this, aSuccess );
 257
 258         if( mpPlaybin != NULL ) {
 259             gst_element_set_state( mpPlaybin, GST_STATE_NULL );
 260             mbPlayPending = false;
 261             g_object_unref( mpPlaybin );
 262         }
 263
 264         mpPlaybin = gst_element_factory_make( "playbin", NULL );
 265
 266         if( bFakeVideo )
 267             g_object_set( G_OBJECT( mpPlaybin ), "video-sink", gst_element_factory_make( "fakesink", NULL ), NULL );
 268
 269         mbFakeVideo = bFakeVideo;
 270
 271         rtl::OString ascURL = OUStringToOString( rURL, RTL_TEXTENCODING_ASCII_US );
 272         g_object_set( G_OBJECT( mpPlaybin ), "uri", ascURL.getStr() , NULL );
 273
 274         pBus = gst_element_get_bus( mpPlaybin );
 275         gst_bus_add_watch( pBus, gst_pipeline_bus_callback, this );
 276         DBG( "%p set sync handler", this );
 277         gst_bus_set_sync_handler( pBus, gst_pipeline_bus_sync_handler, this );
 278         g_object_unref( pBus );
 279 }
 280
 281 bool Player::create( const ::rtl::OUString& rURL )
 282 {
 283     bool    bRet = false;
 284
 285     // create all the elements and link them
 286
 287     if( mbInitialized )
 288     {
 289         preparePlaybin( rURL, true );
 290
 291         gst_element_set_state( mpPlaybin, GST_STATE_PAUSED );
 292         mbPlayPending = false;
 293
 294         bRet = true;
 295     }
 296
 297
 298     if( bRet )
 299         maURL = rURL;
 300     else
 301         maURL = ::rtl::OUString();
 302
 303     return bRet;
 304 }
 305
 306 // ------------------------------------------------------------------------------
 307
 308 void SAL_CALL Player::start(  )
 309     throw (uno::RuntimeException)
 310 {
 311     //DBG ("Player::start");
 312
 313     // set the pipeline state to READY and run the loop
 314     if( mbInitialized && NULL != mpPlaybin )
 315     {
 316         gst_element_set_state( mpPlaybin, GST_STATE_PLAYING );
 317         mbPlayPending = true;
 318     }
 319 }
 320
 321 // ------------------------------------------------------------------------------
 322
 323 void SAL_CALL Player::stop(  )
 324     throw (uno::RuntimeException)
 325 {
 326     // set the pipeline in PAUSED STATE
 327     if( mpPlaybin )
 328         gst_element_set_state( mpPlaybin, GST_STATE_PAUSED );
 329
 330     mbPlayPending = false;
 331     DBG( "stop %p", mpPlaybin );
 332 }
 333
 334 // ------------------------------------------------------------------------------
 335
 336 sal_Bool SAL_CALL Player::isPlaying()
 337     throw (uno::RuntimeException)
 338 {
 339     bool            bRet = mbPlayPending;
 340
 341     // return whether the pipeline is in PLAYING STATE or not
 342     if( !mbPlayPending && mbInitialized && mpPlaybin )
 343     {
 344         bRet = GST_STATE_PLAYING == GST_STATE( mpPlaybin );
 345     }
 346
 347     DBG( "isPlaying %d", bRet );
 348
 349     return bRet;
 350 }
 351
 352 // ------------------------------------------------------------------------------
 353
 354 double SAL_CALL Player::getDuration(  )
 355     throw (uno::RuntimeException)
 356 {
 357     // slideshow checks for non-zero duration, so cheat here
 358     double duration = 0.01;
 359
 360     if( mpPlaybin && mnDuration > 0 ) {
 361         duration = mnDuration / 1E9;
 362
 363         //DBG( "gst duration: %lld ns duration: %lf s", gst_duration, duration );
 364     }
 365
 366     return duration;
 367 }
 368
 369 // ------------------------------------------------------------------------------
 370
 371 void SAL_CALL Player::setMediaTime( double fTime )
 372     throw (uno::RuntimeException)
 373 {
 374     if( mpPlaybin ) {
 375         gint64 gst_position = llround (fTime * 1E9);
 376
 377         gst_element_seek( mpPlaybin, 1.0,
 378                           GST_FORMAT_TIME,
 379                           GST_SEEK_FLAG_FLUSH,
 380                           GST_SEEK_TYPE_SET, gst_position,
 381                           GST_SEEK_TYPE_NONE, 0 );
 382         if( !isPlaying() )
 383             gst_element_set_state( mpPlaybin, GST_STATE_PAUSED );
 384
 385         DBG( "seek to: %lld ns original: %lf s", gst_position, fTime );
 386     }
 387 }
 388
 389 // ------------------------------------------------------------------------------
 390
 391 double SAL_CALL Player::getMediaTime(  )
 392     throw (uno::RuntimeException)
 393 {
 394     double position = 0.0;
 395
 396     if( mpPlaybin ) {
 397         // get current position in the stream
 398         GstFormat format = GST_FORMAT_TIME;
 399         gint64 gst_position;
 400         if( gst_element_query_position( mpPlaybin, &format, &gst_position ) && format == GST_FORMAT_TIME && gst_position > 0L )
 401             position = gst_position / 1E9;
 402     }
 403
 404     return position;
 405 }
 406
 407 // ------------------------------------------------------------------------------
 408
 409 void SAL_CALL Player::setStopTime( double fTime )
 410     throw (uno::RuntimeException)
 411 {
 412     // TODO implement
 413 }
 414
 415 // ------------------------------------------------------------------------------
 416
 417 double SAL_CALL Player::getStopTime(  )
 418     throw (uno::RuntimeException)
 419 {
 420     // Get the time at which to stop
 421
 422     return 0;
 423 }
 424
 425 // ------------------------------------------------------------------------------
 426
 427 void SAL_CALL Player::setRate( double fRate )
 428     throw (uno::RuntimeException)
 429 {
 430     // TODO set the window rate
 431 }
 432
 433 // ------------------------------------------------------------------------------
 434
 435 double SAL_CALL Player::getRate(  )
 436     throw (uno::RuntimeException)
 437 {
 438     double rate = 0.0;
 439
 440     // TODO get the window rate
 441     if( mbInitialized )
 442     {
 443
 444     }
 445
 446     return rate;
 447 }
 448
 449 // ------------------------------------------------------------------------------
 450
 451 void SAL_CALL Player::setPlaybackLoop( sal_Bool bSet )
 452     throw (uno::RuntimeException)
 453 {
 454     // TODO check how to do with GST
 455     mbLooping = bSet;
 456 }
 457
 458 // ------------------------------------------------------------------------------
 459
 460 sal_Bool SAL_CALL Player::isPlaybackLoop(  )
 461     throw (uno::RuntimeException)
 462 {
 463     // TODO check how to do with GST
 464     return mbLooping;
 465 }
 466
 467 // ------------------------------------------------------------------------------
 468
 469 void SAL_CALL Player::setMute( sal_Bool bSet )
 470     throw (uno::RuntimeException)
 471 {
 472     DBG( "set mute: %d muted: %d unmuted volume: %lf", bSet, mbMuted, mnUnmutedVolume );
 473
 474     // change the volume to 0 or the unmuted volume
 475     if(  mpPlaybin && mbMuted != bSet )
 476     {
 477         double nVolume = mnUnmutedVolume;
 478         if( bSet )
 479         {
 480             nVolume = 0.0;
 481         }
 482
 483         g_object_set( G_OBJECT( mpPlaybin ), "volume", nVolume, NULL );
 484
 485         mbMuted = bSet;
 486     }
 487 }
 488
 489 // ------------------------------------------------------------------------------
 490
 491 sal_Bool SAL_CALL Player::isMute(  )
 492     throw (uno::RuntimeException)
 493 {
 494     return mbMuted;
 495 }
 496
 497 // ------------------------------------------------------------------------------
 498
 499 void SAL_CALL Player::setVolumeDB( sal_Int16 nVolumeDB )
 500     throw (uno::RuntimeException)
 501 {
 502     mnUnmutedVolume = pow( 10.0, nVolumeDB / 20.0 );
 503
 504     DBG( "set volume: %d gst volume: %lf", nVolumeDB, mnUnmutedVolume );
 505
 506     // change volume
 507      if( !mbMuted && mpPlaybin )
 508      {
 509          g_object_set( G_OBJECT( mpPlaybin ), "volume", (gdouble) mnUnmutedVolume, NULL );
 510      }
 511 }
 512
 513 // ------------------------------------------------------------------------------
 514
 515 sal_Int16 SAL_CALL Player::getVolumeDB(  )
 516     throw (uno::RuntimeException)
 517 {
 518     sal_Int16 nVolumeDB;
 519
 520     if( mpPlaybin ) {
 521         double nGstVolume = 0.0;
 522
 523         g_object_get( G_OBJECT( mpPlaybin ), "volume", &nGstVolume, NULL );
 524
 525         nVolumeDB = (sal_Int16) ( 20.0*log10 ( nGstVolume ) );
 526
 527         //DBG( "get volume: %d gst volume: %lf", nVolumeDB, nGstVolume );
 528     }
 529
 530     return nVolumeDB;
 531 }
 532
 533 // ------------------------------------------------------------------------------
 534
 535 awt::Size SAL_CALL Player::getPreferredPlayerWindowSize(  )
 536     throw (uno::RuntimeException)
 537 {
 538     awt::Size aSize( 0, 0 );
 539
 540     DBG( "%p Player::getPreferredPlayerWindowSize, member %d x %d", this, mnWidth, mnHeight );
 541
 542     TimeValue aTimeout = { 10, 0 };
 543     oslConditionResult aResult = osl_waitCondition( maSizeCondition, &aTimeout );
 544
 545     if( mbFakeVideo ) {
 546         mbFakeVideo = sal_False;
 547
 548          g_object_set( G_OBJECT( mpPlaybin ), "video-sink", NULL, NULL );
 549          gst_element_set_state( mpPlaybin, GST_STATE_READY );
 550          gst_element_set_state( mpPlaybin, GST_STATE_PAUSED );
 551     }
 552
 553     DBG( "%p Player::getPreferredPlayerWindowSize after waitCondition %d, member %d x %d", this, aResult, mnWidth, mnHeight );
 554
 555     if( mnWidth != 0 && mnHeight != 0 ) {
 556         aSize.Width = mnWidth;
 557         aSize.Height = mnHeight;
 558     }
 559
 560     return aSize;
 561 }
 562
 563 // ------------------------------------------------------------------------------
 564
 565 uno::Reference< ::media::XPlayerWindow > SAL_CALL Player::createPlayerWindow( const uno::Sequence< uno::Any >& rArguments )
 566     throw (uno::RuntimeException)
 567 {
 568     uno::Reference< ::media::XPlayerWindow >    xRet;
 569     awt::Size                                   aSize( getPreferredPlayerWindowSize() );
 570
 571     DBG( "Player::createPlayerWindow %d %d length: %d", aSize.Width, aSize.Height, rArguments.getLength() );
 572
 573     if( aSize.Width > 0 && aSize.Height > 0 )
 574     {
 575         ::avmedia::gstreamer::Window* pWindow = new ::avmedia::gstreamer::Window( mxMgr, *this );
 576
 577         xRet = pWindow;
 578
 579         if( rArguments.getLength() > 2 ) {
 580             rArguments[ 2 ] >>= mnWindowID;
 581             DBG( "window ID: %ld", mnWindowID );
 582         }
 583
 584         //if( !pWindow->create( aArguments ) )
 585         //xRet = uno::Reference< ::media::XPlayerWindow >();
 586     }
 587
 588     return xRet;
 589 }
 590
 591 // ------------------------------------------------------------------------------
 592
 593 uno::Reference< media::XFrameGrabber > SAL_CALL Player::createFrameGrabber(  )
 594     throw (uno::RuntimeException)
 595 {
 596     uno::Reference< media::XFrameGrabber > xRet;
 597
 598     /*if( maURL.getLength() > 0 )
 599     {
 600         FrameGrabber* pGrabber = new FrameGrabber( mxMgr );
 601
 602         xRet = pGrabber;
 603
 604         if( !pGrabber->create( maURL ) )
 605             xRet.clear();
 606             }*/
 607
 608     return xRet;
 609 }
 610
 611 // ------------------------------------------------------------------------------
 612
 613 ::rtl::OUString SAL_CALL Player::getImplementationName(  )
 614     throw (uno::RuntimeException)
 615 {
 616     return ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( AVMEDIA_GST_PLAYER_IMPLEMENTATIONNAME ) );
 617 }
 618
 619 // ------------------------------------------------------------------------------
 620
 621 sal_Bool SAL_CALL Player::supportsService( const ::rtl::OUString& ServiceName )
 622     throw (uno::RuntimeException)
 623 {
 624     return ServiceName.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM ( AVMEDIA_GST_PLAYER_SERVICENAME ) );
 625 }
 626
 627 // ------------------------------------------------------------------------------
 628
 629 uno::Sequence< ::rtl::OUString > SAL_CALL Player::getSupportedServiceNames(  )
 630     throw (uno::RuntimeException)
 631 {
 632     uno::Sequence< ::rtl::OUString > aRet(1);
 633     aRet[0] = ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM ( AVMEDIA_GST_PLAYER_SERVICENAME ) );
 634
 635     return aRet;
 636 }
 637
 638 } // namespace gstreamer
 639 } // namespace avmedia