void CProcessInfo::UpdateDeinterlacingMethods(std::list<EINTERLACEMETHOD> &methods)
{
CSingleLock lock(m_videoCodecSection);
m_deintMethods = methods;
for (auto &deint : m_renderInfo.m_deintMethods)
{
if (!Supports(deint))
m_deintMethods.push_back(deint);
}
if (!Supports(EINTERLACEMETHOD::VS_INTERLACEMETHOD_NONE))
m_deintMethods.push_front(EINTERLACEMETHOD::VS_INTERLACEMETHOD_NONE);
}
void CWinRenderer::UpdateVideoFilter()
{
bool cmsChanged = m_cmsOn != m_colorManager->IsEnabled()
|| m_cmsOn && !m_colorManager->CheckConfiguration(m_cmsToken, m_iFlags);
cmsChanged &= m_clutLoaded;
if (m_scalingMethodGui == m_videoSettings.m_ScalingMethod
&& m_bFilterInitialized && !cmsChanged)
return;
m_bFilterInitialized = true;
m_scalingMethodGui = m_videoSettings.m_ScalingMethod;
m_scalingMethod = m_scalingMethodGui;
if (!Supports(m_scalingMethod))
{
CLog::Log(LOGWARNING, "%s: chosen scaling method %d is not supported by renderer", __FUNCTION__, static_cast<int>(m_scalingMethod));
m_scalingMethod = VS_SCALINGMETHOD_AUTO;
}
if (cmsChanged)
ColorManagmentUpdate();
if (cmsChanged || !m_outputShader)
{
m_outputShader = std::make_unique<COutputShader>();
if (!m_outputShader->Create(m_cmsOn, m_useDithering, m_ditherDepth, m_toneMapping))
{
CLog::Log(LOGDEBUG, "%s: Unable to create output shader.", __FUNCTION__);
m_outputShader.reset();
}
else if (m_pCLUTView && m_CLUTSize)
m_outputShader->SetCLUT(m_CLUTSize, m_pCLUTView.Get());
}
RESOLUTION_INFO res = CServiceBroker::GetWinSystem()->GetGfxContext().GetResInfo();
if (!res.bFullScreen)
res = CServiceBroker::GetWinSystem()->GetGfxContext().GetResInfo(RES_DESKTOP);
m_destWidth = res.iScreenWidth;
m_destHeight = res.iScreenHeight;
switch(m_renderMethod)
{
case RENDER_SW:
SelectSWVideoFilter();
break;
case RENDER_PS:
case RENDER_DXVA:
SelectPSVideoFilter();
UpdatePSVideoFilter();
break;
default:
return;
}
}
void CWinRenderer::SelectPSVideoFilter()
{
m_bUseHQScaler = false;
switch (m_scalingMethod)
{
case VS_SCALINGMETHOD_NEAREST:
case VS_SCALINGMETHOD_LINEAR:
break;
case VS_SCALINGMETHOD_CUBIC:
case VS_SCALINGMETHOD_LANCZOS2:
case VS_SCALINGMETHOD_SPLINE36_FAST:
case VS_SCALINGMETHOD_LANCZOS3_FAST:
m_bUseHQScaler = true;
break;
case VS_SCALINGMETHOD_SPLINE36:
case VS_SCALINGMETHOD_LANCZOS3:
m_bUseHQScaler = true;
break;
case VS_SCALINGMETHOD_SINC8:
case VS_SCALINGMETHOD_NEDI:
CLog::Log(LOGERROR, "D3D: TODO: This scaler has not yet been implemented");
break;
case VS_SCALINGMETHOD_BICUBIC_SOFTWARE:
case VS_SCALINGMETHOD_LANCZOS_SOFTWARE:
case VS_SCALINGMETHOD_SINC_SOFTWARE:
CLog::Log(LOGERROR, "D3D: TODO: Software scaling has not yet been implemented");
break;
default:
break;
}
if (m_scalingMethod == VS_SCALINGMETHOD_AUTO)
{
bool scaleSD = m_sourceHeight < 720 && m_sourceWidth < 1280;
bool scaleUp = static_cast<int>(m_sourceHeight) < g_graphicsContext.GetHeight()
&& static_cast<int>(m_sourceWidth) < g_graphicsContext.GetWidth();
bool scaleFps = m_fps < (g_advancedSettings.m_videoAutoScaleMaxFps + 0.01f);
if (m_renderMethod == RENDER_DXVA)
{
m_scalingMethod = VS_SCALINGMETHOD_DXVA_HARDWARE;
m_bUseHQScaler = false;
}
else if (scaleSD && scaleUp && scaleFps && Supports(VS_SCALINGMETHOD_LANCZOS3_FAST))
{
m_scalingMethod = VS_SCALINGMETHOD_LANCZOS3_FAST;
m_bUseHQScaler = true;
}
}
if (m_renderOrientation)
m_bUseHQScaler = false;
}
bool SPropertyEditorAsset::Supports( const TSharedRef< FPropertyEditor >& InPropertyEditor )
{
const TSharedRef< FPropertyNode > PropertyNode = InPropertyEditor->GetPropertyNode();
if( PropertyNode->HasNodeFlags(EPropertyNodeFlags::EditInline) )
{
return false;
}
return Supports(PropertyNode->GetProperty());
}
bool
WMFDecoderModule::SupportsMimeType(const nsACString& aMimeType,
DecoderDoctorDiagnostics* aDiagnostics) const
{
UniquePtr<TrackInfo> trackInfo = CreateTrackInfoWithMIMEType(aMimeType);
if (!trackInfo) {
return false;
}
return Supports(*trackInfo, aDiagnostics);
}
void setup(const SkPixmap& dst, int left, int top, const SkPaint& paint) override {
SkASSERT(Supports(dst, fSource, paint));
this->INHERITED::setup(dst, left, top, paint);
SkBlendMode mode = paint.getBlendMode();
SkASSERT(mode == SkBlendMode::kSrcOver || mode == SkBlendMode::kSrc);
if (mode == SkBlendMode::kSrcOver && !fSource.isOpaque()) {
fUseMemcpy = false;
}
}
void CProcessInfo::UpdateRenderInfo(CRenderInfo &info)
{
CSingleLock lock(m_renderSection);
m_renderInfo = info;
for (auto &deint : m_renderInfo.m_deintMethods)
{
if (!Supports(deint))
m_deintMethods.push_back(deint);
}
}
void CVDPAU::SetHWUpscaling()
{
#ifdef VDP_VIDEO_MIXER_FEATURE_HIGH_QUALITY_SCALING_L1
if(!Supports(VDP_VIDEO_MIXER_FEATURE_HIGH_QUALITY_SCALING_L1) || !upScale)
return;
VdpVideoMixerFeature feature[] = { VDP_VIDEO_MIXER_FEATURE_HIGH_QUALITY_SCALING_L1 };
VdpStatus vdp_st;
VdpBool enabled[]={1};
vdp_st = vdp_video_mixer_set_feature_enables(videoMixer, ARSIZE(feature), feature, enabled);
CheckStatus(vdp_st, __LINE__);
#endif
}
bool CVDPAU::Supports(EINTERLACEMETHOD method)
{
if(method == VS_INTERLACEMETHOD_VDPAU_BOB
|| method == VS_INTERLACEMETHOD_AUTO)
return true;
for(SInterlaceMapping* p = g_interlace_mapping; p->method != VS_INTERLACEMETHOD_NONE; p++)
{
if(p->method == method)
return Supports(p->feature);
}
return false;
}
void setup(const SkPixmap& dst, int left, int top, const SkPaint& paint) override {
SkASSERT(Supports(dst, fSource, paint));
this->INHERITED::setup(dst, left, top, paint);
SkXfermode::Mode mode;
if (!SkXfermode::AsMode(paint.getXfermode(), &mode)) {
SkFAIL("Should never happen.");
}
SkASSERT(mode == SkXfermode::kSrcOver_Mode || mode == SkXfermode::kSrc_Mode);
if (mode == SkXfermode::kSrcOver_Mode && !fSource.isOpaque()) {
fUseMemcpy = false;
}
}
void CWinRenderer::SelectPSVideoFilter()
{
m_bUseHQScaler = false;
switch (m_scalingMethod)
{
case VS_SCALINGMETHOD_NEAREST:
case VS_SCALINGMETHOD_LINEAR:
break;
case VS_SCALINGMETHOD_CUBIC:
case VS_SCALINGMETHOD_LANCZOS2:
case VS_SCALINGMETHOD_LANCZOS3_FAST:
m_bUseHQScaler = true;
break;
case VS_SCALINGMETHOD_LANCZOS3:
m_bUseHQScaler = true;
break;
case VS_SCALINGMETHOD_SINC8:
case VS_SCALINGMETHOD_NEDI:
CLog::Log(LOGERROR, "D3D: TODO: This scaler has not yet been implemented");
break;
case VS_SCALINGMETHOD_BICUBIC_SOFTWARE:
case VS_SCALINGMETHOD_LANCZOS_SOFTWARE:
case VS_SCALINGMETHOD_SINC_SOFTWARE:
CLog::Log(LOGERROR, "D3D: TODO: Software scaling has not yet been implemented");
break;
default:
break;
}
// Scaler auto + SD + capable HW -> Lanczos3 optim. Otherwise bilinear.
if(m_scalingMethod == VS_SCALINGMETHOD_AUTO
&& m_sourceWidth < 1280
&& Supports(VS_SCALINGMETHOD_LANCZOS3_FAST))
{
m_scalingMethod = VS_SCALINGMETHOD_LANCZOS3_FAST;
m_bUseHQScaler = true;
}
}
void CWinRenderer::SelectSWVideoFilter()
{
switch (m_scalingMethod)
{
case VS_SCALINGMETHOD_AUTO:
case VS_SCALINGMETHOD_LINEAR:
if (Supports(VS_SCALINGMETHOD_LINEAR))
{
m_TextureFilter = D3DTEXF_LINEAR;
break;
}
// fall through for fallback
case VS_SCALINGMETHOD_NEAREST:
default:
m_TextureFilter = D3DTEXF_POINT;
break;
}
}
void CVDPAU::SetSharpness()
{
if(!Supports(VDP_VIDEO_MIXER_FEATURE_SHARPNESS))
return;
VdpVideoMixerFeature feature[] = { VDP_VIDEO_MIXER_FEATURE_SHARPNESS };
VdpVideoMixerAttribute attributes[] = { VDP_VIDEO_MIXER_ATTRIBUTE_SHARPNESS_LEVEL };
VdpStatus vdp_st;
if (!g_settings.m_currentVideoSettings.m_Sharpness)
{
VdpBool enabled[]={0};
vdp_st = vdp_video_mixer_set_feature_enables(videoMixer, ARSIZE(feature), feature, enabled);
CheckStatus(vdp_st, __LINE__);
return;
}
VdpBool enabled[]={1};
vdp_st = vdp_video_mixer_set_feature_enables(videoMixer, ARSIZE(feature), feature, enabled);
CheckStatus(vdp_st, __LINE__);
void* sh[] = { &g_settings.m_currentVideoSettings.m_Sharpness };
CLog::Log(LOGNOTICE,"Setting Sharpness to %f",g_settings.m_currentVideoSettings.m_Sharpness);
vdp_st = vdp_video_mixer_set_attribute_values(videoMixer, ARSIZE(attributes), attributes, sh);
CheckStatus(vdp_st, __LINE__);
}
void CVDPAU::SetNoiseReduction()
{
if(!Supports(VDP_VIDEO_MIXER_FEATURE_NOISE_REDUCTION))
return;
VdpVideoMixerFeature feature[] = { VDP_VIDEO_MIXER_FEATURE_NOISE_REDUCTION };
VdpVideoMixerAttribute attributes[] = { VDP_VIDEO_MIXER_ATTRIBUTE_NOISE_REDUCTION_LEVEL };
VdpStatus vdp_st;
if (!g_settings.m_currentVideoSettings.m_NoiseReduction)
{
VdpBool enabled[]= {0};
vdp_st = vdp_video_mixer_set_feature_enables(videoMixer, ARSIZE(feature), feature, enabled);
CheckStatus(vdp_st, __LINE__);
return;
}
VdpBool enabled[]={1};
vdp_st = vdp_video_mixer_set_feature_enables(videoMixer, ARSIZE(feature), feature, enabled);
CheckStatus(vdp_st, __LINE__);
void* nr[] = { &g_settings.m_currentVideoSettings.m_NoiseReduction };
CLog::Log(LOGNOTICE,"Setting Noise Reduction to %f",g_settings.m_currentVideoSettings.m_NoiseReduction);
vdp_st = vdp_video_mixer_set_attribute_values(videoMixer, ARSIZE(attributes), attributes, nr);
CheckStatus(vdp_st, __LINE__);
}
void setup(const SkPixmap& dst, int left, int top, const SkPaint& paint) override {
SkASSERT(Supports(dst, fSource, paint));
this->INHERITED::setup(dst, left, top, paint);
}
inline void CBaseRenderer::ReorderDrawPoints()
{
// 0 - top left, 1 - top right, 2 - bottom right, 3 - bottom left
float origMat[4][2] = {{m_destRect.x1, m_destRect.y1},
{m_destRect.x2, m_destRect.y1},
{m_destRect.x2, m_destRect.y2},
{m_destRect.x1, m_destRect.y2}};
bool changeAspect = false;
int pointOffset = 0;
switch (m_renderOrientation)
{
case 90:
pointOffset = 1;
changeAspect = true;
break;
case 180:
pointOffset = 2;
break;
case 270:
pointOffset = 3;
changeAspect = true;
break;
}
// if renderer doesn't support rotation
// treat orientation as 0 degree so that
// ffmpeg might handle it.
if (!Supports(RENDERFEATURE_ROTATION))
{
pointOffset = 0;
changeAspect = false;
}
int diff = (int) ((m_destRect.Height() - m_destRect.Width()) / 2);
for (int destIdx=0, srcIdx=pointOffset; destIdx < 4; destIdx++)
{
m_rotatedDestCoords[destIdx].x = origMat[srcIdx][0];
m_rotatedDestCoords[destIdx].y = origMat[srcIdx][1];
if (changeAspect)
{
switch (srcIdx)
{
case 0:
m_rotatedDestCoords[destIdx].x -= diff;
m_rotatedDestCoords[destIdx].y += diff;
break;
case 1:
m_rotatedDestCoords[destIdx].x += diff;
m_rotatedDestCoords[destIdx].y += diff;
break;
case 2:
m_rotatedDestCoords[destIdx].x += diff;
m_rotatedDestCoords[destIdx].y -= diff;
break;
case 3:
m_rotatedDestCoords[destIdx].x -= diff;
m_rotatedDestCoords[destIdx].y -= diff;
break;
}
}
srcIdx++;
srcIdx = srcIdx % 4;
}
}