diff --git a/modules/desktop_capture/linux/base_capturer_pipewire.cc b/modules/desktop_capture/linux/base_capturer_pipewire.cc
index 3be24f22c4..be8b5f3bf8 100644
--- a/modules/desktop_capture/linux/base_capturer_pipewire.cc
+++ b/modules/desktop_capture/linux/base_capturer_pipewire.cc
@@ -555,19 +555,23 @@ void BaseCapturerPipeWire::HandleBuffer(pw_buffer* buffer) {
     src = SPA_MEMBER(map.get(), spa_buffer->datas[0].mapoffset, uint8_t);
   } else if (spa_buffer->datas[0].type == SPA_DATA_DmaBuf) {
     const uint n_planes = spa_buffer->n_datas;
-    int fds[n_planes];
-    uint32_t offsets[n_planes];
-    uint32_t strides[n_planes];
 
-    for (uint32_t i = 0; i < n_planes; ++i) {
-      fds[i] = spa_buffer->datas[i].fd;
-      offsets[i] = spa_buffer->datas[i].chunk->offset;
-      strides[i] = spa_buffer->datas[i].chunk->stride;
+    if (!n_planes) {
+      return;
     }
 
-    src_unique_ptr = egl_dmabuf_->ImageFromDmaBuf(
-        desktop_size_, spa_video_format_.format, n_planes, fds, strides,
-        offsets, modifier_);
+    std::vector<EglDmaBuf::PlaneData> plane_datas;
+    for (uint32_t i = 0; i < n_planes; ++i) {
+      EglDmaBuf::PlaneData data = {
+          static_cast<int32_t>(spa_buffer->datas[i].fd),
+          static_cast<uint32_t>(spa_buffer->datas[i].chunk->stride),
+          static_cast<uint32_t>(spa_buffer->datas[i].chunk->offset)};
+      plane_datas.push_back(data);
+    }
+
+    src_unique_ptr =
+        egl_dmabuf_->ImageFromDmaBuf(desktop_size_, spa_video_format_.format,
+                                     plane_datas, modifier_);
     src = src_unique_ptr.get();
   } else if (spa_buffer->datas[0].type == SPA_DATA_MemPtr) {
     src = static_cast<uint8_t*>(spa_buffer->datas[0].data);
diff --git a/modules/desktop_capture/linux/egl_dmabuf.cc b/modules/desktop_capture/linux/egl_dmabuf.cc
index c78036b20c..7e464a1e88 100644
--- a/modules/desktop_capture/linux/egl_dmabuf.cc
+++ b/modules/desktop_capture/linux/egl_dmabuf.cc
@@ -384,30 +384,28 @@ EglDmaBuf::~EglDmaBuf() {
 }
 
 RTC_NO_SANITIZE("cfi-icall")
-std::unique_ptr<uint8_t[]> EglDmaBuf::ImageFromDmaBuf(const DesktopSize& size,
-                                                      uint32_t format,
-                                                      uint32_t n_planes,
-                                                      const int32_t* fds,
-                                                      const uint32_t* strides,
-                                                      const uint32_t* offsets,
-                                                      uint64_t modifier) {
+std::unique_ptr<uint8_t[]> EglDmaBuf::ImageFromDmaBuf(
+    const DesktopSize& size,
+    uint32_t format,
+    const std::vector<PlaneData>& plane_datas,
+    uint64_t modifier) {
   std::unique_ptr<uint8_t[]> src;
 
   if (!egl_initialized_) {
     return src;
   }
 
-  if (n_planes <= 0) {
+  if (plane_datas.size() <= 0) {
     RTC_LOG(LS_ERROR) << "Failed to process buffer: invalid number of planes";
     return src;
   }
 
   gbm_bo* imported;
   if (modifier == DRM_FORMAT_MOD_INVALID) {
-    gbm_import_fd_data import_info = {fds[0],
-                                      static_cast<uint32_t>(size.width()),
-                                      static_cast<uint32_t>(size.height()),
-                                      strides[0], GBM_BO_FORMAT_ARGB8888};
+    gbm_import_fd_data import_info = {
+        plane_datas[0].fd, static_cast<uint32_t>(size.width()),
+        static_cast<uint32_t>(size.height()), plane_datas[0].stride,
+        GBM_BO_FORMAT_ARGB8888};
 
     imported = gbm_bo_import(gbm_device_, GBM_BO_IMPORT_FD, &import_info, 0);
   } else {
@@ -415,12 +413,12 @@ std::unique_ptr<uint8_t[]> EglDmaBuf::ImageFromDmaBuf(const DesktopSize& size,
     import_info.format = GBM_BO_FORMAT_ARGB8888;
     import_info.width = static_cast<uint32_t>(size.width());
     import_info.height = static_cast<uint32_t>(size.height());
-    import_info.num_fds = n_planes;
+    import_info.num_fds = plane_datas.size();
     import_info.modifier = modifier;
-    for (uint32_t i = 0; i < n_planes; i++) {
-      import_info.fds[i] = fds[i];
-      import_info.offsets[i] = offsets[i];
-      import_info.strides[i] = strides[i];
+    for (uint32_t i = 0; i < plane_datas.size(); i++) {
+      import_info.fds[i] = plane_datas[i].fd;
+      import_info.offsets[i] = plane_datas[i].offset;
+      import_info.strides[i] = plane_datas[i].stride;
     }
 
     imported =
@@ -458,7 +456,7 @@ std::unique_ptr<uint8_t[]> EglDmaBuf::ImageFromDmaBuf(const DesktopSize& size,
   GlBindTexture(GL_TEXTURE_2D, texture);
   GlEGLImageTargetTexture2DOES(GL_TEXTURE_2D, image);
 
-  src = std::make_unique<uint8_t[]>(strides[0] * size.height());
+  src = std::make_unique<uint8_t[]>(plane_datas[0].stride * size.height());
 
   GLenum gl_format = GL_BGRA;
   switch (format) {
diff --git a/modules/desktop_capture/linux/egl_dmabuf.h b/modules/desktop_capture/linux/egl_dmabuf.h
index f7ced99a38..9d7309f562 100644
--- a/modules/desktop_capture/linux/egl_dmabuf.h
+++ b/modules/desktop_capture/linux/egl_dmabuf.h
@@ -32,16 +32,20 @@ class EglDmaBuf {
     EGLContext context = EGL_NO_CONTEXT;
   };
 
+  struct PlaneData {
+    int32_t fd;
+    uint32_t stride;
+    uint32_t offset;
+  };
+
   EglDmaBuf();
   ~EglDmaBuf();
 
-  std::unique_ptr<uint8_t[]> ImageFromDmaBuf(const DesktopSize& size,
-                                             uint32_t format,
-                                             uint32_t n_planes,
-                                             const int32_t* fds,
-                                             const uint32_t* strides,
-                                             const uint32_t* offsets,
-                                             uint64_t modifiers);
+  std::unique_ptr<uint8_t[]> ImageFromDmaBuf(
+      const DesktopSize& size,
+      uint32_t format,
+      const std::vector<PlaneData>& plane_datas,
+      uint64_t modifiers);
   std::vector<uint64_t> QueryDmaBufModifiers(uint32_t format);
 
   bool IsEglInitialized() const { return egl_initialized_; }