You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
657 lines
20 KiB
657 lines
20 KiB
//========= Copyright (c), Valve Corporation, All rights reserved. ============//
|
|
|
|
#include "client_pch.h"
|
|
#include "demostreamhttp.h"
|
|
#include "cl_steamauth.h"
|
|
#include "tier1/keyvaluesjson.h"
|
|
#include "tier0/memalloc.h"
|
|
#include "cl_demo.h"
|
|
#include "sv_steamauth.h"
|
|
#include "engine_gcmessages.pb.h"
|
|
|
|
|
|
static ISteamHTTP *s_pSteamHTTP = NULL;
|
|
ConVar demo_debug( "demo_debug", "0", 0, "Demo debug info." );
|
|
ConVar tv_playcast_origin_auth( "tv_playcast_origin_auth", "", FCVAR_RELEASE | FCVAR_HIDDEN, "Get request X-Origin-Auth string" );
|
|
ConVar tv_playcast_max_rcvage( "tv_playcast_max_rcvage", "15", FCVAR_RELEASE | FCVAR_HIDDEN );
|
|
ConVar tv_playcast_max_rtdelay( "tv_playcast_max_rtdelay", "55", FCVAR_RELEASE | FCVAR_HIDDEN );
|
|
ConVar tv_playcast_delay_prediction( "tv_playcast_delay_prediction", "1", FCVAR_RELEASE );
|
|
|
|
CDemoStreamHttp::CDemoStreamHttp() :
|
|
m_nState( STATE_IDLE ),
|
|
m_pStreamSignup( NULL ),
|
|
m_pClient( NULL ),
|
|
m_bSyncFromGc( false ),
|
|
m_flBroadcastKeyframeInterval( 3 )
|
|
{
|
|
V_memset( &m_SyncResponse, 0, sizeof( m_SyncResponse ) );
|
|
m_dSyncTimeoutEnd = -1;
|
|
}
|
|
|
|
void CDemoStreamHttp::StartStreaming( const char *pUrl, SyncParams_t syncParams )
|
|
{
|
|
if ( !PrepareForStreaming( pUrl ) )
|
|
return;
|
|
m_SyncParams = syncParams;
|
|
SendSync( );
|
|
}
|
|
|
|
bool CDemoStreamHttp::PrepareForStreaming( const char * pUrl )
|
|
{
|
|
StopStreaming();
|
|
|
|
if ( pUrl[ 0 ] == 'g' && pUrl[ 1 ] == 'c' && pUrl[ 2 ] == '-' )
|
|
{
|
|
m_Url = pUrl + 3;
|
|
m_bSyncFromGc = true;
|
|
}
|
|
else
|
|
{
|
|
m_Url = pUrl;
|
|
m_bSyncFromGc = false;
|
|
}
|
|
|
|
m_Url.StripTrailingSlash();
|
|
|
|
#ifndef DEDICATED
|
|
s_pSteamHTTP = Steam3Client().SteamHTTP();
|
|
#endif
|
|
|
|
if ( !s_pSteamHTTP )
|
|
s_pSteamHTTP = Steam3Server().SteamHTTP();
|
|
|
|
|
|
if ( !s_pSteamHTTP )
|
|
{
|
|
DevMsg( "Cannot get Steam HTTP interface\n" );
|
|
return false ;
|
|
}
|
|
|
|
DevMsg( "Broadcast: Synchronizing stream\n" );
|
|
m_nState = STATE_SYNC;
|
|
return true;
|
|
}
|
|
|
|
// this is only called in special cases for debugging, to play back stale contents
|
|
void CDemoStreamHttp::StartStreamingCached( const char *pUrl, int nFragment)
|
|
{
|
|
if ( !PrepareForStreaming( pUrl ) )
|
|
return;
|
|
|
|
m_nState = STATE_START;
|
|
// guess parameters of the stream
|
|
int nStartTick = 1;
|
|
m_nDemoProtocol = 4; // DEMO_PROTOCOL == 4 is where I started writing this
|
|
int nSignupFragment = 0;
|
|
|
|
m_SyncParams.m_nStartFragment = 0;
|
|
m_SyncResponse.flTicksPerSecond = 128;
|
|
m_SyncResponse.flKeyframeInterval = 3;
|
|
m_SyncResponse.flRealTimeDelay = 0;
|
|
m_SyncResponse.flReceiveAge = 0;
|
|
m_SyncResponse.nFragment = nFragment;
|
|
m_SyncResponse.nSignupFragment = nSignupFragment;
|
|
m_SyncResponse.nStartTick = nStartTick;
|
|
m_SyncResponse.dPlatTimeReceived = Plat_FloatTime();
|
|
|
|
SendGet( CFmtStr( "/%d/start", nSignupFragment ), new CStartRequest( ) );
|
|
BeginBuffering( nFragment );
|
|
}
|
|
|
|
void CDemoStreamHttp::SendSync( int nResync )
|
|
{
|
|
Assert( m_nState == STATE_SYNC );
|
|
#ifndef DEDICATED
|
|
if ( m_bSyncFromGc )
|
|
{
|
|
GotvHttpStreamId_t params = GetStreamId( m_Url );
|
|
DevMsg( "Requesting sync from GC, start fragment %d match id %llu instance %d\n", m_SyncParams.m_nStartFragment, params.m_nMatchId, params.m_nInstanceId );
|
|
CEngineGotvSyncPacket msg;
|
|
msg.set_match_id( params.m_nMatchId );
|
|
msg.set_instance_id( params.m_nInstanceId );
|
|
if ( m_SyncParams.m_nStartFragment > 0 )
|
|
{
|
|
msg.set_currentfragment( m_SyncParams.m_nStartFragment );
|
|
}
|
|
g_ClientDLL->EngineGotvSyncPacket( &msg );
|
|
m_dSyncTimeoutEnd = Plat_FloatTime() + 10;
|
|
}
|
|
else
|
|
#endif
|
|
{
|
|
char request[ 128 ];
|
|
m_SyncParams.PrintSyncRequest( request, sizeof( request ) );
|
|
DevMsg( "Requesting sync from relay %s\n", request );
|
|
SendGet( request, new CSyncRequest( m_SyncParams, nResync ) );
|
|
}
|
|
}
|
|
|
|
void CDemoStreamHttp::Resync( )
|
|
{
|
|
m_nState = STATE_SYNC;
|
|
SendSync( 1 );
|
|
}
|
|
|
|
void CDemoStreamHttp::Update()
|
|
{
|
|
if ( m_nState == STATE_SYNC && m_bSyncFromGc && m_dSyncTimeoutEnd > 0 && m_dSyncTimeoutEnd < Plat_FloatTime() )
|
|
{
|
|
StopStreaming();
|
|
}
|
|
|
|
if ( m_nState == STATE_RANDOM_WAIT_AND_SYNC && m_bSyncFromGc && m_dSyncTimeoutEnd > 0 && m_dSyncTimeoutEnd < Plat_FloatTime() )
|
|
{
|
|
m_nState = STATE_SYNC;
|
|
SendSync( 0 );
|
|
}
|
|
}
|
|
|
|
// result from "/start" request
|
|
void CDemoStreamHttp::OnStart( HTTPRequestHandle hRequest )
|
|
{
|
|
m_pStreamSignup = MakeBuffer( hRequest );
|
|
m_nStreamSignupFragment = m_SyncResponse.nSignupFragment;
|
|
if ( !m_pStreamSignup )
|
|
{
|
|
DevMsg( "Broadcast failed to start: cannot retrieve startup packet data\n" );
|
|
StopStreaming();
|
|
return;
|
|
}
|
|
|
|
DevMsg( "Received signup fragment %d\n", m_SyncResponse.nSignupFragment );
|
|
if ( m_pClient )
|
|
{
|
|
m_pClient->OnDemoStreamStart( GetStreamStartReference(), 0 );
|
|
}
|
|
}
|
|
|
|
void CDemoStreamHttp::OnFragmentRequestSuccess( HTTPRequestHandle hRequest, int nFragment, FragmentTypeEnum_t nType )
|
|
{
|
|
Fragment_t &fragment = Fragment( nFragment );
|
|
fragment.ClearStreaming( nType );
|
|
if ( Buffer_t *pBuf = MakeBuffer( hRequest ) )
|
|
{
|
|
fragment.SetField( nType, pBuf );
|
|
}
|
|
else
|
|
{
|
|
DevMsg( "Broadcast playback failed to retrieve %s frame of fragment %d", AsString( nType ), nFragment ); // TODO: implement fault-tolerant recovery; we can request the next fragment's full frame
|
|
StopStreaming();
|
|
}
|
|
}
|
|
|
|
void CDemoStreamHttp::OnFragmentRequestFailure( EHTTPStatusCode nErrorCode, int nFragment, FragmentTypeEnum_t nType )
|
|
{
|
|
Fragment_t &fragment = Fragment( nFragment );
|
|
fragment.ClearStreaming( nType );
|
|
// TODO: Retry streaming gracefully, implement timeouts, skip fragment and download the next full frame if needed
|
|
}
|
|
|
|
bool CDemoStreamHttp::OnEngineGotvSyncPacket( const CEngineGotvSyncPacket *pPkt )
|
|
{
|
|
GotvHttpStreamId_t streamId = GetStreamId( m_Url );
|
|
|
|
if ( streamId.m_nMatchId != pPkt->match_id() || streamId.m_nInstanceId != pPkt->instance_id() )
|
|
{
|
|
Warning( "Ignoring unexpected sync from gc, match %llu:%d, expected %llu:%d\n", pPkt->match_id(), pPkt->instance_id(), streamId.m_nMatchId, streamId.m_nInstanceId );
|
|
return false;
|
|
}
|
|
|
|
if ( m_nState != STATE_SYNC && m_nState != STATE_RANDOM_WAIT_AND_SYNC ) // we should be waiting for a sync in some way. In case of WAIT_AND_SYNC, maybe GC will send us a packet even though we didn't ask for it, while we're waiting to re-ask for a sync..
|
|
{
|
|
Warning( "Ignoring unexpected sync from gc, match %llu:%d\n", pPkt->match_id(), pPkt->instance_id() );
|
|
return false;
|
|
}
|
|
|
|
if ( !pPkt->has_tick() )
|
|
{
|
|
// the packet is empty, which means: wait for a few seconds
|
|
m_nState = STATE_RANDOM_WAIT_AND_SYNC;
|
|
float flDelay = pPkt->rtdelay() * RandomFloat( 0.5f, 1.5f );
|
|
m_dSyncTimeoutEnd = Plat_FloatTime() + flDelay;
|
|
DevMsg( "Waiting %.2f seconds\n", flDelay );
|
|
return true; // we actually successfully processed the packet
|
|
}
|
|
|
|
m_nDemoProtocol = 4;
|
|
m_SyncResponse.flTicksPerSecond = pPkt->tickrate();
|
|
m_SyncResponse.flKeyframeInterval = pPkt->has_keyframe_interval() ? pPkt->keyframe_interval() : 3.0f;
|
|
m_SyncResponse.nStartTick = pPkt->tick();
|
|
m_SyncResponse.flRealTimeDelay = pPkt->rtdelay();
|
|
m_SyncResponse.flReceiveAge = pPkt->rcvage();
|
|
m_SyncResponse.nFragment = pPkt->currentfragment();
|
|
m_SyncResponse.nSignupFragment = pPkt->signupfragment();
|
|
m_SyncResponse.dPlatTimeReceived = Plat_FloatTime();
|
|
|
|
return OnSync( 0 );
|
|
}
|
|
|
|
|
|
|
|
// result from "/sync" request arrived
|
|
bool CDemoStreamHttp::OnSync( const char *pBuffer, int nBufferSize, int nResync )
|
|
{
|
|
if ( m_nState != STATE_SYNC )
|
|
{
|
|
Warning( "Ignoring unexpected sync, %d bytes, resync %d\n", nBufferSize, nResync );
|
|
return false;
|
|
}
|
|
KeyValuesJSONParser json( pBuffer, nBufferSize );
|
|
if ( KeyValues *pSync = json.ParseFile() )
|
|
{
|
|
m_SyncResponse.flKeyframeInterval = pSync->GetFloat( "keyframe_interval", 3.0f );
|
|
m_SyncResponse.nStartTick = pSync->GetInt( "tick", -1 );
|
|
m_SyncResponse.flRealTimeDelay = pSync->GetFloat( "rtdelay", 0 );
|
|
m_SyncResponse.flReceiveAge = pSync->GetFloat( "rcvage", 0 );
|
|
m_SyncResponse.nFragment = pSync->GetInt( "fragment", 1 );
|
|
m_SyncResponse.nSignupFragment = pSync->GetInt( "signup_fragment", 0 );
|
|
m_SyncResponse.flTicksPerSecond = pSync->GetInt( "tps", 0 );
|
|
m_SyncResponse.dPlatTimeReceived = Plat_FloatTime();
|
|
m_nDemoProtocol = pSync->GetInt( "protocol", 4 ); // DEMO_PROTOCOL == 4 is where I started writing this
|
|
|
|
delete pSync; pSync = NULL;
|
|
|
|
return OnSync( nResync );
|
|
}
|
|
else
|
|
{
|
|
DevMsg( "Broadcast sync: malformed response: %s\n", pBuffer );
|
|
StopStreaming();
|
|
return false;
|
|
}
|
|
}
|
|
|
|
|
|
bool CDemoStreamHttp::OnSync( int nResync )
|
|
{
|
|
if ( nResync && !IsDebug() && m_SyncResponse.flReceiveAge > tv_playcast_max_rcvage.GetFloat() && m_SyncResponse.flRealTimeDelay > tv_playcast_max_rtdelay.GetFloat() )
|
|
{
|
|
DevMsg( "Broadcast resync %d: the stream seems to have stopped (rcvage %.1f, rtdelay %.1f)\n", nResync, m_SyncResponse.flReceiveAge, m_SyncResponse.flRealTimeDelay );
|
|
StopStreaming();
|
|
return false;
|
|
}
|
|
else if ( /*nTick < 0 || nEndTick < nTick || flSkip < 0 ||*/ m_SyncResponse.nFragment < m_SyncResponse.nSignupFragment || m_SyncResponse.nSignupFragment < 0 )
|
|
{
|
|
DevMsg( "Broadcast m_SyncResponse: unexpected response. fragment %d must be at/after start fragment %d\n", m_SyncResponse.nFragment, m_SyncResponse.nSignupFragment );
|
|
StopStreaming();
|
|
return false;
|
|
}
|
|
else
|
|
{
|
|
DevMsg( "Broadcast: Buffering stream tick %d fragment %d signup fragment %d\n", m_SyncResponse.nStartTick, m_SyncResponse.nSignupFragment, m_SyncResponse.nSignupFragment );
|
|
m_nState = STATE_START;
|
|
m_dSyncTimeoutEnd = -1;
|
|
m_flBroadcastKeyframeInterval = m_SyncResponse.flKeyframeInterval;
|
|
if ( nResync )
|
|
{
|
|
if ( !m_pClient )
|
|
{
|
|
DevMsg( "Broadcast resync failed: Client not connected to Stream\n" );
|
|
StopStreaming();
|
|
return false;
|
|
}
|
|
if ( m_SyncResponse.nSignupFragment == m_nStreamSignupFragment )
|
|
{
|
|
Assert( m_pStreamSignup.IsValid() && m_pClient );
|
|
m_pClient->OnDemoStreamStart( GetStreamStartReference(), nResync );
|
|
}
|
|
else
|
|
{
|
|
if ( !m_pClient->OnDemoStreamRestarting() )
|
|
{
|
|
StopStreaming();
|
|
return false;
|
|
}
|
|
DevMsg( "Resync %d response requires full stream restart because signup fragment changed from %d to %d\n", nResync, m_nStreamSignupFragment, m_SyncResponse.nSignupFragment );
|
|
SendGet( CFmtStr( "/%d/start", m_SyncResponse.nSignupFragment ), new CStartRequest( ) );
|
|
}
|
|
}
|
|
else
|
|
{
|
|
Assert( !m_pStreamSignup ); // when we're restarting, we don't need the start fragment, we already initialized
|
|
SendGet( CFmtStr( "/%d/start", m_SyncResponse.nSignupFragment ), new CStartRequest( ) );
|
|
}
|
|
if ( nResync || !tv_playcast_delay_prediction.GetBool() )
|
|
{
|
|
int nFragment = m_SyncResponse.nFragment;
|
|
BeginBuffering( nFragment );
|
|
}
|
|
return true;
|
|
}
|
|
}
|
|
|
|
|
|
void CDemoStreamHttp::BeginBuffering( int nFragment )
|
|
{
|
|
RequestFragment( nFragment, FRAGMENT_FULL );
|
|
for ( int i = 0; i <= 4; ++i )
|
|
RequestFragment( nFragment + i, FRAGMENT_DELTA );
|
|
}
|
|
|
|
void CDemoStreamHttp::RequestFragment( int nFragment, FragmentTypeEnum_t nType )
|
|
{
|
|
Fragment_t &fragment = Fragment( nFragment );
|
|
if ( !fragment.GetField( nType ) && !fragment.IsStreaming(nType) )
|
|
{
|
|
fragment.SetStreaming( nType );
|
|
SendGet( CFmtStr( nType == FRAGMENT_FULL ? "/%d/full" : "/%d/delta", nFragment ), new CFragmentRequest( nFragment, nType ) );
|
|
}
|
|
}
|
|
|
|
void CDemoStreamHttp::ReleaseFragment( int nFragment )
|
|
{
|
|
UtlHashHandle_t it = m_FragmentCache.Find( nFragment );
|
|
if ( it != m_FragmentCache.InvalidHandle() )
|
|
{
|
|
m_FragmentCache[ it ].ResetBuffers();
|
|
m_FragmentCache.RemoveByHandle( it );
|
|
}
|
|
}
|
|
|
|
GotvHttpStreamId_t CDemoStreamHttp::GetStreamId( const char *pUrl )
|
|
{
|
|
GotvHttpStreamId_t out;
|
|
if ( !pUrl || !*pUrl )
|
|
return out;
|
|
const char *p = pUrl + V_strlen( pUrl ) - 1;
|
|
if ( !V_isdigit( *p ) )
|
|
return out;
|
|
out.m_nInstanceId = *p - '0';
|
|
|
|
p--;
|
|
if ( *p != 'i' )
|
|
return out;
|
|
|
|
out.m_nMatchId = 0;
|
|
uint64 digitPlace = 1;
|
|
while ( ( --p ) >= pUrl && V_isdigit( *p ) )
|
|
{
|
|
if ( out.m_nMatchId > uint64( -1ll ) / 10 )
|
|
break; // the number doesn't fit 64 bit, error out
|
|
out.m_nMatchId += ( *p - '0' ) * digitPlace;
|
|
digitPlace *= 10;
|
|
}
|
|
if ( *p != '/' )
|
|
{
|
|
// invalid matchid
|
|
out.m_nMatchId = 0;
|
|
}
|
|
return out;
|
|
}
|
|
|
|
IDemoStreamClient::DemoStreamReference_t CDemoStreamHttp::GetStreamStartReference( bool bLagCompensation /*= false */ )
|
|
{
|
|
IDemoStreamClient::DemoStreamReference_t start;
|
|
start.nTick = m_SyncResponse.nStartTick;
|
|
start.nFragment = m_SyncResponse.nFragment;
|
|
|
|
if ( bLagCompensation )
|
|
{
|
|
float flSkipSeconds = ( Plat_FloatTime() - m_SyncResponse.dPlatTimeReceived + m_SyncResponse.flReceiveAge );
|
|
if ( flSkipSeconds >= 0 && flSkipSeconds < 90 ) // if it's not too suspiciously long interval, we can try to compensate for it
|
|
{
|
|
int nTotalSkipTicks = int( flSkipSeconds * m_SyncResponse.flTicksPerSecond );
|
|
int nTicksPerFragment = int( m_SyncResponse.flKeyframeInterval * m_SyncResponse.flTicksPerSecond );
|
|
start.nSkipTicks = nTotalSkipTicks % nTicksPerFragment;
|
|
start.nTick += ( nTotalSkipTicks - start.nSkipTicks );
|
|
start.nFragment += nTotalSkipTicks / nTicksPerFragment;
|
|
}
|
|
else
|
|
start.nSkipTicks = 0;
|
|
}
|
|
else
|
|
{
|
|
start.nSkipTicks = int( m_SyncResponse.flReceiveAge * m_SyncResponse.flTicksPerSecond ); // Maybe GC should send rtdelay - desired_delay instead?
|
|
}
|
|
|
|
return start;
|
|
}
|
|
|
|
void CDemoStreamHttp::StopStreaming()
|
|
{
|
|
if ( m_nState != STATE_IDLE )
|
|
{
|
|
m_nState = STATE_IDLE;
|
|
if ( m_pClient )
|
|
{
|
|
m_pClient->OnDemoStreamStop();
|
|
}
|
|
}
|
|
|
|
m_dSyncTimeoutEnd = -1;
|
|
|
|
while ( m_PendingRequests.Count() )
|
|
m_PendingRequests.Tail()->Cancel();
|
|
|
|
m_pStreamSignup = NULL; // delete start Buffer_t
|
|
FOR_EACH_HASHTABLE( m_FragmentCache, it )
|
|
{
|
|
m_FragmentCache.Element( it ).ResetBuffers();
|
|
}
|
|
m_FragmentCache.Purge();
|
|
}
|
|
|
|
CDemoStreamHttp::Buffer_t * CDemoStreamHttp::GetFragmentBuffer( int nFragment , FragmentTypeEnum_t nFragmentType )
|
|
{
|
|
UtlHashHandle_t hFind = m_FragmentCache.Find( nFragment );
|
|
if ( hFind == m_FragmentCache.InvalidHandle() )
|
|
return NULL;
|
|
return m_FragmentCache[ hFind ].GetField( nFragmentType );
|
|
}
|
|
|
|
void CDemoStreamHttp::CSyncRequest::OnSuccess( const HTTPRequestCompleted_t * pResponse )
|
|
{
|
|
uint32 nBodySize;
|
|
if( !s_pSteamHTTP->GetHTTPResponseBodySize( pResponse->m_hRequest, &nBodySize ) || nBodySize >= 1024 )
|
|
{
|
|
DevMsg( "Broadcast sync: response buffer overflow (%d bytes)\n", nBodySize );
|
|
return;
|
|
};
|
|
|
|
char *pResponseBuffer = StackAlloc( char, nBodySize + 1 );
|
|
if ( !s_pSteamHTTP->GetHTTPResponseBodyData( pResponse->m_hRequest, ( uint8* )pResponseBuffer, nBodySize ) )
|
|
{
|
|
DevMsg( "Broadcast sync: cannot read response body\n" );
|
|
return;
|
|
}
|
|
pResponseBuffer[ nBodySize ] = '\0';
|
|
m_pParent->OnSync( pResponseBuffer, nBodySize, m_nResync );
|
|
}
|
|
|
|
|
|
void CDemoStreamHttp::CSyncRequest::OnFailure( const HTTPRequestCompleted_t * pResponse )
|
|
{
|
|
if ( !m_nResync || m_nResync > 5 )
|
|
{
|
|
CPendingRequest::OnFailure( pResponse );
|
|
}
|
|
else
|
|
{
|
|
DevMsg( "%d stream resync failed\n", m_nResync );
|
|
m_pParent->SendSync( m_nResync + 1 ); // retry a couple times
|
|
}
|
|
}
|
|
|
|
void CDemoStreamHttp::CPendingRequest::OnFailure( const HTTPRequestCompleted_t * pResponse )
|
|
{
|
|
if ( !pResponse )
|
|
{
|
|
DevMsg( "Broadcast IO error. Please try again later.\n" );
|
|
}
|
|
else
|
|
{
|
|
DevMsg( "Broadcast Streaming error %d\n", pResponse->m_eStatusCode );
|
|
}
|
|
m_pParent->StopStreaming();
|
|
}
|
|
|
|
void CDemoStreamHttp::CStartRequest::OnSuccess( const HTTPRequestCompleted_t * pResponse )
|
|
{
|
|
m_pParent->OnStart( pResponse->m_hRequest );
|
|
}
|
|
|
|
|
|
|
|
CDemoStreamHttp::Buffer_t * CDemoStreamHttp::MakeBuffer( HTTPRequestHandle hRequest )
|
|
{
|
|
uint32 nBodySize;
|
|
if ( !s_pSteamHTTP->GetHTTPResponseBodySize( hRequest, &nBodySize ) )
|
|
{
|
|
return NULL;
|
|
}
|
|
|
|
uint8 *pMemory = new uint8[ sizeof( Buffer_t ) + nBodySize + 1 ];
|
|
if ( !s_pSteamHTTP->GetHTTPResponseBodyData( hRequest, pMemory + sizeof( Buffer_t ), nBodySize ) )
|
|
{
|
|
delete[] pMemory;
|
|
return NULL;
|
|
}
|
|
pMemory[ sizeof( Buffer_t ) + nBodySize ] = '\0'; // in case we need to receive and parse some text-only packets in the future
|
|
Buffer_t* pBuffer = ( Buffer_t* )pMemory;
|
|
pBuffer->m_nRefCount = 0;
|
|
pBuffer->m_nSize = nBodySize;
|
|
return pBuffer;
|
|
}
|
|
|
|
|
|
void CDemoStreamHttp::SendGet( const char *pPath, CPendingRequest *pRequest )
|
|
{
|
|
HTTPRequestHandle hRequest = s_pSteamHTTP->CreateHTTPRequest( k_EHTTPMethodGET, m_Url + pPath );
|
|
s_pSteamHTTP->SetHTTPRequestNetworkActivityTimeout( hRequest, 30 );
|
|
const char *pOriginAuth = tv_playcast_origin_auth.GetString();
|
|
if ( pOriginAuth && *pOriginAuth )
|
|
{
|
|
if ( !s_pSteamHTTP->SetHTTPRequestHeaderValue( hRequest, "X-Origin-Auth", pOriginAuth ) )
|
|
{
|
|
Warning( "Cannot set http X-Origin-Auth for %s\n", pPath );
|
|
}
|
|
}
|
|
SteamAPICall_t hCall;
|
|
bool bSentOk = s_pSteamHTTP->SendHTTPRequest( hRequest, &hCall );
|
|
pRequest->Init( this, hRequest, hCall );
|
|
if ( bSentOk && hCall )
|
|
{
|
|
SteamAPI_RegisterCallResult( pRequest, hCall );
|
|
}
|
|
else
|
|
{
|
|
s_pSteamHTTP->ReleaseHTTPRequest( hRequest );
|
|
DevMsg( "Broadcast streaming: unexpected failure getting %s\n", pPath );
|
|
pRequest->OnFailure( NULL ); // IO failure
|
|
}
|
|
}
|
|
|
|
CDemoStreamHttp::Fragment_t & CDemoStreamHttp::Fragment( int nFragment )
|
|
{
|
|
UtlHashHandle_t it = m_FragmentCache.Insert( nFragment );
|
|
return m_FragmentCache[ it ];
|
|
}
|
|
|
|
|
|
CDemoStreamHttp::CPendingRequest::CPendingRequest() :
|
|
m_pParent( NULL ),
|
|
m_hRequest( INVALID_HTTPREQUEST_HANDLE ),
|
|
m_hCall( k_uAPICallInvalid )
|
|
{
|
|
m_iCallback = HTTPRequestCompleted_t::k_iCallback;
|
|
}
|
|
|
|
|
|
void CDemoStreamHttp::CPendingRequest::Init( CDemoStreamHttp *pParent, HTTPRequestHandle hRequest, SteamAPICall_t hCall )
|
|
{
|
|
m_pParent = pParent;
|
|
m_hRequest = hRequest;
|
|
m_hCall = hCall;
|
|
pParent->m_PendingRequests.AddToTail( this );
|
|
}
|
|
|
|
CDemoStreamHttp::CPendingRequest::~CPendingRequest()
|
|
{
|
|
}
|
|
|
|
void CDemoStreamHttp::CPendingRequest::Run( void *pvParam )
|
|
{
|
|
m_pParent->m_PendingRequests.FindAndFastRemove( this );
|
|
OnSuccess( ( HTTPRequestCompleted_t * )pvParam );
|
|
delete this;
|
|
}
|
|
|
|
void CDemoStreamHttp::CPendingRequest::Run( void *pvParam, bool bIOFailure, SteamAPICall_t hSteamAPICall )
|
|
{
|
|
m_pParent->m_PendingRequests.FindAndFastRemove( this );
|
|
if ( bIOFailure )
|
|
{
|
|
OnFailure( NULL );
|
|
}
|
|
else
|
|
{
|
|
EHTTPStatusCode nStatus = ( ( HTTPRequestCompleted_t * )pvParam )->m_eStatusCode;
|
|
Assert( ( ( HTTPRequestCompleted_t * )pvParam )->m_hRequest == m_hRequest );
|
|
if ( nStatus != k_EHTTPStatusCode200OK ) // we should always get a 200
|
|
{
|
|
OnFailure( ( HTTPRequestCompleted_t * )pvParam );
|
|
}
|
|
else
|
|
{
|
|
OnSuccess( ( HTTPRequestCompleted_t * )pvParam );
|
|
}
|
|
}
|
|
delete this;
|
|
}
|
|
|
|
void CDemoStreamHttp::CPendingRequest::Cancel()
|
|
{
|
|
SteamAPI_UnregisterCallResult( this, m_hCall );
|
|
s_pSteamHTTP->ReleaseHTTPRequest( m_hRequest );
|
|
m_pParent->m_PendingRequests.FindAndFastRemove( this );
|
|
OnFailure( NULL );
|
|
delete this;
|
|
}
|
|
|
|
void CDemoStreamHttp::CFragmentRequest::OnSuccess( const HTTPRequestCompleted_t * pResponse )
|
|
{
|
|
m_pParent->OnFragmentRequestSuccess( pResponse->m_hRequest, m_nFragment, m_nType );
|
|
}
|
|
|
|
static const char *s_pFragmentTypeName[ CDemoStreamHttp::FRAGMENT_COUNT ] =
|
|
{
|
|
"delta", "full"
|
|
};
|
|
|
|
|
|
void CDemoStreamHttp::CFragmentRequest::OnFailure( const HTTPRequestCompleted_t * pResponse )
|
|
{
|
|
if ( demo_debug.GetBool() )
|
|
DevMsg( "Failed to retrieve %s fragment %d\n", s_pFragmentTypeName[ m_nType ], m_nFragment );
|
|
m_pParent->OnFragmentRequestFailure( pResponse ? pResponse->m_eStatusCode : k_EHTTPStatusCodeInvalid, m_nFragment, m_nType );
|
|
// CPendingRequest::OnFailure( pResponse ); <-- the parent OnFail will stop streaming, and we don't want that because we'll retry this fragment or next for a few times before giving up
|
|
}
|
|
|
|
void CDemoStreamHttp::Fragment_t::ResetBuffers()
|
|
{
|
|
for ( int i = 0; i < FRAGMENT_COUNT; ++i )
|
|
{
|
|
if ( m_pField[ i ] )
|
|
{
|
|
Buffer_t::Release( m_pField[ i ] );
|
|
m_pField[ i ] = NULL;
|
|
}
|
|
}
|
|
}
|
|
|
|
void CDemoStreamHttp::Fragment_t::SetField( FragmentTypeEnum_t nFragment, Buffer_t *pBuffer )
|
|
{
|
|
if ( pBuffer )
|
|
Buffer_t::AddRef( pBuffer );
|
|
if ( m_pField[ nFragment ] )
|
|
Buffer_t::Release( m_pField[ nFragment ] );
|
|
m_pField[ nFragment ] = pBuffer;
|
|
}
|
|
|
|
void CDemoStreamHttp::SyncParams_t::PrintSyncRequest(char *buffer, int nBufferSize) const
|
|
{
|
|
if ( m_nStartFragment )
|
|
V_snprintf(buffer, nBufferSize, "/sync?fragment=%d", m_nStartFragment );
|
|
else
|
|
V_strncpy( buffer, "/sync", nBufferSize );
|
|
}
|