1 /************************************************************** 2 * 3 * Licensed to the Apache Software Foundation (ASF) under one 4 * or more contributor license agreements. See the NOTICE file 5 * distributed with this work for additional information 6 * regarding copyright ownership. The ASF licenses this file 7 * to you under the Apache License, Version 2.0 (the 8 * "License"); you may not use this file except in compliance 9 * with the License. You may obtain a copy of the License at 10 * 11 * http://www.apache.org/licenses/LICENSE-2.0 12 * 13 * Unless required by applicable law or agreed to in writing, 14 * software distributed under the License is distributed on an 15 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY 16 * KIND, either express or implied. See the License for the 17 * specific language governing permissions and limitations 18 * under the License. 19 * 20 *************************************************************/ 21 22 23 24 #include "gstplayer.hxx" 25 #include "gstwindow.hxx" 26 #include "gstframegrabber.hxx" 27 #include <stdio.h> 28 #include <unistd.h> 29 #include <math.h> 30 #include <string> 31 #include <gst/gstelement.h> 32 #include <gst/interfaces/xoverlay.h> 33 34 35 // maximum timeout time in nanoseconds 36 #define GST_MAX_TIMEOUT (2500 * GST_MSECOND) 37 38 using namespace ::com::sun::star; 39 40 namespace avmedia 41 { 42 namespace gst 43 { 44 const double NANO_TIME_FACTOR = 1000000000.0; 45 46 const long VIDEO_DEFAULT_WIDTH = 256; 47 const long VIDEO_DEFAULT_HEIGHT = 192; 48 49 // ---------------- 50 // - GstBusSource - 51 // ---------------- 52 53 struct GstBusSource : public GSource 54 { 55 GstBus* mpBus; 56 57 GstBusSource() : 58 mpBus( NULL ) 59 {} 60 61 ~GstBusSource() 62 {} 63 }; 64 65 66 // ----------------------------------------------------------------------- 67 extern "C" 68 { 69 70 static gpointer 71 lcl_implThreadFunc( gpointer pData ) 72 { 73 return( pData ? static_cast< Player* >( pData )->run() : NULL ); 74 } 75 76 static gboolean 77 lcl_implBusCheck( GSource* pSource ) 78 { 79 GstBusSource* pBusSource = static_cast< GstBusSource* >( pSource ); 80 81 return( pBusSource && 82 GST_IS_BUS( pBusSource->mpBus ) && 83 gst_bus_have_pending( GST_BUS_CAST( pBusSource->mpBus ) ) ); 84 } 85 86 87 static gboolean 88 lcl_implBusPrepare( GSource* pSource, gint* pTimeout ) 89 { 90 if (pTimeout) 91 { 92 *pTimeout = 0; 93 } 94 95 return lcl_implBusCheck(pSource); 96 } 97 98 static gboolean 99 lcl_implBusDispatch( GSource* pSource, 100 GSourceFunc /*aCallback*/, 101 gpointer pData ) 102 { 103 GstBusSource* pBusSource = static_cast< GstBusSource* >( pSource ); 104 gboolean bRet = false; 105 106 if( pData && pBusSource && GST_IS_BUS( pBusSource->mpBus ) ) 107 { 108 GstMessage* pMsg = gst_bus_pop( pBusSource->mpBus ); 109 110 if( pMsg ) 111 { 112 bRet = static_cast< Player* >( pData )->busCallback( 113 pBusSource->mpBus, pMsg ); 114 gst_message_unref( pMsg ); 115 } 116 } 117 118 return( bRet ); 119 } 120 121 static void 122 lcl_implBusFinalize( GSource* pSource ) 123 { 124 GstBusSource* pBusSource = static_cast< GstBusSource* >( pSource ); 125 126 if( pBusSource && pBusSource->mpBus ) 127 { 128 gst_object_unref( pBusSource->mpBus ); 129 pBusSource->mpBus = NULL; 130 } 131 } 132 133 static gboolean 134 lcl_implIdleFunc( gpointer pData ) 135 { 136 return( pData ? static_cast< Player* >( pData )->idle() : true ); 137 } 138 139 static GstBusSyncReply 140 lcl_implHandleCreateWindowFunc( GstBus* pBus, GstMessage* pMsg, gpointer pData ) 141 { 142 return (pData) 143 ? static_cast< Player* >( pData )->handleCreateWindow( pBus, pMsg ) 144 : GST_BUS_PASS; 145 } 146 147 } // extern "C" 148 149 150 151 // --------------- 152 // - Player - 153 // --------------- 154 Player::Player( GString* pURI ) : 155 Player_BASE(m_aMutex), 156 mpMutex( g_mutex_new() ), 157 mpCond( g_cond_new() ), 158 mpThread( NULL ), 159 mpContext( NULL ), 160 mpLoop( NULL ), 161 mpPlayer( NULL ), 162 mpURI( pURI ), 163 mpPlayerWindow( NULL ), 164 mnIsVideoSource( 0 ), 165 mnVideoWidth( 0 ), 166 mnVideoHeight( 0 ), 167 mnInitialized( 0 ), 168 mnVolumeDB( 0 ), 169 mnLooping( 0 ), 170 mnQuit( 0 ), 171 mnVideoWindowSet( 0 ), 172 mnInitFail( 0 ) 173 { 174 // initialize GStreamer framework only once 175 static bool bGstInitialized = false; 176 177 if( !bGstInitialized ) 178 { 179 gst_init( NULL, NULL ); 180 bGstInitialized = true; 181 } 182 183 if( pURI ) 184 { 185 OSL_TRACE( ">>> --------------------------------" ); 186 OSL_TRACE( ">>> Creating Player object with URL: %s", pURI->str ); 187 188 mpThread = g_thread_create( &lcl_implThreadFunc, this, true, NULL ); 189 } 190 } 191 192 // ------------------------------------------------------------------------------ 193 194 Player::~Player() 195 { 196 if( g_atomic_pointer_get( &mpPlayer ) ) 197 { 198 implQuitThread(); 199 } 200 201 // cleanup 202 g_cond_free( mpCond ); 203 g_mutex_free( mpMutex ); 204 g_string_free( mpURI, false ); 205 } 206 207 // ------------------------------------------------------------------------------ 208 Player* Player::create( const ::rtl::OUString& rURL ) 209 { 210 Player* pPlayer = NULL; 211 212 if( rURL.getLength() ) 213 { 214 // safely initialize GLib threading framework 215 try 216 { 217 if( !g_thread_supported() ) 218 { 219 g_thread_init( NULL ); 220 } 221 } 222 catch( ... ) 223 {} 224 225 if( g_thread_supported() ) 226 { 227 const INetURLObject aURL( rURL ); 228 229 if( aURL.GetProtocol() != INET_PROT_NOT_VALID ) 230 { 231 GString* pURI = g_string_new( ::rtl::OUStringToOString( 232 aURL.GetMainURL( INetURLObject::NO_DECODE ), 233 RTL_TEXTENCODING_UTF8 ).getStr() ); 234 235 if( pURI->len ) 236 { 237 pPlayer = new Player( pURI ); 238 239 // wait until thread signals that it has finished initialization 240 if( pPlayer->mpThread ) 241 { 242 g_mutex_lock( pPlayer->mpMutex ); 243 244 while( !pPlayer->implIsInitialized() ) 245 { 246 g_cond_wait( pPlayer->mpCond, pPlayer->mpMutex ); 247 } 248 249 g_mutex_unlock( pPlayer->mpMutex ); 250 } 251 252 // check if player pipeline could be initialized 253 if( !pPlayer->mpPlayer ) 254 { 255 delete pPlayer; 256 pPlayer = NULL; 257 } 258 } 259 else 260 { 261 g_string_free( pURI, false ); 262 } 263 } 264 } 265 } 266 267 return( pPlayer ); 268 } 269 270 // ------------------------------------------------------------------------------ 271 void SAL_CALL Player::start() 272 throw( uno::RuntimeException ) 273 { 274 ::osl::MutexGuard aGuard(m_aMutex); 275 if( implInitPlayer() && !isPlaying() ) 276 { 277 gst_element_set_state( mpPlayer, GST_STATE_PLAYING ); 278 } 279 } 280 281 // ------------------------------------------------------------------------------ 282 void SAL_CALL Player::stop() 283 throw( uno::RuntimeException ) 284 { 285 ::osl::MutexGuard aGuard(m_aMutex); 286 if( implInitPlayer() && isPlaying() ) 287 { 288 gst_element_set_state( mpPlayer, GST_STATE_PAUSED ); 289 } 290 } 291 292 // ------------------------------------------------------------------------------ 293 sal_Bool SAL_CALL Player::isPlaying() 294 throw( uno::RuntimeException ) 295 { 296 GstState aState = GST_STATE_NULL; 297 ::osl::MutexGuard aGuard(m_aMutex); 298 if( mpPlayer ) 299 { 300 gst_element_get_state( mpPlayer, &aState, NULL, GST_MAX_TIMEOUT ); 301 } 302 303 return( GST_STATE_PLAYING == aState ); 304 } 305 306 // ------------------------------------------------------------------------------ 307 double SAL_CALL Player::getDuration() 308 throw( uno::RuntimeException ) 309 { 310 ::osl::MutexGuard aGuard(m_aMutex); 311 gint64 nDuration = 0; 312 313 if( implInitPlayer() ) 314 { 315 GstFormat aFormat = GST_FORMAT_TIME; 316 317 if( !gst_element_query_duration( mpPlayer, &aFormat, &nDuration ) || 318 ( GST_FORMAT_TIME != aFormat ) || 319 ( nDuration < 0 ) ) 320 { 321 nDuration = 0; 322 } 323 } 324 325 return( static_cast< double >( nDuration ) / NANO_TIME_FACTOR ); 326 } 327 328 // ------------------------------------------------------------------------------ 329 void SAL_CALL Player::setMediaTime( double fTime ) 330 throw( uno::RuntimeException ) 331 { 332 ::osl::MutexGuard aGuard(m_aMutex); 333 if( implInitPlayer() ) 334 { 335 fTime = ::std::min( ::std::max( fTime, 0.0 ), getDuration() ); 336 337 gst_element_seek_simple( mpPlayer, GST_FORMAT_TIME, 338 (GstSeekFlags) ( GST_SEEK_FLAG_FLUSH | GST_SEEK_FLAG_KEY_UNIT ), 339 static_cast< gint64 >( fTime * NANO_TIME_FACTOR ) ); 340 } 341 } 342 343 // ------------------------------------------------------------------------------ 344 double SAL_CALL Player::getMediaTime() 345 throw( uno::RuntimeException ) 346 { 347 double fRet = 0.0; 348 ::osl::MutexGuard aGuard(m_aMutex); 349 if( implInitPlayer() ) 350 { 351 GstFormat aFormat = GST_FORMAT_TIME; 352 gint64 nCurTime = 0; 353 354 if( gst_element_query_position( mpPlayer, &aFormat, &nCurTime ) && 355 ( GST_FORMAT_TIME == aFormat ) && 356 ( nCurTime >= 0 ) ) 357 { 358 fRet = static_cast< double >( nCurTime ) / NANO_TIME_FACTOR; 359 } 360 } 361 362 return( fRet ); 363 } 364 365 // ------------------------------------------------------------------------------ 366 void SAL_CALL Player::setStopTime( double /* fTime */ ) 367 throw( uno::RuntimeException ) 368 { 369 OSL_TRACE( "GStreamer method avmedia::gst::Player::setStopTime needs to be implemented" ); 370 371 /* Currently no need for implementation since higher levels of code don't use this method at all 372 !!! TODO: needs to be implemented if this functionality is needed at a later point of time 373 if( implInitPlayer() ) 374 { 375 } 376 377 */ 378 } 379 380 // ------------------------------------------------------------------------------ 381 double SAL_CALL Player::getStopTime() 382 throw( uno::RuntimeException ) 383 { 384 /* 385 Currently no need for implementation since higher levels of code don't set a stop time ATM 386 !!! TODO: needs to be fully implemented if this functionality is needed at a later point of time 387 */ 388 ::osl::MutexGuard aGuard(m_aMutex); 389 return( getDuration() ); 390 } 391 392 // ------------------------------------------------------------------------------ 393 void SAL_CALL Player::setRate( double /* fRate */ ) 394 throw( uno::RuntimeException ) 395 { 396 OSL_TRACE( "GStreamer method avmedia::gst::Player::setRate needs to be implemented" ); 397 398 /* Currently no need for implementation since higher levels of code don't use this method at all 399 !!! TODO: needs to be implemented if this functionality is needed at a later point of time 400 */ 401 } 402 403 // ------------------------------------------------------------------------------ 404 double SAL_CALL Player::getRate() 405 throw( uno::RuntimeException ) 406 { 407 /* 408 Currently no need for implementation since higher levels of code don't set a different rate than 1 ATM 409 !!! TODO: needs to be fully implemented if this functionality is needed at a later point of time 410 */ 411 412 return( 1.0 ); 413 } 414 415 // ------------------------------------------------------------------------------ 416 void SAL_CALL Player::setPlaybackLoop( sal_Bool bSet ) 417 throw( uno::RuntimeException ) 418 { 419 ::osl::MutexGuard aGuard(m_aMutex); 420 if (bSet) 421 { 422 g_atomic_int_compare_and_exchange(&mnLooping, 0, 1); 423 } 424 else 425 { 426 g_atomic_int_compare_and_exchange(&mnLooping, 1, 0); 427 } 428 } 429 430 // ------------------------------------------------------------------------------ 431 sal_Bool SAL_CALL Player::isPlaybackLoop() 432 throw( uno::RuntimeException ) 433 { 434 ::osl::MutexGuard aGuard(m_aMutex); 435 return( g_atomic_int_get( &mnLooping ) > 0 ); 436 } 437 438 // ------------------------------------------------------------------------------ 439 void SAL_CALL Player::setMute( sal_Bool bSet ) 440 throw( uno::RuntimeException ) 441 { 442 ::osl::MutexGuard aGuard(m_aMutex); 443 if( implInitPlayer() && ( bSet != isMute() ) ) 444 { 445 if( bSet ) 446 { 447 g_object_set( mpPlayer, "volume", 0.0, NULL ); 448 } 449 else 450 { 451 setVolumeDB( mnVolumeDB ); 452 } 453 } 454 } 455 456 // ------------------------------------------------------------------------------ 457 sal_Bool SAL_CALL Player::isMute() 458 throw( uno::RuntimeException ) 459 { 460 gdouble fGstVolume = 1.0; 461 ::osl::MutexGuard aGuard(m_aMutex); 462 463 if( implInitPlayer() ) 464 { 465 g_object_get( mpPlayer, "volume", &fGstVolume, NULL ); 466 } 467 468 return( 0.0 == fGstVolume ); 469 } 470 471 // ------------------------------------------------------------------------------ 472 void SAL_CALL Player::setVolumeDB( sal_Int16 nVolumeDB ) 473 throw( uno::RuntimeException ) 474 { 475 ::osl::MutexGuard aGuard(m_aMutex); 476 if( implInitPlayer() ) 477 { 478 g_mutex_lock( mpMutex ); 479 mnVolumeDB = nVolumeDB; 480 g_mutex_unlock( mpMutex ); 481 482 // maximum gain for gstreamer volume is 10 483 double fGstVolume = pow( 10.0, static_cast< double >( ::std::min( 484 nVolumeDB, static_cast< sal_Int16 >( 20 ) ) / 20.0 ) ); 485 486 g_object_set( mpPlayer, "volume", fGstVolume, NULL ); 487 } 488 } 489 490 // ------------------------------------------------------------------------------ 491 sal_Int16 SAL_CALL Player::getVolumeDB() 492 throw( uno::RuntimeException ) 493 { 494 ::osl::MutexGuard aGuard(m_aMutex); 495 return( static_cast< sal_Int16 >( g_atomic_int_get( &mnVolumeDB ) ) ); 496 } 497 498 // ------------------------------------------------------------------------------ 499 awt::Size SAL_CALL Player::getPreferredPlayerWindowSize() 500 throw( uno::RuntimeException ) 501 { 502 awt::Size aSize( 0, 0 ); 503 ::osl::MutexGuard aGuard(m_aMutex); 504 505 if( implInitPlayer() && ( g_atomic_int_get( &mnIsVideoSource ) > 0 ) ) 506 { 507 aSize.Width = g_atomic_int_get( &mnVideoWidth ); 508 aSize.Height = g_atomic_int_get( &mnVideoHeight ); 509 510 // if we have a video source, but no size is given => use default size 511 if( ( aSize.Width <= 0 ) || ( aSize.Height <= 0 ) ) 512 { 513 aSize.Width = VIDEO_DEFAULT_WIDTH; 514 aSize.Height = VIDEO_DEFAULT_HEIGHT; 515 } 516 } 517 518 OSL_TRACE( ">>> Requested preferred video size is: %d x %d pixel", aSize.Width, aSize.Height ); 519 520 return( aSize ); 521 } 522 523 // ------------------------------------------------------------------------------ 524 uno::Reference< ::media::XPlayerWindow > SAL_CALL Player::createPlayerWindow( 525 const uno::Sequence< uno::Any >& rArguments ) 526 throw( uno::RuntimeException ) 527 { 528 ::osl::MutexGuard aGuard(m_aMutex); 529 uno::Reference< ::media::XPlayerWindow > xRet; 530 awt::Size aSize( getPreferredPlayerWindowSize() ); 531 532 OSL_ENSURE( !g_atomic_pointer_get( &mpPlayerWindow ), "::avmedia::gst::Player already has a player window" ); 533 534 if( ( aSize.Width > 0 ) && ( aSize.Height > 0 ) ) 535 { 536 Window* pPlayerWindow = new Window( *this ); 537 538 xRet = pPlayerWindow; 539 540 if( !pPlayerWindow->create( rArguments ) ) 541 { 542 xRet.clear(); 543 } 544 else 545 { 546 // try to use gconf user configurable video sink first 547 GstElement* pVideoSink = gst_element_factory_make( "gconfvideosink", NULL ); 548 549 if( ( NULL != pVideoSink ) || 550 ( NULL != ( pVideoSink = gst_element_factory_make( "autovideosink", NULL ) ) ) || 551 ( NULL != ( pVideoSink = gst_element_factory_make( "xvimagesink", NULL ) ) ) || 552 ( NULL != ( pVideoSink = gst_element_factory_make( "ximagesink", NULL ) ) ) ) 553 { 554 GstState aOldState = GST_STATE_NULL; 555 556 mpPlayerWindow = pPlayerWindow; 557 gst_element_get_state( mpPlayer, &aOldState, NULL, GST_MAX_TIMEOUT ); 558 gst_element_set_state( mpPlayer, GST_STATE_READY ); 559 g_object_set( mpPlayer, "video-sink", pVideoSink, NULL ); 560 gst_element_set_state( mpPlayer, aOldState ); 561 } 562 } 563 } 564 565 return( xRet ); 566 } 567 568 // ------------------------------------------------------------------------------ 569 uno::Reference< media::XFrameGrabber > SAL_CALL Player::createFrameGrabber() 570 throw( ::com::sun::star::uno::RuntimeException ) 571 { 572 ::osl::MutexGuard aGuard(m_aMutex); 573 FrameGrabber* pFrameGrabber = NULL; 574 const awt::Size aPrefSize( getPreferredPlayerWindowSize() ); 575 576 if( ( aPrefSize.Width > 0 ) && ( aPrefSize.Height > 0 ) ) 577 { 578 pFrameGrabber = FrameGrabber::create( mpURI ); 579 } 580 581 return( pFrameGrabber ); 582 } 583 584 // ------------------------------------------------------------------------------ 585 void SAL_CALL Player::disposing() 586 { 587 ::osl::MutexGuard aGuard(m_aMutex); 588 if( mpPlayer ) 589 { 590 stop(); 591 implQuitThread(); 592 } 593 594 OSL_ASSERT( NULL == mpPlayer ); 595 } 596 597 // ------------------------------------------------------------------------------ 598 ::rtl::OUString SAL_CALL Player::getImplementationName() 599 throw( uno::RuntimeException ) 600 { 601 return( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( AVMEDIA_GSTREAMER_PLAYER_IMPLEMENTATIONNAME ) ) ); 602 } 603 604 // ------------------------------------------------------------------------------ 605 sal_Bool SAL_CALL Player::supportsService( const ::rtl::OUString& ServiceName ) 606 throw( uno::RuntimeException ) 607 { 608 return( ServiceName.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM( AVMEDIA_GSTREAMER_PLAYER_SERVICENAME ) ) ); 609 } 610 611 // ------------------------------------------------------------------------------ 612 uno::Sequence< ::rtl::OUString > SAL_CALL Player::getSupportedServiceNames() 613 throw( uno::RuntimeException ) 614 { 615 uno::Sequence< ::rtl::OUString > aRet( 1 ); 616 aRet[ 0 ] = ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( AVMEDIA_GSTREAMER_PLAYER_SERVICENAME ) ); 617 618 return( aRet ); 619 } 620 621 // ------------------------------------------------------------------------------ 622 void Player::implQuitThread() 623 { 624 if( mpThread ) 625 { 626 // set quit flag to 1 so that the main loop will be quit in idle 627 // handler the next time it is called from the thread's main loop 628 g_atomic_int_inc( &mnQuit ); 629 630 // wait until loop and as such the thread has quit 631 g_thread_join( mpThread ); 632 mpThread = NULL; 633 } 634 } 635 636 // ------------------------------------------------------------------------------ 637 bool Player::implInitPlayer() 638 { 639 bool bRet = false; 640 641 if( mpPlayer && (mnInitFail < 3) ) 642 { 643 GstState aState = GST_STATE_NULL; 644 645 if( gst_element_get_state( mpPlayer, &aState, NULL, GST_MAX_TIMEOUT ) == GST_STATE_CHANGE_SUCCESS ) 646 { 647 bRet = ( GST_STATE_PAUSED == aState ) || ( GST_STATE_PLAYING == aState ); 648 649 if( !bRet ) 650 { 651 gst_element_set_state( mpPlayer, GST_STATE_PAUSED ); 652 bRet = ( gst_element_get_state( mpPlayer, &aState, NULL, 653 GST_MAX_TIMEOUT ) == GST_STATE_CHANGE_SUCCESS ) && 654 ( GST_STATE_PAUSED == aState ); 655 } 656 } 657 658 if( ! bRet ) 659 mnInitFail++; 660 } 661 662 return( bRet ); 663 } 664 665 // ------------------------------------------------------------------------------ 666 gboolean Player::busCallback( GstBus* /*pBus*/, 667 GstMessage* pMsg ) 668 { 669 if( pMsg && mpLoop ) 670 { 671 switch( GST_MESSAGE_TYPE( pMsg ) ) 672 { 673 case ( GST_MESSAGE_EOS ): 674 { 675 if( g_atomic_int_get( &mnLooping ) > 0 ) 676 { 677 setMediaTime( 0.0 ); 678 start(); 679 } 680 else 681 { 682 stop(); 683 } 684 } 685 break; 686 687 case ( GST_MESSAGE_ERROR ): 688 { 689 gchar* pDebug; 690 GError* pErr; 691 692 gst_message_parse_error( pMsg, &pErr, &pDebug ); 693 fprintf( stderr, "Error: %s\n", pErr->message ); 694 695 g_free( pDebug ); 696 g_error_free( pErr ); 697 } 698 break; 699 700 default: 701 { 702 break; 703 } 704 } 705 } 706 707 return( true ); 708 } 709 710 // ------------------------------------------------------------------------------ 711 void Player::implHandleNewElementFunc( GstBin* /* pBin */, 712 GstElement* pElement, 713 gpointer pData ) 714 { 715 if( pElement ) 716 { 717 #ifdef DEBUG 718 gchar* pElementName = gst_element_get_name( pElement ); 719 720 if( pElementName ) 721 { 722 OSL_TRACE( ">>> Bin has element: %s", pElementName ); 723 g_free( pElementName ); 724 } 725 #endif 726 727 if( GST_IS_BIN( pElement ) ) 728 { 729 // set this handler in case we have a GstBin element 730 g_signal_connect( GST_BIN( pElement ), "element-added", 731 G_CALLBACK( Player::implHandleNewElementFunc ), pData ); 732 } 733 734 // watch for all pads that are going to be added to this element; 735 g_signal_connect( pElement, "pad-added", 736 G_CALLBACK( Player::implHandleNewPadFunc ), pData ); 737 } 738 } 739 740 // ------------------------------------------------------------------------------ 741 void Player::implHandleNewPadFunc( GstElement* pElement, 742 GstPad* pPad, 743 gpointer pData ) 744 { 745 Player* pPlayer = static_cast< Player* >( pData ); 746 747 if( pPlayer && pElement && pPad ) 748 { 749 #ifdef DEBUG 750 gchar* pElementName = gst_element_get_name( pElement ); 751 gchar* pPadName = gst_pad_get_name( pPad ); 752 753 OSL_TRACE( ">>> Element %s has pad: %s", pElementName, pPadName ); 754 755 g_free( pPadName ); 756 g_free( pElementName ); 757 #endif 758 759 GstCaps* pCaps = gst_pad_get_caps( pPad ); 760 761 // we are interested only in getting video properties 762 // width and height or if we have a video source at all 763 if( pCaps ) 764 { 765 for( gint i = 0, nSize = gst_caps_get_size( pCaps ); i < nSize; ++i ) 766 { 767 const GstStructure* pStruct = gst_caps_get_structure( pCaps, i ); 768 769 if( pStruct ) 770 { 771 const gchar* pStructName = gst_structure_get_name( pStruct ); 772 773 #ifdef DEBUG 774 OSL_TRACE( "\t>>> Pad has structure: %s", pStructName ); 775 776 for( gint n = 0, nFields = gst_structure_n_fields( pStruct ); n < nFields; ++n ) 777 { 778 OSL_TRACE( "\t\t>>> Structure has field: %s", gst_structure_nth_field_name( pStruct, n ) ); 779 } 780 #endif 781 782 // just look for structures having 'video' in their names 783 if( ::std::string( pStructName ).find( "video" ) != ::std::string::npos ) 784 { 785 g_atomic_int_inc( &pPlayer->mnIsVideoSource ); 786 787 for( gint n = 0, nFields = gst_structure_n_fields( pStruct ); n < nFields; ++n ) 788 { 789 const gchar* pFieldName = gst_structure_nth_field_name( pStruct, n ); 790 gint nValue; 791 792 if( ( ::std::string( pFieldName ).find( "width" ) != ::std::string::npos ) && 793 gst_structure_get_int( pStruct, pFieldName, &nValue ) ) 794 { 795 const gint nDiff = nValue - g_atomic_int_get( &pPlayer->mnVideoWidth ); 796 g_atomic_int_add( &pPlayer->mnVideoWidth, ::std::max( nDiff, 0 ) ); 797 } 798 else if( ( ::std::string( pFieldName ).find( "height" ) != ::std::string::npos ) && 799 gst_structure_get_int( pStruct, pFieldName, &nValue ) ) 800 { 801 const gint nDiff = nValue - g_atomic_int_get( &pPlayer->mnVideoHeight ); 802 g_atomic_int_add( &pPlayer->mnVideoHeight, ::std::max( nDiff, 0 ) ); 803 } 804 } 805 } 806 } 807 } 808 809 gst_caps_unref( pCaps ); 810 } 811 } 812 } 813 814 // ------------------------------------------------------------------------------ 815 gboolean Player::idle() 816 { 817 // test if main loop should quit by comparing with 1 818 // and set flag mnQuit to 0 so we call g_main_loop_quit exactly once 819 bool const bQuit = g_atomic_int_compare_and_exchange( &mnQuit, 1, 0 ); 820 821 if( bQuit ) 822 { 823 g_main_loop_quit( mpLoop ); 824 } 825 826 // don't eat up all cpu time 827 usleep( 1000 ); 828 829 return( true ); 830 } 831 832 // ------------------------------------------------------------------------------ 833 gpointer Player::run() 834 { 835 static GSourceFuncs aSourceFuncs = 836 { 837 &lcl_implBusPrepare, 838 &lcl_implBusCheck, 839 &lcl_implBusDispatch, 840 &lcl_implBusFinalize, 841 NULL, 842 NULL 843 }; 844 845 if( NULL != ( mpPlayer = gst_element_factory_make( "playbin", NULL ) ) ) 846 { 847 // initialization 848 // no mutex necessary since initialization 849 // is synchronous until loop is started 850 mpContext = g_main_context_new(); 851 mpLoop = g_main_loop_new( mpContext, false ); 852 853 // add idle callback 854 GSource* pIdleSource = g_idle_source_new(); 855 g_source_set_callback( pIdleSource, &lcl_implIdleFunc, this, NULL ); 856 g_source_attach( pIdleSource, mpContext ); 857 858 // add bus callback 859 GSource* pBusSource = g_source_new( &aSourceFuncs, sizeof( GstBusSource ) ); 860 static_cast< GstBusSource* >( pBusSource )->mpBus = gst_pipeline_get_bus( GST_PIPELINE( mpPlayer ) ); 861 g_source_set_callback( pBusSource, NULL, this, NULL ); 862 g_source_attach( pBusSource, mpContext ); 863 864 // add bus sync handler to intercept video window creation for setting our own window 865 gst_bus_set_sync_handler( static_cast< GstBusSource* >( pBusSource )->mpBus, 866 &lcl_implHandleCreateWindowFunc, this ); 867 868 // watch for all elements (and pads) that will be added to the playbin, 869 // in order to retrieve properties like video width and height 870 g_signal_connect( GST_BIN( mpPlayer ), "element-added", 871 G_CALLBACK( Player::implHandleNewElementFunc ), this ); 872 873 // set source URI for player 874 g_object_set( mpPlayer, "uri", mpURI->str, NULL ); 875 876 // set video fake sink first, since we only create a player without window here 877 // and don't want to have the gstreamer default window appearing 878 g_object_set( mpPlayer, "video-sink", gst_element_factory_make( "fakesink", NULL ), NULL ); 879 880 // set state of player to READY or destroy object in case of FAILURE 881 if( gst_element_set_state( mpPlayer, GST_STATE_READY ) == GST_STATE_CHANGE_FAILURE ) 882 { 883 gst_object_unref( mpPlayer ); 884 mpPlayer = NULL; 885 } 886 887 g_atomic_int_add( &mnInitialized, 1 ); 888 g_cond_signal( mpCond ); 889 890 // run the main loop 891 g_main_loop_run( mpLoop ); 892 893 // clenanup 894 // no mutex necessary since other thread joined us (this thread) 895 // after setting the quit flag 896 if( mpPlayer ) 897 { 898 gst_element_set_state( mpPlayer, GST_STATE_NULL ); 899 gst_object_unref( mpPlayer ); 900 mpPlayer = NULL; 901 } 902 903 g_main_loop_unref( mpLoop ); 904 mpLoop = NULL; 905 906 g_source_destroy( pBusSource ); 907 g_source_unref( pBusSource ); 908 909 g_source_destroy( pIdleSource ); 910 g_source_unref( pIdleSource ); 911 912 g_main_context_unref( mpContext ); 913 mpContext = NULL; 914 } 915 else 916 { 917 g_atomic_int_add( &mnInitialized, 1 ); 918 g_cond_signal( mpCond ); 919 } 920 921 return( NULL ); 922 } 923 924 // ------------------------------------------------------------------------------ 925 GstBusSyncReply Player::handleCreateWindow( GstBus* /* pBus */, 926 GstMessage* pMsg ) 927 { 928 GstBusSyncReply eRet = GST_BUS_PASS; 929 930 if( pMsg && 931 ( GST_MESSAGE_TYPE( pMsg ) == GST_MESSAGE_ELEMENT ) && 932 gst_structure_has_name( pMsg->structure, "prepare-xwindow-id" ) && 933 g_atomic_pointer_get( &mpPlayerWindow ) ) 934 { 935 OSL_TRACE( ">>> Got Request to create XOverlay" ); 936 937 gst_x_overlay_set_xwindow_id( GST_X_OVERLAY( GST_MESSAGE_SRC( pMsg ) ), 938 static_cast< Window* >( g_atomic_pointer_get( 939 &mpPlayerWindow ) )->getXWindowHandle() ); 940 941 gst_message_unref( pMsg ); 942 eRet = GST_BUS_DROP; 943 } 944 945 return( eRet ); 946 } 947 } // namespace gst 948 } // namespace avmedia 949