UINT CDisplayDX::GetAdapterOrdinal()
{
if (m_pDirect3DInstance == NULL || (g_Settings()->Get( "settings.player.force_default_adapter", false ) == true))
{
g_Log->Error( "Using default adapter for screen %d", m_DesiredScreenID );
return D3DADAPTER_DEFAULT;
}
MONITORINFO monitorInfo;
for( DWORD iMonitor = 0; iMonitor < m_dwNumMonitors; iMonitor++ )
{
if (iMonitor == m_DesiredScreenID)
{
MonitorInfo *pMonitorInfo = &m_Monitors[iMonitor];
monitorInfo.cbSize = sizeof(MONITORINFO);
if ( GetMonitorInfo( pMonitorInfo->hMonitor, &monitorInfo ) != 0 )
for ( UINT iAdapter = 0; iAdapter < m_pDirect3DInstance->GetAdapterCount(); ++iAdapter )
{
if ( m_pDirect3DInstance->GetAdapterMonitor(iAdapter) == pMonitorInfo->hMonitor )
{
g_Log->Info( "Using adapter %d for screen %d", iAdapter, m_DesiredScreenID );
return iAdapter;
}
}
}
}
g_Log->Info( "Using default adapter for screen %d", m_DesiredScreenID );
return D3DADAPTER_DEFAULT;
}
/*
Start.
Start decoding playlist.
*/
bool CContentDecoder::Start()
{
if( m_spPlaylist == NULL )
{
g_Log->Warning( "No playlist..." );
return false;
}
//abs is a protection against malicious negative numbers giving large integer when converted to uint32
m_LoopIterations = static_cast<uint32>(g_Settings()->Get( "settings.player.LoopIterations", 2 ));
// Start by opening, so we have a context to work with.
m_bStop = false;
m_pNextSheepThread = new thread( bind( &CContentDecoder::CalculateNextSheep, this ) );
#ifdef WIN32
SetThreadPriority( (HANDLE)m_pNextSheepThread->native_handle(), THREAD_PRIORITY_BELOW_NORMAL );
SetThreadPriorityBoost( (HANDLE)m_pNextSheepThread->native_handle(), TRUE );
#else
struct sched_param sp;
sp.sched_priority = 8; //Foreground NORMAL_PRIORITY_CLASS - THREAD_PRIORITY_BELOW_NORMAL
pthread_setschedparam( (pthread_t)m_pNextSheepThread->native_handle(), SCHED_RR, &sp );
#endif
while ( Initialized() == false )
thread::sleep( get_system_time() + posix_time::milliseconds(100) );
m_pDecoderThread = new thread( bind( &CContentDecoder::ReadPackets, this ) );
int retry = 0;
CVideoFrame *tmp = NULL;
while ( retry < 10 && !m_FrameQueue.peek( tmp, false ) && !m_bStop)
{
thread::sleep( get_system_time() + posix_time::milliseconds(100) );
retry++;
}
if (tmp == NULL)
return false;
return true;
}
/*
CContentDecoder.
*/
CContentDecoder::CContentDecoder( spCPlaylist _spPlaylist, bool _bStartByRandom, bool _bCalculateTransitions, const uint32 _queueLenght, AVPixelFormat _wantedFormat )
{
g_Log->Info( "CContentDecoder()" );
m_FadeCount = static_cast<uint32>(g_Settings()->Get("settings.player.fadecount", 30));
// We want errors!
av_log_set_level( AV_LOG_ERROR );
// Register all formats and codecs.
av_register_all();
m_pScaler = NULL;
m_ScalerWidth = 0;
m_ScalerHeight = 0;
m_bStartByRandom = _bStartByRandom;
m_bCalculateTransitions = _bCalculateTransitions;
m_pDecoderThread = NULL;
m_FrameQueue.setMaxQueueElements(_queueLenght);
m_NextSheepQueue.setMaxQueueElements(10);
m_WantedPixelFormat = _wantedFormat;
m_bStop = true;
m_spPlaylist = _spPlaylist;
m_bForceNext = false;
m_sharedFrame = NULL;
m_Initialized = false;
m_NoSheeps = true;
m_FadeIn = m_FadeCount;
m_FadeOut = 0;
m_prevLast = 0;
m_MainVideoInfo = NULL;//new sMainVideoInfo();
m_SecondVideoInfo = NULL;
}
bool CContentDownloader::Startup( const bool _bPreview, bool _bReadOnlyInstance )
{
g_Log->Info( "Attempting to start contentdownloader...", _bPreview );
Shepherd::initializeShepherd();
Shepherd::setRedirectServerName( g_Settings()->Get( "settings.content.redirectserver", std::string(REDIRECT_SERVER) ).c_str() );
std::string root = g_Settings()->Get( "settings.content.sheepdir", g_Settings()->Root() + "content" );
if (root.empty())
{
root = g_Settings()->Root() + "content";
g_Settings()->Set( "settings.content.sheepdir", root );
}
Shepherd::setRootPath( root.c_str() );
Shepherd::setCacheSize( g_Settings()->Get( "settings.content.cache_size", 2000 ), 0 );
Shepherd::setCacheSize( g_Settings()->Get( "settings.content.cache_size_gold", 2000 ), 1 );
if (g_Settings()->Get( "settings.content.unlimited_cache", true) == true)
Shepherd::setCacheSize( 0, 0 );
if (g_Settings()->Get( "settings.content.unlimited_cache_gold", true) == true)
Shepherd::setCacheSize( 0, 1 );
Shepherd::setPassword( g_Settings()->Get( "settings.content.password_md5", std::string("") ).c_str() );
Shepherd::setUniqueID( g_Settings()->Get( "settings.content.unique_id", generateID() ).c_str() );
Shepherd::setUseProxy( g_Settings()->Get( "settings.content.use_proxy", false ) );
Shepherd::setRegistered( g_Settings()->Get( "settings.content.registered", false ) );
Shepherd::setProxy( g_Settings()->Get( "settings.content.proxy", std::string("") ).c_str() );
Shepherd::setProxyUserName( g_Settings()->Get( "settings.content.proxy_username", std::string("") ).c_str() );
Shepherd::setProxyPassword( g_Settings()->Get( "settings.content.proxy_password", std::string("") ).c_str() );
Shepherd::setSaveFrames( g_Settings()->Get( "settings.generator.save_frames", false ) );
SheepGenerator::setNickName( g_Settings()->Get( "settings.generator.nickname", std::string("") ).c_str() );
SheepGenerator::setURL( g_Settings()->Get( "settings.generator.user_url", std::string("") ).c_str() );
m_gDownloader = NULL;
if( g_Settings()->Get( "settings.content.download_mode", true ) && _bReadOnlyInstance == false)
{
m_gDownloader = new SheepDownloader();
g_Log->Info( "Starting download thread..." );
m_gDownloadThread = new boost::thread( boost::bind( &SheepDownloader::shepherdCallback, m_gDownloader ) );
#ifdef WIN32
SetThreadPriority( (HANDLE)m_gDownloadThread->native_handle(), THREAD_PRIORITY_BELOW_NORMAL );
SetThreadPriorityBoost( (HANDLE)m_gDownloadThread->native_handle(), TRUE );
#else
struct sched_param sp;
sp.sched_priority = 6; //Background NORMAL_PRIORITY_CLASS - THREAD_PRIORITY_BELOW_NORMAL
pthread_setschedparam( (pthread_t)m_gDownloadThread->native_handle(), SCHED_RR, &sp );
#endif
}
else
g_Log->Warning( "Downloading disabled." );
if( g_Settings()->Get( "settings.generator.enabled", true ) && _bReadOnlyInstance == false)
{
// Create the generators based on the number of processors.
uint32 ncpus = 1;
if( g_Settings()->Get( "settings.generator.all_cores", false ) )
{
#ifdef WIN32
SYSTEM_INFO sysInfo;
GetSystemInfo( &sysInfo );
ncpus = (uint32)sysInfo.dwNumberOfProcessors;
#else
#ifdef MAC
ncpus = static_cast<uint32>(MPProcessors());
#else
#ifdef LINUX_GNU
ncpus = sysconf( _SC_NPROCESSORS_ONLN );
#endif
#endif
#endif
}
if (ncpus > 1)
--ncpus;
uint32 i;
for( i=0; i<ncpus; i++ )
{
g_Log->Info( "Starting generator for core %d...", i );
gGenerators.push_back( new SheepGenerator() );
gGenerators[i]->setGeneratorId( i );
}
g_Log->Info( "Starting generator threads..." );
for( i=0; i<gGenerators.size(); i++ )
{
gGeneratorThreads.push_back( new boost::thread( boost::bind( &SheepGenerator::shepherdCallback, gGenerators[i] ) ) );
#ifdef WIN32
SetThreadPriority( (HANDLE)gGeneratorThreads[i]->native_handle(), THREAD_PRIORITY_IDLE );
SetThreadPriorityBoost( (HANDLE)gGeneratorThreads[i]->native_handle(), FALSE );
#else
struct sched_param sp;
sp.sched_priority = 1; //THREAD_PRIORITY_IDLE - THREAD_PRIORITY_IDLE
pthread_setschedparam( (pthread_t)gGeneratorThreads[i]->native_handle(), SCHED_RR, &sp );
#endif
}
}
else
g_Log->Warning( "Generators disabled..." );
g_Log->Info( "...success" );
return true;
}
bool CDisplayDX::InitDX9()
{
if( m_pDirect3DInstance == NULL )
{
g_Log->Error( "Couldn't initialize Direct3D\nMake sure you have DirectX 9.0c or later installed." );
return false;
} else
g_Log->Info( "Direct3D Initialized from old IDirect3D9 object" );
memset( &m_PresentationParams, 0, sizeof(m_PresentationParams) );
m_PresentationParams.BackBufferFormat = D3DFMT_X8R8G8B8;
if (g_Settings()->Get( "settings.player.MultiDisplayMode", 0 ) != 2 && g_Settings()->Get( "settings.player.force_windowed_directx", true ) == true)
m_PresentationParams.Windowed = TRUE;
else
m_PresentationParams.Windowed = !m_bFullScreen;
D3DDISPLAYMODE dm = {0};
if ( m_bFullScreen && m_pDirect3DInstance->GetAdapterDisplayMode( GetAdapterOrdinal(), &dm ) == D3D_OK )
{
m_PresentationParams.BackBufferWidth = dm.Width;
m_PresentationParams.BackBufferHeight = dm.Height;
} else
{
m_PresentationParams.BackBufferWidth = m_Width;
m_PresentationParams.BackBufferHeight = m_Height;
}
g_Log->Info( "Using backbuffer w=%d h=%d", m_PresentationParams.BackBufferWidth, m_PresentationParams.BackBufferHeight);
m_PresentationParams.BackBufferCount = 1;
m_PresentationParams.hDeviceWindow = m_WindowHandle;
m_PresentationParams.FullScreen_RefreshRateInHz = D3DPRESENT_RATE_DEFAULT;
if (g_Settings()->Get( "settings.player.vbl_sync", false ) == true)
m_PresentationParams.PresentationInterval = D3DPRESENT_INTERVAL_ONE;
else
m_PresentationParams.PresentationInterval = D3DPRESENT_INTERVAL_IMMEDIATE;
m_PresentationParams.SwapEffect = D3DSWAPEFFECT_DISCARD;
m_PresentationParams.EnableAutoDepthStencil = false;
m_PresentationParams.MultiSampleType = D3DMULTISAMPLE_NONE;
D3DCAPS9 caps;
DWORD dwVertexProcessing = 0;
m_pDirect3DInstance->GetDeviceCaps(0, D3DDEVTYPE_HAL, &caps);
if ( caps.VertexShaderVersion >= D3DVS_VERSION(2,0) )
m_Shader20 = true;
if (caps.DevCaps & D3DDEVCAPS_HWTRANSFORMANDLIGHT)
{
if ( caps.VertexShaderVersion < D3DVS_VERSION(1,1) )
{
dwVertexProcessing = D3DCREATE_MIXED_VERTEXPROCESSING;
g_Log->Info( "DX: Mixed vertex processing" );
m_Shader20 = false;
}
else
{
dwVertexProcessing = D3DCREATE_HARDWARE_VERTEXPROCESSING;
g_Log->Info( "DX: Hardware vertex processing" );
m_Shader20 = true;
}
}
else
{
dwVertexProcessing = D3DCREATE_SOFTWARE_VERTEXPROCESSING;
g_Log->Info( "DX: Software vertex processing" );
m_Shader20 = false;
}
HRESULT devresult = m_pDirect3DInstance->CreateDevice( m_bFullScreen ? GetAdapterOrdinal() : D3DADAPTER_DEFAULT, D3DDEVTYPE_HAL, (gl_hFocusWindow == NULL) ? m_WindowHandle : gl_hFocusWindow, D3DCREATE_FPU_PRESERVE | dwVertexProcessing, &m_PresentationParams, &m_pDevice);
/* UINT adapterid = 0;
for (adapterid = 0; adapterid < m_pDirect3D->GetAdapterCount(); ++adapterid)
{
D3DADAPTER_IDENTIFIER9 adapterid9;
m_pDirect3D->GetAdapterIdentifier(adapterid, 0, &adapterid9);
if (strstr(adapterid9.Description, "PerfHUD") != 0)
break;
}
HRESULT devresult = m_pDirect3D->CreateDevice( adapterid, D3DDEVTYPE_REF, m_WindowHandle, D3DCREATE_FPU_PRESERVE | dwVertexProcessing, &m_PresentationParams, &m_pDevice);*/
if(devresult != D3D_OK )
{
g_Log->Error( "Failed to create Direct3D 9 device" );
switch (devresult)
{
case D3DERR_DEVICELOST:
g_Log->Info( "CreateDevice returned D3DERR_DEVICELOST" );
break;
case D3DERR_INVALIDCALL:
g_Log->Info( "CreateDevice returned D3DERR_INVALIDCALL" );
break;
case D3DERR_NOTAVAILABLE:
g_Log->Info( "CreateDevice returned D3DERR_NOTAVAILABLE" );
break;
case D3DERR_OUTOFVIDEOMEMORY:
g_Log->Info( "CreateDevice returned D3DERR_OUTOFVIDEOMEMORY" );
break;
default:
g_Log->Info( "CreateDevice returned %X", devresult );
break;
};
return false;
}
if (gl_hFocusWindow == NULL && m_bFullScreen == true)
{
g_Log->Info( "gl_hFocusWindow = m_WindowHandle" );
gl_hFocusWindow = m_WindowHandle;
}
return true;
}
