init

libs/hwcodec/cpp/common/platform/linux/linux.cpp

@@ -0,0 +1,163 @@
+#include "linux.h"
+#include "../../log.h"
+#include <cstring>
+#include <dlfcn.h>
+#include <dynlink_cuda.h>
+#include <dynlink_loader.h>
+#include <errno.h>
+#include <exception> // Include the necessary header file
+#include <signal.h>
+#include <sys/prctl.h>
+#include <unistd.h>
+#include <fcntl.h>
+
+namespace
+{
+  void load_driver(CudaFunctions **pp_cuda_dl, NvencFunctions **pp_nvenc_dl,
+                   CuvidFunctions **pp_cvdl)
+  {
+    if (cuda_load_functions(pp_cuda_dl, NULL) < 0)
+    {
+      LOG_TRACE(std::string("cuda_load_functions failed"));
+      throw "cuda_load_functions failed";
+    }
+    if (nvenc_load_functions(pp_nvenc_dl, NULL) < 0)
+    {
+      LOG_TRACE(std::string("nvenc_load_functions failed"));
+      throw "nvenc_load_functions failed";
+    }
+    if (cuvid_load_functions(pp_cvdl, NULL) < 0)
+    {
+      LOG_TRACE(std::string("cuvid_load_functions failed"));
+      throw "cuvid_load_functions failed";
+    }
+  }
+
+  void free_driver(CudaFunctions **pp_cuda_dl, NvencFunctions **pp_nvenc_dl,
+                   CuvidFunctions **pp_cvdl)
+  {
+    if (*pp_cvdl)
+    {
+      cuvid_free_functions(pp_cvdl);
+      *pp_cvdl = NULL;
+    }
+    if (*pp_nvenc_dl)
+    {
+      nvenc_free_functions(pp_nvenc_dl);
+      *pp_nvenc_dl = NULL;
+    }
+    if (*pp_cuda_dl)
+    {
+      cuda_free_functions(pp_cuda_dl);
+      *pp_cuda_dl = NULL;
+    }
+  }
+} // namespace
+
+int linux_support_nv()
+{
+  try
+  {
+    CudaFunctions *cuda_dl = NULL;
+    NvencFunctions *nvenc_dl = NULL;
+    CuvidFunctions *cvdl = NULL;
+    load_driver(&cuda_dl, &nvenc_dl, &cvdl);
+    free_driver(&cuda_dl, &nvenc_dl, &cvdl);
+    return 0;
+  }
+  catch (...)
+  {
+    LOG_TRACE(std::string("nvidia driver not support"));
+  }
+  return -1;
+}
+
+int linux_support_amd()
+{
+#if defined(__x86_64__) || defined(__aarch64__)
+#define AMF_DLL_NAME L"libamfrt64.so.1"
+#define AMF_DLL_NAMEA "libamfrt64.so.1"
+#else
+#define AMF_DLL_NAME L"libamfrt32.so.1"
+#define AMF_DLL_NAMEA "libamfrt32.so.1"
+#endif
+  void *handle = dlopen(AMF_DLL_NAMEA, RTLD_LAZY);
+  if (!handle)
+  {
+    return -1;
+  }
+  dlclose(handle);
+  return 0;
+}
+
+int linux_support_intel()
+{
+  const char *libs[] =
+      {"libvpl.so", "libmfx.so", "libmfx-gen.so.1.2", "libmfxhw64.so.1"};
+  for (size_t i = 0; i < sizeof(libs) / sizeof(libs[0]); i++)
+  {
+    void *handle = dlopen(libs[i], RTLD_LAZY);
+    if (handle)
+    {
+      dlclose(handle);
+      return 0;
+    }
+  }
+  return -1;
+}
+
+int setup_parent_death_signal() {
+  // Set up parent death signal to ensure this process dies if parent dies
+  // This prevents orphaned processes especially when running with different
+  // user permissions
+  int ret = prctl(PR_SET_PDEATHSIG, SIGKILL);
+  if (ret != 0) {
+    LOG_ERROR(std::string("Failed to set parent death signal:") + std::to_string(errno));
+    return -1;
+  } else {
+    return 0;
+  }
+}
+
+// Check for Rockchip MPP (Media Process Platform) support
+// Returns 0 if supported, -1 otherwise
+int linux_support_rkmpp() {
+  // Check for MPP service device (primary method)
+  if (access("/dev/mpp_service", F_OK) == 0) {
+    LOG_TRACE(std::string("RKMPP: Found /dev/mpp_service"));
+    return 0;
+  }
+  // Fallback: check for RGA (Rockchip Graphics Acceleration) device
+  if (access("/dev/rga", F_OK) == 0) {
+    LOG_TRACE(std::string("RKMPP: Found /dev/rga"));
+    return 0;
+  }
+  LOG_TRACE(std::string("RKMPP: No Rockchip MPP device found"));
+  return -1;
+}
+
+// Check for V4L2 Memory-to-Memory (M2M) codec support
+// Returns 0 if a M2M capable device is found, -1 otherwise
+int linux_support_v4l2m2m() {
+  // Check common V4L2 M2M device paths used by various ARM SoCs
+  const char *m2m_devices[] = {
+    "/dev/video10",  // Common M2M encoder device
+    "/dev/video11",  // Common M2M decoder device
+    "/dev/video0",   // Some SoCs use video0 for M2M
+  };
+
+  for (size_t i = 0; i < sizeof(m2m_devices) / sizeof(m2m_devices[0]); i++) {
+    if (access(m2m_devices[i], F_OK) == 0) {
+      // Device exists, check if it's an M2M device by trying to open it
+      int fd = open(m2m_devices[i], O_RDWR | O_NONBLOCK);
+      if (fd >= 0) {
+        close(fd);
+        LOG_TRACE(std::string("V4L2 M2M: Found device ") + m2m_devices[i]);
+        return 0;
+      }
+    }
+  }
+
+  LOG_TRACE(std::string("V4L2 M2M: No M2M device found"));
+  return -1;
+}

libs/hwcodec/cpp/common/platform/linux/linux.h

@@ -0,0 +1,11 @@
+#ifndef LINUX_H
+#define LINUX_H
+
+extern "C" int linux_support_nv();
+extern "C" int linux_support_amd();
+extern "C" int linux_support_intel();
+extern "C" int linux_support_rkmpp();
+extern "C" int linux_support_v4l2m2m();
+extern "C" int setup_parent_death_signal();
+
+#endif