| /************************************************************** |
| * |
| * Licensed to the Apache Software Foundation (ASF) under one |
| * or more contributor license agreements. See the NOTICE file |
| * distributed with this work for additional information |
| * regarding copyright ownership. The ASF licenses this file |
| * to you under the Apache License, Version 2.0 (the |
| * "License"); you may not use this file except in compliance |
| * with the License. You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, |
| * software distributed under the License is distributed on an |
| * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY |
| * KIND, either express or implied. See the License for the |
| * specific language governing permissions and limitations |
| * under the License. |
| * |
| *************************************************************/ |
| |
| |
| |
| #include "gstplayer.hxx" |
| #include "gstwindow.hxx" |
| #include "gstframegrabber.hxx" |
| #include <stdio.h> |
| #include <unistd.h> |
| #include <math.h> |
| #include <string> |
| #include <gst/gstelement.h> |
| #include <gst/interfaces/xoverlay.h> |
| |
| |
| // maximum timeout time in nanoseconds |
| #define GST_MAX_TIMEOUT (2500 * GST_MSECOND) |
| |
| using namespace ::com::sun::star; |
| |
| namespace avmedia |
| { |
| namespace gst |
| { |
| const double NANO_TIME_FACTOR = 1000000000.0; |
| |
| const long VIDEO_DEFAULT_WIDTH = 256; |
| const long VIDEO_DEFAULT_HEIGHT = 192; |
| |
| // ---------------- |
| // - GstBusSource - |
| // ---------------- |
| |
| struct GstBusSource : public GSource |
| { |
| GstBus* mpBus; |
| |
| GstBusSource() : |
| mpBus( NULL ) |
| {} |
| |
| ~GstBusSource() |
| {} |
| }; |
| |
| |
| // ----------------------------------------------------------------------- |
| extern "C" |
| { |
| |
| static gpointer |
| lcl_implThreadFunc( gpointer pData ) |
| { |
| return( pData ? static_cast< Player* >( pData )->run() : NULL ); |
| } |
| |
| static gboolean |
| lcl_implBusCheck( GSource* pSource ) |
| { |
| GstBusSource* pBusSource = static_cast< GstBusSource* >( pSource ); |
| |
| return( pBusSource && |
| GST_IS_BUS( pBusSource->mpBus ) && |
| gst_bus_have_pending( GST_BUS_CAST( pBusSource->mpBus ) ) ); |
| } |
| |
| |
| static gboolean |
| lcl_implBusPrepare( GSource* pSource, gint* pTimeout ) |
| { |
| if (pTimeout) |
| { |
| *pTimeout = 0; |
| } |
| |
| return lcl_implBusCheck(pSource); |
| } |
| |
| static gboolean |
| lcl_implBusDispatch( GSource* pSource, |
| GSourceFunc /*aCallback*/, |
| gpointer pData ) |
| { |
| GstBusSource* pBusSource = static_cast< GstBusSource* >( pSource ); |
| gboolean bRet = false; |
| |
| if( pData && pBusSource && GST_IS_BUS( pBusSource->mpBus ) ) |
| { |
| GstMessage* pMsg = gst_bus_pop( pBusSource->mpBus ); |
| |
| if( pMsg ) |
| { |
| bRet = static_cast< Player* >( pData )->busCallback( |
| pBusSource->mpBus, pMsg ); |
| gst_message_unref( pMsg ); |
| } |
| } |
| |
| return( bRet ); |
| } |
| |
| static void |
| lcl_implBusFinalize( GSource* pSource ) |
| { |
| GstBusSource* pBusSource = static_cast< GstBusSource* >( pSource ); |
| |
| if( pBusSource && pBusSource->mpBus ) |
| { |
| gst_object_unref( pBusSource->mpBus ); |
| pBusSource->mpBus = NULL; |
| } |
| } |
| |
| static gboolean |
| lcl_implIdleFunc( gpointer pData ) |
| { |
| return( pData ? static_cast< Player* >( pData )->idle() : true ); |
| } |
| |
| static GstBusSyncReply |
| lcl_implHandleCreateWindowFunc( GstBus* pBus, GstMessage* pMsg, gpointer pData ) |
| { |
| return (pData) |
| ? static_cast< Player* >( pData )->handleCreateWindow( pBus, pMsg ) |
| : GST_BUS_PASS; |
| } |
| |
| } // extern "C" |
| |
| |
| |
| // --------------- |
| // - Player - |
| // --------------- |
| Player::Player( GString* pURI ) : |
| Player_BASE(m_aMutex), |
| mpMutex( g_mutex_new() ), |
| mpCond( g_cond_new() ), |
| mpThread( NULL ), |
| mpContext( NULL ), |
| mpLoop( NULL ), |
| mpPlayer( NULL ), |
| mpURI( pURI ), |
| mpPlayerWindow( NULL ), |
| mnIsVideoSource( 0 ), |
| mnVideoWidth( 0 ), |
| mnVideoHeight( 0 ), |
| mnInitialized( 0 ), |
| mnVolumeDB( 0 ), |
| mnLooping( 0 ), |
| mnQuit( 0 ), |
| mnVideoWindowSet( 0 ), |
| mnInitFail( 0 ) |
| { |
| // initialize GStreamer framework only once |
| static bool bGstInitialized = false; |
| |
| if( !bGstInitialized ) |
| { |
| gst_init( NULL, NULL ); |
| bGstInitialized = true; |
| } |
| |
| if( pURI ) |
| { |
| OSL_TRACE( ">>> --------------------------------" ); |
| OSL_TRACE( ">>> Creating Player object with URL: %s", pURI->str ); |
| |
| mpThread = g_thread_create( &lcl_implThreadFunc, this, true, NULL ); |
| } |
| } |
| |
| // ------------------------------------------------------------------------------ |
| |
| Player::~Player() |
| { |
| if( g_atomic_pointer_get( &mpPlayer ) ) |
| { |
| implQuitThread(); |
| } |
| |
| // cleanup |
| g_cond_free( mpCond ); |
| g_mutex_free( mpMutex ); |
| g_string_free( mpURI, false ); |
| } |
| |
| // ------------------------------------------------------------------------------ |
| Player* Player::create( const ::rtl::OUString& rURL ) |
| { |
| Player* pPlayer = NULL; |
| |
| if( !rURL.isEmpty() ) |
| { |
| // safely initialize GLib threading framework |
| try |
| { |
| if( !g_thread_supported() ) |
| { |
| g_thread_init( NULL ); |
| } |
| } |
| catch( ... ) |
| {} |
| |
| if( g_thread_supported() ) |
| { |
| const INetURLObject aURL( rURL ); |
| |
| if( aURL.GetProtocol() != INET_PROT_NOT_VALID ) |
| { |
| GString* pURI = g_string_new( ::rtl::OUStringToOString( |
| aURL.GetMainURL( INetURLObject::NO_DECODE ), |
| RTL_TEXTENCODING_UTF8 ).getStr() ); |
| |
| if( pURI->len ) |
| { |
| pPlayer = new Player( pURI ); |
| |
| // wait until thread signals that it has finished initialization |
| if( pPlayer->mpThread ) |
| { |
| g_mutex_lock( pPlayer->mpMutex ); |
| |
| while( !pPlayer->implIsInitialized() ) |
| { |
| g_cond_wait( pPlayer->mpCond, pPlayer->mpMutex ); |
| } |
| |
| g_mutex_unlock( pPlayer->mpMutex ); |
| } |
| |
| // check if player pipeline could be initialized |
| if( !pPlayer->mpPlayer ) |
| { |
| delete pPlayer; |
| pPlayer = NULL; |
| } |
| } |
| else |
| { |
| g_string_free( pURI, false ); |
| } |
| } |
| } |
| } |
| |
| return( pPlayer ); |
| } |
| |
| // ------------------------------------------------------------------------------ |
| void SAL_CALL Player::start() |
| throw( uno::RuntimeException ) |
| { |
| ::osl::MutexGuard aGuard(m_aMutex); |
| if( implInitPlayer() && !isPlaying() ) |
| { |
| gst_element_set_state( mpPlayer, GST_STATE_PLAYING ); |
| } |
| } |
| |
| // ------------------------------------------------------------------------------ |
| void SAL_CALL Player::stop() |
| throw( uno::RuntimeException ) |
| { |
| ::osl::MutexGuard aGuard(m_aMutex); |
| if( implInitPlayer() && isPlaying() ) |
| { |
| gst_element_set_state( mpPlayer, GST_STATE_PAUSED ); |
| } |
| } |
| |
| // ------------------------------------------------------------------------------ |
| sal_Bool SAL_CALL Player::isPlaying() |
| throw( uno::RuntimeException ) |
| { |
| GstState aState = GST_STATE_NULL; |
| ::osl::MutexGuard aGuard(m_aMutex); |
| if( mpPlayer ) |
| { |
| gst_element_get_state( mpPlayer, &aState, NULL, GST_MAX_TIMEOUT ); |
| } |
| |
| return( GST_STATE_PLAYING == aState ); |
| } |
| |
| // ------------------------------------------------------------------------------ |
| double SAL_CALL Player::getDuration() |
| throw( uno::RuntimeException ) |
| { |
| ::osl::MutexGuard aGuard(m_aMutex); |
| gint64 nDuration = 0; |
| |
| if( implInitPlayer() ) |
| { |
| GstFormat aFormat = GST_FORMAT_TIME; |
| |
| if( !gst_element_query_duration( mpPlayer, &aFormat, &nDuration ) || |
| ( GST_FORMAT_TIME != aFormat ) || |
| ( nDuration < 0 ) ) |
| { |
| nDuration = 0; |
| } |
| } |
| |
| return( static_cast< double >( nDuration ) / NANO_TIME_FACTOR ); |
| } |
| |
| // ------------------------------------------------------------------------------ |
| void SAL_CALL Player::setMediaTime( double fTime ) |
| throw( uno::RuntimeException ) |
| { |
| ::osl::MutexGuard aGuard(m_aMutex); |
| if( implInitPlayer() ) |
| { |
| fTime = ::std::min( ::std::max( fTime, 0.0 ), getDuration() ); |
| |
| gst_element_seek_simple( mpPlayer, GST_FORMAT_TIME, |
| (GstSeekFlags) ( GST_SEEK_FLAG_FLUSH | GST_SEEK_FLAG_KEY_UNIT ), |
| static_cast< gint64 >( fTime * NANO_TIME_FACTOR ) ); |
| } |
| } |
| |
| // ------------------------------------------------------------------------------ |
| double SAL_CALL Player::getMediaTime() |
| throw( uno::RuntimeException ) |
| { |
| double fRet = 0.0; |
| ::osl::MutexGuard aGuard(m_aMutex); |
| if( implInitPlayer() ) |
| { |
| GstFormat aFormat = GST_FORMAT_TIME; |
| gint64 nCurTime = 0; |
| |
| if( gst_element_query_position( mpPlayer, &aFormat, &nCurTime ) && |
| ( GST_FORMAT_TIME == aFormat ) && |
| ( nCurTime >= 0 ) ) |
| { |
| fRet = static_cast< double >( nCurTime ) / NANO_TIME_FACTOR; |
| } |
| } |
| |
| return( fRet ); |
| } |
| |
| // ------------------------------------------------------------------------------ |
| void SAL_CALL Player::setStopTime( double /* fTime */ ) |
| throw( uno::RuntimeException ) |
| { |
| OSL_TRACE( "GStreamer method avmedia::gst::Player::setStopTime needs to be implemented" ); |
| |
| /* Currently no need for implementation since higher levels of code don't use this method at all |
| !!! TODO: needs to be implemented if this functionality is needed at a later point of time |
| if( implInitPlayer() ) |
| { |
| } |
| |
| */ |
| } |
| |
| // ------------------------------------------------------------------------------ |
| double SAL_CALL Player::getStopTime() |
| throw( uno::RuntimeException ) |
| { |
| /* |
| Currently no need for implementation since higher levels of code don't set a stop time ATM |
| !!! TODO: needs to be fully implemented if this functionality is needed at a later point of time |
| */ |
| ::osl::MutexGuard aGuard(m_aMutex); |
| return( getDuration() ); |
| } |
| |
| // ------------------------------------------------------------------------------ |
| void SAL_CALL Player::setRate( double /* fRate */ ) |
| throw( uno::RuntimeException ) |
| { |
| OSL_TRACE( "GStreamer method avmedia::gst::Player::setRate needs to be implemented" ); |
| |
| /* Currently no need for implementation since higher levels of code don't use this method at all |
| !!! TODO: needs to be implemented if this functionality is needed at a later point of time |
| */ |
| } |
| |
| // ------------------------------------------------------------------------------ |
| double SAL_CALL Player::getRate() |
| throw( uno::RuntimeException ) |
| { |
| /* |
| Currently no need for implementation since higher levels of code don't set a different rate than 1 ATM |
| !!! TODO: needs to be fully implemented if this functionality is needed at a later point of time |
| */ |
| |
| return( 1.0 ); |
| } |
| |
| // ------------------------------------------------------------------------------ |
| void SAL_CALL Player::setPlaybackLoop( sal_Bool bSet ) |
| throw( uno::RuntimeException ) |
| { |
| ::osl::MutexGuard aGuard(m_aMutex); |
| if (bSet) |
| { |
| g_atomic_int_compare_and_exchange(&mnLooping, 0, 1); |
| } |
| else |
| { |
| g_atomic_int_compare_and_exchange(&mnLooping, 1, 0); |
| } |
| } |
| |
| // ------------------------------------------------------------------------------ |
| sal_Bool SAL_CALL Player::isPlaybackLoop() |
| throw( uno::RuntimeException ) |
| { |
| ::osl::MutexGuard aGuard(m_aMutex); |
| return( g_atomic_int_get( &mnLooping ) > 0 ); |
| } |
| |
| // ------------------------------------------------------------------------------ |
| void SAL_CALL Player::setMute( sal_Bool bSet ) |
| throw( uno::RuntimeException ) |
| { |
| ::osl::MutexGuard aGuard(m_aMutex); |
| if( implInitPlayer() && ( bSet != isMute() ) ) |
| { |
| if( bSet ) |
| { |
| g_object_set( mpPlayer, "volume", 0.0, NULL ); |
| } |
| else |
| { |
| setVolumeDB( mnVolumeDB ); |
| } |
| } |
| } |
| |
| // ------------------------------------------------------------------------------ |
| sal_Bool SAL_CALL Player::isMute() |
| throw( uno::RuntimeException ) |
| { |
| gdouble fGstVolume = 1.0; |
| ::osl::MutexGuard aGuard(m_aMutex); |
| |
| if( implInitPlayer() ) |
| { |
| g_object_get( mpPlayer, "volume", &fGstVolume, NULL ); |
| } |
| |
| return( 0.0 == fGstVolume ); |
| } |
| |
| // ------------------------------------------------------------------------------ |
| void SAL_CALL Player::setVolumeDB( sal_Int16 nVolumeDB ) |
| throw( uno::RuntimeException ) |
| { |
| ::osl::MutexGuard aGuard(m_aMutex); |
| if( implInitPlayer() ) |
| { |
| g_mutex_lock( mpMutex ); |
| mnVolumeDB = nVolumeDB; |
| g_mutex_unlock( mpMutex ); |
| |
| // maximum gain for gstreamer volume is 10 |
| double fGstVolume = pow( 10.0, static_cast< double >( ::std::min( |
| nVolumeDB, static_cast< sal_Int16 >( 20 ) ) / 20.0 ) ); |
| |
| g_object_set( mpPlayer, "volume", fGstVolume, NULL ); |
| } |
| } |
| |
| // ------------------------------------------------------------------------------ |
| sal_Int16 SAL_CALL Player::getVolumeDB() |
| throw( uno::RuntimeException ) |
| { |
| ::osl::MutexGuard aGuard(m_aMutex); |
| return( static_cast< sal_Int16 >( g_atomic_int_get( &mnVolumeDB ) ) ); |
| } |
| |
| // ------------------------------------------------------------------------------ |
| awt::Size SAL_CALL Player::getPreferredPlayerWindowSize() |
| throw( uno::RuntimeException ) |
| { |
| awt::Size aSize( 0, 0 ); |
| ::osl::MutexGuard aGuard(m_aMutex); |
| |
| if( implInitPlayer() && ( g_atomic_int_get( &mnIsVideoSource ) > 0 ) ) |
| { |
| aSize.Width = g_atomic_int_get( &mnVideoWidth ); |
| aSize.Height = g_atomic_int_get( &mnVideoHeight ); |
| |
| // if we have a video source, but no size is given => use default size |
| if( ( aSize.Width <= 0 ) || ( aSize.Height <= 0 ) ) |
| { |
| aSize.Width = VIDEO_DEFAULT_WIDTH; |
| aSize.Height = VIDEO_DEFAULT_HEIGHT; |
| } |
| } |
| |
| OSL_TRACE( ">>> Requested preferred video size is: %d x %d pixel", aSize.Width, aSize.Height ); |
| |
| return( aSize ); |
| } |
| |
| // ------------------------------------------------------------------------------ |
| uno::Reference< ::media::XPlayerWindow > SAL_CALL Player::createPlayerWindow( |
| const uno::Sequence< uno::Any >& rArguments ) |
| throw( uno::RuntimeException ) |
| { |
| ::osl::MutexGuard aGuard(m_aMutex); |
| uno::Reference< ::media::XPlayerWindow > xRet; |
| awt::Size aSize( getPreferredPlayerWindowSize() ); |
| |
| OSL_ENSURE( !g_atomic_pointer_get( &mpPlayerWindow ), "::avmedia::gst::Player already has a player window" ); |
| |
| if( ( aSize.Width > 0 ) && ( aSize.Height > 0 ) ) |
| { |
| Window* pPlayerWindow = new Window( *this ); |
| |
| xRet = pPlayerWindow; |
| |
| if( !pPlayerWindow->create( rArguments ) ) |
| { |
| xRet.clear(); |
| } |
| else |
| { |
| // try to use gconf user configurable video sink first |
| GstElement* pVideoSink = gst_element_factory_make( "gconfvideosink", NULL ); |
| |
| if( ( NULL != pVideoSink ) || |
| ( NULL != ( pVideoSink = gst_element_factory_make( "autovideosink", NULL ) ) ) || |
| ( NULL != ( pVideoSink = gst_element_factory_make( "xvimagesink", NULL ) ) ) || |
| ( NULL != ( pVideoSink = gst_element_factory_make( "ximagesink", NULL ) ) ) ) |
| { |
| GstState aOldState = GST_STATE_NULL; |
| |
| mpPlayerWindow = pPlayerWindow; |
| gst_element_get_state( mpPlayer, &aOldState, NULL, GST_MAX_TIMEOUT ); |
| gst_element_set_state( mpPlayer, GST_STATE_READY ); |
| g_object_set( mpPlayer, "video-sink", pVideoSink, NULL ); |
| gst_element_set_state( mpPlayer, aOldState ); |
| } |
| } |
| } |
| |
| return( xRet ); |
| } |
| |
| // ------------------------------------------------------------------------------ |
| uno::Reference< media::XFrameGrabber > SAL_CALL Player::createFrameGrabber() |
| throw( ::com::sun::star::uno::RuntimeException ) |
| { |
| ::osl::MutexGuard aGuard(m_aMutex); |
| FrameGrabber* pFrameGrabber = NULL; |
| const awt::Size aPrefSize( getPreferredPlayerWindowSize() ); |
| |
| if( ( aPrefSize.Width > 0 ) && ( aPrefSize.Height > 0 ) ) |
| { |
| pFrameGrabber = FrameGrabber::create( mpURI ); |
| } |
| |
| return( pFrameGrabber ); |
| } |
| |
| // ------------------------------------------------------------------------------ |
| void SAL_CALL Player::disposing() |
| { |
| ::osl::MutexGuard aGuard(m_aMutex); |
| if( mpPlayer ) |
| { |
| stop(); |
| implQuitThread(); |
| } |
| |
| OSL_ASSERT( NULL == mpPlayer ); |
| } |
| |
| // ------------------------------------------------------------------------------ |
| ::rtl::OUString SAL_CALL Player::getImplementationName() |
| throw( uno::RuntimeException ) |
| { |
| return( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( AVMEDIA_GSTREAMER_PLAYER_IMPLEMENTATIONNAME ) ) ); |
| } |
| |
| // ------------------------------------------------------------------------------ |
| sal_Bool SAL_CALL Player::supportsService( const ::rtl::OUString& ServiceName ) |
| throw( uno::RuntimeException ) |
| { |
| return( ServiceName.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM( AVMEDIA_GSTREAMER_PLAYER_SERVICENAME ) ) ); |
| } |
| |
| // ------------------------------------------------------------------------------ |
| uno::Sequence< ::rtl::OUString > SAL_CALL Player::getSupportedServiceNames() |
| throw( uno::RuntimeException ) |
| { |
| uno::Sequence< ::rtl::OUString > aRet( 1 ); |
| aRet[ 0 ] = ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( AVMEDIA_GSTREAMER_PLAYER_SERVICENAME ) ); |
| |
| return( aRet ); |
| } |
| |
| // ------------------------------------------------------------------------------ |
| void Player::implQuitThread() |
| { |
| if( mpThread ) |
| { |
| // set quit flag to 1 so that the main loop will be quit in idle |
| // handler the next time it is called from the thread's main loop |
| g_atomic_int_inc( &mnQuit ); |
| |
| // wait until loop and as such the thread has quit |
| g_thread_join( mpThread ); |
| mpThread = NULL; |
| } |
| } |
| |
| // ------------------------------------------------------------------------------ |
| bool Player::implInitPlayer() |
| { |
| bool bRet = false; |
| |
| if( mpPlayer && (mnInitFail < 3) ) |
| { |
| GstState aState = GST_STATE_NULL; |
| |
| if( gst_element_get_state( mpPlayer, &aState, NULL, GST_MAX_TIMEOUT ) == GST_STATE_CHANGE_SUCCESS ) |
| { |
| bRet = ( GST_STATE_PAUSED == aState ) || ( GST_STATE_PLAYING == aState ); |
| |
| if( !bRet ) |
| { |
| gst_element_set_state( mpPlayer, GST_STATE_PAUSED ); |
| bRet = ( gst_element_get_state( mpPlayer, &aState, NULL, |
| GST_MAX_TIMEOUT ) == GST_STATE_CHANGE_SUCCESS ) && |
| ( GST_STATE_PAUSED == aState ); |
| } |
| } |
| |
| if( ! bRet ) |
| mnInitFail++; |
| } |
| |
| return( bRet ); |
| } |
| |
| // ------------------------------------------------------------------------------ |
| gboolean Player::busCallback( GstBus* /*pBus*/, |
| GstMessage* pMsg ) |
| { |
| if( pMsg && mpLoop ) |
| { |
| switch( GST_MESSAGE_TYPE( pMsg ) ) |
| { |
| case ( GST_MESSAGE_EOS ): |
| { |
| if( g_atomic_int_get( &mnLooping ) > 0 ) |
| { |
| setMediaTime( 0.0 ); |
| start(); |
| } |
| else |
| { |
| stop(); |
| } |
| } |
| break; |
| |
| case ( GST_MESSAGE_ERROR ): |
| { |
| gchar* pDebug; |
| GError* pErr; |
| |
| gst_message_parse_error( pMsg, &pErr, &pDebug ); |
| fprintf( stderr, "Error: %s\n", pErr->message ); |
| |
| g_free( pDebug ); |
| g_error_free( pErr ); |
| } |
| break; |
| |
| default: |
| { |
| break; |
| } |
| } |
| } |
| |
| return( true ); |
| } |
| |
| // ------------------------------------------------------------------------------ |
| void Player::implHandleNewElementFunc( GstBin* /* pBin */, |
| GstElement* pElement, |
| gpointer pData ) |
| { |
| if( pElement ) |
| { |
| #ifdef DEBUG |
| gchar* pElementName = gst_element_get_name( pElement ); |
| |
| if( pElementName ) |
| { |
| OSL_TRACE( ">>> Bin has element: %s", pElementName ); |
| g_free( pElementName ); |
| } |
| #endif |
| |
| if( GST_IS_BIN( pElement ) ) |
| { |
| // set this handler in case we have a GstBin element |
| g_signal_connect( GST_BIN( pElement ), "element-added", |
| G_CALLBACK( Player::implHandleNewElementFunc ), pData ); |
| } |
| |
| // watch for all pads that are going to be added to this element; |
| g_signal_connect( pElement, "pad-added", |
| G_CALLBACK( Player::implHandleNewPadFunc ), pData ); |
| } |
| } |
| |
| // ------------------------------------------------------------------------------ |
| void Player::implHandleNewPadFunc( GstElement* pElement, |
| GstPad* pPad, |
| gpointer pData ) |
| { |
| Player* pPlayer = static_cast< Player* >( pData ); |
| |
| if( pPlayer && pElement && pPad ) |
| { |
| #ifdef DEBUG |
| gchar* pElementName = gst_element_get_name( pElement ); |
| gchar* pPadName = gst_pad_get_name( pPad ); |
| |
| OSL_TRACE( ">>> Element %s has pad: %s", pElementName, pPadName ); |
| |
| g_free( pPadName ); |
| g_free( pElementName ); |
| #endif |
| |
| GstCaps* pCaps = gst_pad_get_caps( pPad ); |
| |
| // we are interested only in getting video properties |
| // width and height or if we have a video source at all |
| if( pCaps ) |
| { |
| for( gint i = 0, nSize = gst_caps_get_size( pCaps ); i < nSize; ++i ) |
| { |
| const GstStructure* pStruct = gst_caps_get_structure( pCaps, i ); |
| |
| if( pStruct ) |
| { |
| const gchar* pStructName = gst_structure_get_name( pStruct ); |
| |
| #ifdef DEBUG |
| OSL_TRACE( "\t>>> Pad has structure: %s", pStructName ); |
| |
| for( gint n = 0, nFields = gst_structure_n_fields( pStruct ); n < nFields; ++n ) |
| { |
| OSL_TRACE( "\t\t>>> Structure has field: %s", gst_structure_nth_field_name( pStruct, n ) ); |
| } |
| #endif |
| |
| // just look for structures having 'video' in their names |
| if( ::std::string( pStructName ).find( "video" ) != ::std::string::npos ) |
| { |
| g_atomic_int_inc( &pPlayer->mnIsVideoSource ); |
| |
| for( gint n = 0, nFields = gst_structure_n_fields( pStruct ); n < nFields; ++n ) |
| { |
| const gchar* pFieldName = gst_structure_nth_field_name( pStruct, n ); |
| gint nValue; |
| |
| if( ( ::std::string( pFieldName ).find( "width" ) != ::std::string::npos ) && |
| gst_structure_get_int( pStruct, pFieldName, &nValue ) ) |
| { |
| const gint nDiff = nValue - g_atomic_int_get( &pPlayer->mnVideoWidth ); |
| g_atomic_int_add( &pPlayer->mnVideoWidth, ::std::max( nDiff, 0 ) ); |
| } |
| else if( ( ::std::string( pFieldName ).find( "height" ) != ::std::string::npos ) && |
| gst_structure_get_int( pStruct, pFieldName, &nValue ) ) |
| { |
| const gint nDiff = nValue - g_atomic_int_get( &pPlayer->mnVideoHeight ); |
| g_atomic_int_add( &pPlayer->mnVideoHeight, ::std::max( nDiff, 0 ) ); |
| } |
| } |
| } |
| } |
| } |
| |
| gst_caps_unref( pCaps ); |
| } |
| } |
| } |
| |
| // ------------------------------------------------------------------------------ |
| gboolean Player::idle() |
| { |
| // test if main loop should quit by comparing with 1 |
| // and set flag mnQuit to 0 so we call g_main_loop_quit exactly once |
| bool const bQuit = g_atomic_int_compare_and_exchange( &mnQuit, 1, 0 ); |
| |
| if( bQuit ) |
| { |
| g_main_loop_quit( mpLoop ); |
| } |
| |
| // don't eat up all cpu time |
| usleep( 1000 ); |
| |
| return( true ); |
| } |
| |
| // ------------------------------------------------------------------------------ |
| gpointer Player::run() |
| { |
| static GSourceFuncs aSourceFuncs = |
| { |
| &lcl_implBusPrepare, |
| &lcl_implBusCheck, |
| &lcl_implBusDispatch, |
| &lcl_implBusFinalize, |
| NULL, |
| NULL |
| }; |
| |
| if( NULL != ( mpPlayer = gst_element_factory_make( "playbin", NULL ) ) ) |
| { |
| // initialization |
| // no mutex necessary since initialization |
| // is synchronous until loop is started |
| mpContext = g_main_context_new(); |
| mpLoop = g_main_loop_new( mpContext, false ); |
| |
| // add idle callback |
| GSource* pIdleSource = g_idle_source_new(); |
| g_source_set_callback( pIdleSource, &lcl_implIdleFunc, this, NULL ); |
| g_source_attach( pIdleSource, mpContext ); |
| |
| // add bus callback |
| GSource* pBusSource = g_source_new( &aSourceFuncs, sizeof( GstBusSource ) ); |
| static_cast< GstBusSource* >( pBusSource )->mpBus = gst_pipeline_get_bus( GST_PIPELINE( mpPlayer ) ); |
| g_source_set_callback( pBusSource, NULL, this, NULL ); |
| g_source_attach( pBusSource, mpContext ); |
| |
| // add bus sync handler to intercept video window creation for setting our own window |
| gst_bus_set_sync_handler( static_cast< GstBusSource* >( pBusSource )->mpBus, |
| &lcl_implHandleCreateWindowFunc, this ); |
| |
| // watch for all elements (and pads) that will be added to the playbin, |
| // in order to retrieve properties like video width and height |
| g_signal_connect( GST_BIN( mpPlayer ), "element-added", |
| G_CALLBACK( Player::implHandleNewElementFunc ), this ); |
| |
| // set source URI for player |
| g_object_set( mpPlayer, "uri", mpURI->str, NULL ); |
| |
| // set video fake sink first, since we only create a player without window here |
| // and don't want to have the gstreamer default window appearing |
| g_object_set( mpPlayer, "video-sink", gst_element_factory_make( "fakesink", NULL ), NULL ); |
| |
| // set state of player to READY or destroy object in case of FAILURE |
| if( gst_element_set_state( mpPlayer, GST_STATE_READY ) == GST_STATE_CHANGE_FAILURE ) |
| { |
| gst_object_unref( mpPlayer ); |
| mpPlayer = NULL; |
| } |
| |
| g_atomic_int_add( &mnInitialized, 1 ); |
| g_cond_signal( mpCond ); |
| |
| // run the main loop |
| g_main_loop_run( mpLoop ); |
| |
| // clenanup |
| // no mutex necessary since other thread joined us (this thread) |
| // after setting the quit flag |
| if( mpPlayer ) |
| { |
| gst_element_set_state( mpPlayer, GST_STATE_NULL ); |
| gst_object_unref( mpPlayer ); |
| mpPlayer = NULL; |
| } |
| |
| g_main_loop_unref( mpLoop ); |
| mpLoop = NULL; |
| |
| g_source_destroy( pBusSource ); |
| g_source_unref( pBusSource ); |
| |
| g_source_destroy( pIdleSource ); |
| g_source_unref( pIdleSource ); |
| |
| g_main_context_unref( mpContext ); |
| mpContext = NULL; |
| } |
| else |
| { |
| g_atomic_int_add( &mnInitialized, 1 ); |
| g_cond_signal( mpCond ); |
| } |
| |
| return( NULL ); |
| } |
| |
| // ------------------------------------------------------------------------------ |
| GstBusSyncReply Player::handleCreateWindow( GstBus* /* pBus */, |
| GstMessage* pMsg ) |
| { |
| GstBusSyncReply eRet = GST_BUS_PASS; |
| |
| if( pMsg && |
| ( GST_MESSAGE_TYPE( pMsg ) == GST_MESSAGE_ELEMENT ) && |
| gst_structure_has_name( pMsg->structure, "prepare-xwindow-id" ) && |
| g_atomic_pointer_get( &mpPlayerWindow ) ) |
| { |
| OSL_TRACE( ">>> Got Request to create XOverlay" ); |
| |
| gst_x_overlay_set_xwindow_id( GST_X_OVERLAY( GST_MESSAGE_SRC( pMsg ) ), |
| static_cast< Window* >( g_atomic_pointer_get( |
| &mpPlayerWindow ) )->getXWindowHandle() ); |
| |
| gst_message_unref( pMsg ); |
| eRet = GST_BUS_DROP; |
| } |
| |
| return( eRet ); |
| } |
| } // namespace gst |
| } // namespace avmedia |
