diff --git a/Modules/Core/CMakeLists.txt b/Modules/Core/CMakeLists.txt
index 6f3655dbe9..34a24839c4 100644
--- a/Modules/Core/CMakeLists.txt
+++ b/Modules/Core/CMakeLists.txt
@@ -1,75 +1,74 @@
 set(TOOL_CPPS "")
 
 # temporary suppress warnings in the following files until image accessors are fully integrated.
 set_source_files_properties( src/DataManagement/mitkImage.cpp COMPILE_FLAGS -DMITK_NO_DEPRECATED_WARNINGS )
 set_source_files_properties( src/Controllers/mitkSliceNavigationController.cpp COMPILE_FLAGS -DMITK_NO_DEPRECATED_WARNINGS )
 
 mitk_create_module(
   INCLUDE_DIRS
     PUBLIC
       ${MITK_BINARY_DIR}
     PRIVATE
       src/Algorithms
       src/Controllers
       src/DataManagement
       src/Interactions
       src/IO
       src/Rendering
   DEPENDS
     PUBLIC
       mbilog
       CppMicroServices
   PACKAGE_DEPENDS
     PUBLIC
       Boost
       ITK|IOImageBase+SpatialObjects+Statistics
       #ITK|Statistics+Transform
       VTK|FiltersTexture+FiltersParallel+ImagingStencil+ImagingMath+InteractionStyle+RenderingOpenGL2+RenderingVolumeOpenGL2+RenderingFreeType+RenderingLabel+InteractionWidgets+IOGeometry+IOImage+IOXML
     PRIVATE
       ITK|IOBioRad+IOBMP+IOBruker+IOCSV+IOGDCM+IOGE+IOGIPL+IOHDF5+IOIPL+IOJPEG+IOJPEG2000+IOLSM+IOMesh+IOMeta+IOMINC+IOMRC+IONIFTI+IONRRD+IOPNG+IOSiemens+IOSpatialObjects+IOStimulate+IOTIFF+IOTransformBase+IOTransformHDF5+IOTransformInsightLegacy+IOTransformMatlab+IOVTK+IOXML
-      Poco|Foundation
       nlohmann_json
       tinyxml2
       ${optional_private_package_depends}
   # Do not automatically create CppMicroServices initialization code.
   # Because the VTK "auto-init" functionality injects file-local static
   # initialization code in every cpp file which includes a VTK header,
   # static initialization order becomes an issue again. For the Mitk
   # core library, we need to ensure that the VTK static initialization stuff
   # happens before the CppMicroServices initialization, since the latter
   # might already use VTK code which needs to access VTK object factories.
   # Hence, CppMicroServices initialization code is placed manually within
   # the mitkCoreActivator.cpp file.
   NO_INIT
 )
 if(NOT TARGET ${MODULE_TARGET})
   message(SEND_ERROR "Core target ${MODULE_TARGET} does not exist")
 endif()
 
 function(_itk_create_factory_register_manager)
   # In MITK_ITK_Config.cmake, we do *not* include ITK_USE_FILE, which
   # prevents multiple registrations/unregistrations of ITK IO factories
   # during library loading/unloading (of MITK libraries). However, we need
   # "one" place where the IO factories are registered at
   # least once. This could be the application executable, but every executable would
   # need to take care of that itself. Instead, we allow the auto registration in the
   # Mitk Core library.
   set(NO_DIRECTORY_SCOPED_ITK_COMPILE_DEFINITION 1)
   find_package(ITK)
   include(${ITK_USE_FILE})
 
   if(NOT ITK_NO_IO_FACTORY_REGISTER_MANAGER)
     # We manually add the define which will be of target scope. MITK
     # patches ITK_USE_FILE to remove the directory scoped compile
     # definition since it would be propagated to other targets in the
     # same directory scope but these targets might want to *not*
     # use the ITK factory manager stuff.
     target_compile_definitions(${MODULE_TARGET} PRIVATE ITK_IO_FACTORY_REGISTER_MANAGER)
   endif()
 endfunction()
 _itk_create_factory_register_manager()
 
 if(BUILD_TESTING)
   add_subdirectory(TestingHelper)
   add_subdirectory(test)
 endif()
diff --git a/Modules/Core/src/Rendering/mitkVideoRecorder.cpp b/Modules/Core/src/Rendering/mitkVideoRecorder.cpp
index f30ea29140..117946b90f 100644
--- a/Modules/Core/src/Rendering/mitkVideoRecorder.cpp
+++ b/Modules/Core/src/Rendering/mitkVideoRecorder.cpp
@@ -1,360 +1,391 @@
 /*============================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center (DKFZ)
 All rights reserved.
 
 Use of this source code is governed by a 3-clause BSD license that can be
 found in the LICENSE file.
 
 ============================================================================*/
 
 #include <mitkVideoRecorder.h>
 
 #include <mitkBaseRenderer.h>
 #include <mitkCoreServices.h>
 #include <mitkExceptionMacro.h>
 #include <mitkIOUtil.h>
 #include <mitkIPreferences.h>
 #include <mitkIPreferencesService.h>
 #include <mitkLogMacros.h>
 
 #include <vtkImageResize.h>
 #include <vtkNew.h>
 #include <vtkPNGWriter.h>
 #include <vtkRenderWindow.h>
 #include <vtkWindowToImageFilter.h>
 
-#include <Poco/Process.h>
+#include <itksys/Process.h>
 
 #include <iomanip>
 #include <optional>
 #include <sstream>
 
 std::string mitk::VideoRecorder::GetFileExtension(OutputFormat format)
 {
   switch (format)
   {
   case OutputFormat::WebM_VP9:
     return ".webm";
 
   case OutputFormat::MP4_H264:
     return ".mp4";
 
   default:
     break;
   }
 
   mitkThrow() << "Unknown output format for video recording.";
 }
 
 namespace
 {
   mitk::IPreferences* GetPreferences()
   {
     auto* preferencesService = mitk::CoreServices::GetPreferencesService();
     return preferencesService->GetSystemPreferences()->Node("org.mitk.views.moviemaker");
   }
 
   class RecordingSession
   {
   public:
     RecordingSession(vtkRenderWindow* renderWindow, mitk::VideoRecorder::OutputFormat format)
       : m_FrameDir(mitk::IOUtil::CreateTemporaryDirectory("MITK_RecordingSession_XXXXXX")),
         m_NumberOfFrames(0)
     {
       m_WindowToImageFilter->SetInput(renderWindow);
 
       if (mitk::VideoRecorder::OutputFormat::MP4_H264 == format)
       {
         // H.264 only supports image dimensions that are a multiple of 2. Resize if necessary.
 
         auto* size = renderWindow->GetActualSize();
 
         if (size[0] & 1 || size[1] & 1)
         {
           m_ImageResize->SetInputConnection(m_WindowToImageFilter->GetOutputPort());
           m_ImageResize->SetOutputDimensions(size[0] & ~1, size[1] & ~1, -1);
           m_ImageResize->SetInterpolate(0);
           m_ImageResize->BorderOn();
 
           m_ImageWriter->SetInputConnection(m_ImageResize->GetOutputPort());
           return;
         }
       }
 
       m_ImageWriter->SetInputConnection(m_WindowToImageFilter->GetOutputPort());
     }
 
     ~RecordingSession()
     {
       std::error_code errorCode;
       std::filesystem::remove_all(m_FrameDir, errorCode);
     }
 
     RecordingSession(const RecordingSession&) = delete;
     RecordingSession& operator=(const RecordingSession&) = delete;
 
     std::filesystem::path GetFrameDir() const
     {
       return m_FrameDir;
     }
 
     void RecordFrame()
     {
       m_WindowToImageFilter->Modified();
 
       std::stringstream frameFilename;
       frameFilename << std::setw(6) << std::setfill('0') << m_NumberOfFrames << ".png";
       const auto framePath = m_FrameDir / frameFilename.str();
 
       m_ImageWriter->SetFileName(framePath.string().c_str());
       m_ImageWriter->Write();
 
       ++m_NumberOfFrames;
     }
 
   private:
     std::filesystem::path m_FrameDir;
     unsigned int m_NumberOfFrames;
     vtkNew<vtkWindowToImageFilter> m_WindowToImageFilter;
     vtkNew<vtkImageResize> m_ImageResize;
     vtkNew<vtkPNGWriter> m_ImageWriter;
   };
 }
 
 namespace mitk
 {
   class VideoRecorder::Impl
   {
   public:
     Impl()
       : m_FrameRate(30)
     {
     }
 
     ~Impl() = default;
 
     Impl(const Impl&) = delete;
     Impl& operator=(const Impl&) = delete;
 
     std::filesystem::path GetFFmpegPath() const
     {
       if (m_FFmpegPath)
         return m_FFmpegPath.value();
 
       auto* preferences = GetPreferences();
 
       if (nullptr != preferences)
       {
         auto ffmpegPath = preferences->Get("ffmpeg", "");
 
         if (!ffmpegPath.empty())
           return ffmpegPath;
       }
 
       return std::filesystem::path();
     }
 
     void SetFFmpegPath(const std::filesystem::path& path)
     {
       m_FFmpegPath = path;
     }
 
     std::filesystem::path GetOutputPath() const
     {
       return m_OutputPath;
     }
 
     void SetOutputPath(const std::filesystem::path& path)
     {
       m_OutputPath = path;
     }
 
     mitk::VideoRecorder::OutputFormat GetOutputFormat() const
     {
       if (m_OutputFormat)
         return m_OutputFormat.value();
 
       auto* preferences = GetPreferences();
 
       if (nullptr != preferences)
         return static_cast<OutputFormat>(preferences->GetInt("format", 0));
 
       return OutputFormat::WebM_VP9;
     }
 
     void SetOutputFormat(OutputFormat format)
     {
       m_OutputFormat = format;
     }
 
     std::string GetRenderWindowName() const
     {
       return m_RenderWindowName;
     }
 
     void SetRenderWindowName(const std::string& renderWindowName)
     {
       m_RenderWindowName = renderWindowName;
     }
 
     int GetFrameRate() const
     {
       return m_FrameRate;
     }
 
     void SetFrameRate(unsigned int fps)
     {
       m_FrameRate = fps;
     }
 
     bool OnAir() const
     {
       return nullptr != m_RecordingSession.get();
     }
 
     void StartRecording()
     {
       if (this->OnAir())
         mitkThrow() << "Recording session already running.";
 
       auto renderWindowName = this->GetRenderWindowName();
 
       if (renderWindowName.empty())
         mitkThrow() << "No render window specified for recording.";
 
       auto* renderWindow = BaseRenderer::GetRenderWindowByName(renderWindowName);
 
       if (nullptr == renderWindow)
         mitkThrow() << "\"" << renderWindowName << "\" references unknown render window for recording.";
 
       m_RecordingSession = std::make_unique<RecordingSession>(renderWindow, this->GetOutputFormat());
     }
 
     void RecordFrame()
     {
       if (!this->OnAir())
         mitkThrow() << "Cannot record frame. No recording session running.";
 
       m_RecordingSession->RecordFrame();
     }
 
+    std::string GetFFmpegCommandLine() const
+    {
+      bool vp9 = OutputFormat::WebM_VP9 == this->GetOutputFormat();
+
+      std::stringstream stream;
+      stream << this->GetFFmpegPath()
+        << "-y" << ' '
+        << "-r " << std::to_string(this->GetFrameRate()) << ' '
+        << "-i %6d.png" << ' '
+        << "-c:v " << (vp9 ? "libvpx-vp9" : "libx264") << ' '
+        << "-crf " << (vp9 ? "31" : "23") << ' '
+        << "-pix_fmt yuv420p" << ' '
+        << "-b:v 0" << ' '
+        << this->GetOutputPath();
+
+      return stream.str();
+    }
+
+    int ExecuteFFmpeg() const
+    {
+      auto commandLine = this->GetFFmpegCommandLine();
+      auto commandLineCStr = commandLine.c_str();
+
+      auto workingDirectory = m_RecordingSession->GetFrameDir().string();
+
+      auto* ffmpeg = itksysProcess_New();
+
+      itksysProcess_SetOption(ffmpeg, itksysProcess_Option_Verbatim, 1);
+      itksysProcess_SetCommand(ffmpeg, &commandLineCStr);
+      itksysProcess_SetWorkingDirectory(ffmpeg, workingDirectory.c_str());
+
+      itksysProcess_Execute(ffmpeg);
+      itksysProcess_WaitForExit(ffmpeg, nullptr);
+
+      if (itksysProcess_State_Exited != itksysProcess_GetState(ffmpeg))
+      {
+        itksysProcess_Delete(ffmpeg);
+        mitkThrow() << "FFmpeg process did not exit as expected.";
+      }
+
+      auto exitCode = itksysProcess_GetExitValue(ffmpeg);
+
+      itksysProcess_Delete(ffmpeg);
+
+      return exitCode;
+    }
+
     int StopRecording()
     {
       if (!this->OnAir())
         mitkThrow() << "No recording session running.";
 
-      auto ffmpegPath = this->GetFFmpegPath();
-
-      if (ffmpegPath.empty())
+      if (this->GetFFmpegPath().empty())
         mitkThrow() << "Path to FFmpeg not set.";
 
       if (this->GetOutputPath().empty())
         mitkThrow() << "Path to output video file not set.";
 
-      bool vp9 = OutputFormat::WebM_VP9 == this->GetOutputFormat();
-
-      Poco::Process::Args args = {
-        "-y",
-        "-r", std::to_string(this->GetFrameRate()),
-        "-i", "%6d.png",
-        "-c:v", vp9 ? "libvpx-vp9" : "libx264",
-        "-crf", vp9 ? "31" : "23",
-        "-pix_fmt", "yuv420p",
-        "-b:v", "0",
-        this->GetOutputPath().string()
-      };
-
-      auto processHandle = Poco::Process::launch(ffmpegPath.string(), args, m_RecordingSession->GetFrameDir().string());
-      auto exitCode = processHandle.wait();
+      auto exitCode = this->ExecuteFFmpeg();
 
       m_RecordingSession = nullptr;
 
       return exitCode;
     }
 
   private:
     std::optional<std::filesystem::path> m_FFmpegPath;
     std::filesystem::path m_OutputPath;
     std::optional<OutputFormat> m_OutputFormat;
     std::string m_RenderWindowName;
     unsigned int m_FrameRate;
     std::unique_ptr<RecordingSession> m_RecordingSession;
   };
 }
 
 mitk::VideoRecorder::VideoRecorder()
   : m_Impl(std::make_unique<Impl>())
 {
 }
 
 mitk::VideoRecorder::~VideoRecorder()
 {
 }
 
 std::filesystem::path mitk::VideoRecorder::GetFFmpegPath() const
 {
   return m_Impl->GetFFmpegPath();
 }
 
 void mitk::VideoRecorder::SetFFmpegPath(const std::filesystem::path& path)
 {
   m_Impl->SetFFmpegPath(path);
 }
 
 std::filesystem::path mitk::VideoRecorder::GetOutputPath() const
 {
   return m_Impl->GetOutputPath();
 }
 
 void mitk::VideoRecorder::SetOutputPath(const std::filesystem::path& path)
 {
   m_Impl->SetOutputPath(path);
 }
 
 mitk::VideoRecorder::OutputFormat mitk::VideoRecorder::GetOutputFormat() const
 {
   return m_Impl->GetOutputFormat();
 }
 
 void mitk::VideoRecorder::SetOutputFormat(OutputFormat format)
 {
   m_Impl->SetOutputFormat(format);
 }
 
 std::string mitk::VideoRecorder::GetRenderWindowName() const
 {
   return m_Impl->GetRenderWindowName();
 }
 
 void mitk::VideoRecorder::SetRenderWindowName(const std::string& renderWindowName)
 {
   m_Impl->SetRenderWindowName(renderWindowName);
 }
 
 int mitk::VideoRecorder::GetFrameRate() const
 {
   return m_Impl->GetFrameRate();
 }
 
 void mitk::VideoRecorder::SetFrameRate(unsigned int fps)
 {
   m_Impl->SetFrameRate(fps);
 }
 
 void mitk::VideoRecorder::StartRecording()
 {
   m_Impl->StartRecording();
 }
 
 void mitk::VideoRecorder::RecordFrame() const
 {
   m_Impl->RecordFrame();
 }
 
 int mitk::VideoRecorder::StopRecording()
 {
   return m_Impl->StopRecording();
 }