chxclientplayer.cpp

linux下的一款播放器

}

HX_RESULT
CHXClientPlayer::WriteData( void* pData, UINT32 bufferLength, unsigned char* pBuffer )
{
	UINT32 recordNum;
	CHXClientDataStream* pDataStream = ( CHXClientDataStream* ) pData;
	if ( !FindDataStream( pDataStream, &recordNum ) ) return HXR_FAIL;
	
	HX_RESULT outResult = pDataStream->WriteData( bufferLength, pBuffer );
	if ( FAILED( outResult ) )
	{
		m_pDataStreams->Remove( recordNum );
		delete pDataStream;
	}
	return outResult;
}

void
CHXClientPlayer::CloseData( void* pData )
{
	UINT32 recordNum;
	CHXClientDataStream* pDataStream = ( CHXClientDataStream* ) pData;
	if ( !FindDataStream( pDataStream, &recordNum ) ) return;

	HX_RESULT result = pDataStream->CloseData();
	if ( FAILED( result ) )
	{
		m_pDataStreams->Remove( recordNum );
		delete pDataStream;
	}
}

bool
CHXClientPlayer::GetOpenedURL( char* pURLBuffer, UINT32 bufferLength, UINT32* pUsedBufferLength ) const
{
	if ( pUsedBufferLength )
	{
		*pUsedBufferLength = 0;
	}
	if ( !m_pIOpenedRequest ) return false;
	
	const char* pOpenedURL = NULL;
	if ( FAILED( m_pIOpenedRequest->GetURL( pOpenedURL ) ) ) return false;
	
	UINT32 sizeOfMemFSProtocol = strlen( kProtocolMemFS );
	if ( 0 == strncmp( pOpenedURL, kProtocolMemFS, sizeOfMemFSProtocol ) )
	{
		pOpenedURL += sizeOfMemFSProtocol;
	}
	UINT32 desiredBufferLength = strlen( pOpenedURL ) + 1;
	if ( pUsedBufferLength )
	{
		*pUsedBufferLength = desiredBufferLength;
	}
	if ( !pURLBuffer || ( bufferLength == 0 ) ||
		 ( desiredBufferLength > bufferLength ) ) // Makes no sense to copy a partial URL.
	{
		return false;
	}
	memcpy( pURLBuffer, pOpenedURL, desiredBufferLength );
	return true;
}

bool
CHXClientPlayer::CanViewSource( void )
{
	SPIHXViewSourceCommand spViewSourceCommand = m_pIHXCorePlayer;
	return spViewSourceCommand.IsValid() ?
		   ( ( 0 != spViewSourceCommand->CanViewSource( kCurrentStream ) ) ? true : false ) : false;
}

void
CHXClientPlayer::ViewSource( void )
{
	SPIHXViewSourceCommand spViewSourceCommand = m_pIHXCorePlayer;
	if ( spViewSourceCommand.IsValid() )
	{
		( void ) spViewSourceCommand->DoViewSource( kCurrentStream );
	}
}

bool
CHXClientPlayer::CanViewRights( void )
{
	SPIHXClientViewRights spClientViewRights = m_pIHXCorePlayer;
	return spClientViewRights.IsValid() ?
		   ( ( 0 != spClientViewRights->CanViewRights() ) ? true : false ) : false;
}

void
CHXClientPlayer::ViewRights( void )
{
	SPIHXClientViewRights spClientViewRights = m_pIHXCorePlayer;
	if ( spClientViewRights.IsValid() )
	{
		( void ) spClientViewRights->ViewRights( m_pIHXCorePlayer );
	}
}

HX_RESULT
CHXClientPlayer::Authenticate( bool shouldValidateUser, const char* pUsername, const char* pPassword )
{
	return m_pClientContext->Authenticate( shouldValidateUser, pUsername, pPassword );
}

int
CHXClientPlayer::GetContentState( void ) const
{
	return ( m_pClipSink && m_pIOpenedRequest ) ? m_pClipSink->GetContentState() : kContentStateNotLoaded;
}

bool
CHXClientPlayer::HasContentBegun( void ) const
{
	return m_pClipSink ? m_pClipSink->HasContentBegun() : false;
}

bool
CHXClientPlayer::SetStatus( const char* pStatus )
{
#ifdef HELIX_FEATURE_VIDEO
	if ( m_SiteSupplier )
	{
		return m_SiteSupplier->SetStatus( pStatus );
	}
	else
#endif
	{
		return false;
	}
}

void
CHXClientPlayer::Play( void )
{
	if ( m_pIOpenedRequest /* && !HasContentBegun() */ )
	{
		if ( !m_pClientContext->IsAuthenticationPending() )
		{
			HX_RESULT result = HXR_OK;
			
			// XXXSEH: Added IsDone() check to deal with a Helix bug.
			//         Once a clip has been stopped, Helix cannot play it until it's been Opened again.
			if ( m_pClientContext->HasRequestedUpgrade() ||
				 m_pIHXCorePlayer->IsDone() )
			{
				result = LoadRequest( m_pIOpenedRequest );
				if ( FAILED( result ) ) return;
			}
			if ( m_PendingSeekPosition != kInvalidSeekPosition )
			{
				UINT32 beginPosition = m_PendingSeekPosition;
				m_PendingSeekPosition = kInvalidSeekPosition;
				if ( m_pClipSink )
				{
					m_pClipSink->SetBeginPosition( beginPosition );
				}
			}
			result = m_pIHXCorePlayer->Begin();
			CHXASSERT( SUCCEEDED( result ) );
		}
	}
}

void
CHXClientPlayer::Pause( void )
{
	// if ( HasContentBegun() )
	{
		HX_RESULT result = m_pIHXCorePlayer->Pause();
		CHXASSERT( SUCCEEDED( result ) );
	}
}

void
CHXClientPlayer::Stop( void )
{
	// if ( HasContentBegun() )
	{
		HX_RESULT result = m_pIHXCorePlayer->Stop();
		CHXASSERT( SUCCEEDED( result ) );
		if ( m_pClipSink )
		{
			m_pClipSink->ProcessPendingStateChange();
		}
	}
}

bool
CHXClientPlayer::StartSeeking( void )
{
	bool outSeekingHasStarted = m_IsActivelySeeking;
	if ( !outSeekingHasStarted )
	{
		bool hasContentBegun = HasContentBegun();
		if ( hasContentBegun || ( GetContentState() == kContentStatePaused ) )
		{
			m_ShouldPlayOnStopSeeking = hasContentBegun;
			Pause();
			m_PendingSeekPosition = GetPosition();
			m_IsActivelySeeking = true;
			outSeekingHasStarted = true;
		}
	}
	return outSeekingHasStarted;
}

HX_RESULT
CHXClientPlayer::SetPosition( UINT32 position )
{
	HX_RESULT outResult = HXR_FAIL;
	if ( m_IsActivelySeeking /*|| ( GetContentState() == kContentStateStopped )*/ ) // XXXSEH: See comment in CHXClientSink::SetBeginPosition()
	{
		m_PendingSeekPosition = position;
		outResult = HXR_OK;
	}
	else
	{
		outResult = m_pIHXCorePlayer->Seek( position );
	}
	return outResult;
}

void
CHXClientPlayer::StopSeeking( void )
{
	if ( m_IsActivelySeeking )
	{
		m_IsActivelySeeking = false;
		if ( m_ShouldPlayOnStopSeeking )
		{
			Play();
		}
	}
}

UINT32
CHXClientPlayer::GetPosition( void ) const
{
	// return m_pIHXCorePlayer->GetCurrentPlayTime(); // XXXSEH: Would this be better?
	return ( m_PendingSeekPosition != kInvalidSeekPosition ) ?
		   m_PendingSeekPosition : ( m_pClipSink ? m_pClipSink->GetPosition() : 0 );
}

UINT32
CHXClientPlayer::GetLength( void ) const
{
	return m_pClipSink ? m_pClipSink->GetLength() : 0;
}

bool
CHXClientPlayer::IsLive( void ) const
{
	return ( ( 0 != m_pIHXCorePlayer->IsLive() ) ? true : false );
}

const char*
CHXClientPlayer::GetTitle( void ) const
{
	return m_pClipSink ? m_pClipSink->GetTitle() : NULL;
}

const char*
CHXClientPlayer::GetContextURL( void ) const
{
	return m_pClipSink ? m_pClipSink->GetContextURL() : NULL;
}

INT32
CHXClientPlayer::GetClipBandwidth( void ) const
{
	return m_pClipSink ? m_pClipSink->GetClipBandwidth() : 0;
}

UINT16
CHXClientPlayer::GetSourceCount( void ) const
{
	return m_pIHXCorePlayer ? m_pIHXCorePlayer->GetSourceCount() : 0;
}

UINT16
CHXClientPlayer::GetGroupCount( void ) const
{
	SPIHXGroupManager spGroupManager = m_pIHXCorePlayer;
	return spGroupManager.IsValid() ? spGroupManager->GetGroupCount() : 0;
}

UINT16
CHXClientPlayer::GetCurrentGroup( void ) const
{
	SPIHXGroupManager spGroupManager = m_pIHXCorePlayer;
	if ( spGroupManager.IsValid() )
	{
		UINT16 currentGroupIndex = 0;
		if ( SUCCEEDED( spGroupManager->GetCurrentGroup( currentGroupIndex ) ) )
		{
			return currentGroupIndex;
		}
	}
	return 0; // XXXSEH: Is this a reasonable default or failed value?
}

HX_RESULT
CHXClientPlayer::SetCurrentGroup( UINT16 groupIndex )
{
	SPIHXGroupManager spGroupManager = m_pIHXCorePlayer;
	return spGroupManager.IsValid() ? spGroupManager->SetCurrentGroup( groupIndex ) : HXR_FAIL;
}

static bool
BufferContainsText( const SPIHXBuffer& spBuff )
{
	if ( !spBuff.IsValid() ) return false;
	
	const unsigned char* pString = spBuff->GetBuffer();
	while ( *pString )
	{
		if ( !isspace( *pString++ ) )
		{
			return true;
		}
	}
	return false;
}

bool
CHXClientPlayer::GetGroupURLBuffer( UINT16 groupIndex, IHXBuffer** ppIURL ) const
{
	SPIHXBuffer spBuffer;
	SPIHXGroup spGroup;
	SPIHXGroupManager spGroupManager = m_pIHXCorePlayer;
	if ( spGroupManager.IsValid() && SUCCEEDED( spGroupManager->GetGroup( groupIndex, *spGroup.AsInOutParam() ) ) && ( spGroup.IsValid() ) )
	{
		// try to get an URL; if that fails, look for a track with an URL
		SPIHXValues spProperties = spGroup->GetGroupProperties();
		if ( spProperties.IsValid() )
		{
			spProperties->GetPropertyCString( "url", *spBuffer.AsInOutParam() );
			if ( BufferContainsText( spBuffer ) )
			{
				spBuffer.AsPtr( ppIURL );
				return true;
			}
		}
		SPIHXValues spProps2;
		for ( UINT16 i = 0 ; i < spGroup->GetTrackCount() ; ++i )
		{
			spGroup->GetTrack( i, *spProps2.AsInOutParam() );
			if ( spProps2.IsValid() )
			{
				spProps2->GetPropertyCString( "url", *spBuffer.AsInOutParam() );
				if ( BufferContainsText( spBuffer ) )
				{
					spBuffer.AsPtr( ppIURL );
					return true;
				}
				spProps2->GetPropertyCString( "src", *spBuffer.AsInOutParam() );
				if ( BufferContainsText( spBuffer ) )
				{
					spBuffer.AsPtr( ppIURL );
					return true;
				}
			}
		}
    }
	// we failed to get a group or track URL, so use one for the overall file
	SPIHXValues spValues = m_pIHXCorePlayer;
	if ( spValues.IsValid() )
	{
		spValues->GetPropertyCString( "url", *spBuffer.AsInOutParam() );
		if ( BufferContainsText( spBuffer ) )
		{
			spBuffer.AsPtr( ppIURL );
			return true;
		}
	}
	return false;
}

bool
CHXClientPlayer::GetGroupURL( UINT16 groupIndex, char* pURLBuffer, UINT32 bufferLength, UINT32* pUsedBufferLength ) const
{
	if ( pUsedBufferLength )
	{
		*pUsedBufferLength = 0;
	}
	SPIHXBuffer spURL;
	if ( GetGroupURLBuffer( groupIndex, spURL.AsInOutParam() ) )
	{
		const unsigned char* pURLString = spURL->GetBuffer();
		UINT32 desiredBufferLength = spURL->GetSize();

		// If no buffer was provided, just return the string's size.
		if ( !pURLString || ( bufferLength == 0 ) )
		{
			if ( pUsedBufferLength )
			{
				*pUsedBufferLength = desiredBufferLength;
			}
			return false;
		}
		else
		{
			UINT32 usedBufferLength = ( desiredBufferLength <= bufferLength ) ? desiredBufferLength : bufferLength;
			memcpy( pURLBuffer, pURLString, usedBufferLength );
			if ( usedBufferLength < desiredBufferLength )
			{
				pURLBuffer[ usedBufferLength - 1 ] = '\0';
			}
			if ( pUsedBufferLength )
			{
				*pUsedBufferLength = usedBufferLength;
			}
			return true;
		}
	}
	return false;
}

bool
CHXClientPlayer::GetGroupTitleBuffer( UINT16 groupIndex, IHXBuffer** ppIDisplayName, bool& isURL ) const
{
	isURL = false;

	SPIHXBuffer spBuffer;
	SPIHXGroup spGroup;
	SPIHXGroupManager spGroupManager = m_pIHXCorePlayer;
	if ( spGroupManager.IsValid() && SUCCEEDED( spGroupManager->GetGroup( groupIndex, *spGroup.AsInOutParam() ) ) && ( spGroup.IsValid() ) )
	{
		// try to get a group name or URL; if that fails, look for a track with a title or URL
		SPIHXValues spProperties = spGroup->GetGroupProperties();
		if ( spProperties.IsValid() )
		{
			spProperties->GetPropertyCString( "title", *spBuffer.AsInOutParam() );
			if ( BufferContainsText( spBuffer ) )
			{
				spBuffer.AsPtr( ppIDisplayName );
				return true;
			}
			spProperties->GetPropertyCString( "url", *spBuffer.AsInOutParam() );
			if ( BufferContainsText( spBuffer ) )