->GetGpuDriverBugWorkarounds())) {
weak_this_ = weak_factory_.GetWeakPtr();
- plane_collection_manager_ =
- reinterpret_cast<ui::EflSurfaceFactory*>(
- ui::OzonePlatform::GetInstance()->GetSurfaceFactoryOzone())
- ->PlaneCollectionManager();
+ auto* efl_surface_factory = reinterpret_cast<ui::EflSurfaceFactory*>(
+ ui::OzonePlatform::GetInstance()->GetSurfaceFactoryOzone());
+ plane_collection_manager_ = efl_surface_factory->PlaneCollectionManager();
output_surface_manager_ =
- reinterpret_cast<ui::EflSurfaceFactory*>(
- ui::OzonePlatform::GetInstance()->GetSurfaceFactoryOzone())
- ->GetOutputSurfaceManager(rendering_workarounds_);
+ efl_surface_factory->GetOutputSurfaceManager(rendering_workarounds_);
+ efl_surface_factory->SetRenderingWorkarounds(rendering_workarounds_);
strategies_.push_back(std::make_unique<OverlayStrategyFullscreen>(this));
// TODO(vdwasm) VDGAME-336 - Disabling this strategy since reordering planes
"ttvd_prefer_manual_rendering_for_low_latency",
"ttvd_disable_faster_decoder_selection"
]
+ },
+ {
+ "id": 414,
+ "description": "Disable manual rendering within TTVD, it struggles with color conversion when starting",
+ "os": {
+ "type": "linux"
+ },
+ "machine_model_name": ["OSCARP"],
+ "features": [
+ "ttvd_disable_manual_rendering"
+ ]
+ },
+ {
+ "id": 415,
+ "description": "Disable manual rendering within TTVD, it might cause issue with other video playback",
+ "os": {
+ "type": "linux"
+ },
+ "machine_model_name": ["ROSEP"],
+ "features": [
+ "ttvd_disable_manual_rendering"
+ ]
}
]
}
ttvd_force_frames_rendering
ttvd_disable_buffer_parallel_copy
ttvd_disable_faster_decoder_selection
+ttvd_disable_manual_rendering
ttvd_prefer_manual_rendering_for_low_latency
scalarize_vec_and_mat_constructor_args
set_zero_level_before_generating_mipmap
gfx::BufferFormat format,
gfx::NativePixmapHandle handle) {
return base::MakeRefCounted<ui::TizenNativePixmap>(
- this, std::move(handle), size, plane_collection_manager_);
+ this, std::move(handle), size, plane_collection_manager_,
+ rendering_workarounds_);
}
scoped_refptr<OutputSurfaceProxy> EflSurfaceFactory::GetSurface(
return output_surface_manager_;
}
+void EflSurfaceFactory::SetRenderingWorkarounds(
+ const RenderingWorkarounds& rendering_workarounds) {
+ rendering_workarounds_ = rendering_workarounds;
+}
+
#endif // defined(TIZEN_TV_UPSTREAM_MULTIMEDIA)
} // namespace ui
scoped_refptr<OutputSurfaceManager> GetOutputSurfaceManager(
const RenderingWorkarounds& rendering_workarounds);
+
+ void SetRenderingWorkarounds(
+ const RenderingWorkarounds& rendering_workarounds);
#endif
private:
base::Lock output_surface_manager_lock_;
scoped_refptr<ui::OutputSurfaceManager> output_surface_manager_
GUARDED_BY(output_surface_manager_lock_);
+ RenderingWorkarounds rendering_workarounds_;
#endif
std::unique_ptr<GLOzone> egl_implementation_;
bool OutputSurfaceImpl::SelectRenderingMethod(
const gfx::OverlayRenderData& render_data) {
const bool supports_software_rendering =
- IsSoftwareRenderingCapable(render_data);
+ IsSoftwareRenderingCapable(render_data) &&
+ !rendering_workarounds_.disable_manual_rendering;
const bool supports_direct_rendering = render_data.plane_id != 0;
const bool force_software_rendering =
supports_software_rendering && render_data.low_latency &&
gpu_driver_workarounds.limit_rotation_to_single_plane;
result.prefer_manual_rendering_for_low_latency =
gpu_driver_workarounds.ttvd_prefer_manual_rendering_for_low_latency;
+ result.disable_manual_rendering =
+ gpu_driver_workarounds.ttvd_disable_manual_rendering;
return result;
}
bool replace_rotate_180_with_hv_flip = false;
bool limit_rotation_to_single_plane = false;
bool prefer_manual_rendering_for_low_latency = false;
+ bool disable_manual_rendering = false;
};
RenderingWorkarounds ConvertToRenderingWorkarounds(
ui::EflSurfaceFactory* surface_factory,
gfx::NativePixmapHandle handle,
gfx::Size size,
- scoped_refptr<gfx::TizenPlaneCollectionManager> plane_collection_manager)
+ scoped_refptr<gfx::TizenPlaneCollectionManager> plane_collection_manager,
+ const RenderingWorkarounds& rendering_workarounds)
: handle_(std::move(handle)),
size_(size),
plane_collection_manager_(plane_collection_manager),
- surface_factory_(surface_factory) {}
+ surface_factory_(surface_factory),
+ rendering_workarounds_(rendering_workarounds) {}
bool TizenNativePixmap::AreDmaBufFdsValid() const {
return true;
#include "ui/gfx/native_pixmap.h"
#include "ui/gfx/tizen_plane_collection_manager.h"
+#include "ui/ozone/platform/efl/rendering_workarounds.h"
namespace ui {
ui::EflSurfaceFactory* surface_factory,
gfx::NativePixmapHandle handle,
gfx::Size size,
- scoped_refptr<gfx::TizenPlaneCollectionManager> plane_collection_manager);
+ scoped_refptr<gfx::TizenPlaneCollectionManager> plane_collection_manager,
+ const RenderingWorkarounds& rendering_workarounds);
TizenNativePixmap(const TizenNativePixmap&) = delete;
TizenNativePixmap& operator=(const TizenNativePixmap&) = delete;
bool SupportsOverlayPlane() const {
return handle_.picture_id.has_value() ||
- handle_.modifier == kFormatModifierLinear;
+ (handle_.modifier == kFormatModifierLinear &&
+ !rendering_workarounds_.disable_manual_rendering);
}
private:
const gfx::Size size_;
scoped_refptr<gfx::TizenPlaneCollectionManager> plane_collection_manager_;
ui::EflSurfaceFactory* surface_factory_;
+ RenderingWorkarounds rendering_workarounds_;
};
} // namespace ui