Improving swig bindings for Python, Java, and Ruby for access direct pixel byte array:

Example Code Snippets:
Python:
import openshot

r = openshot.FFmpegReader("/home/jonathan/Pictures/ChatGPT Image Mar 27, 2025, 09_50_56 AM.png")
r.Open()
f = r.GetFrame(1)
buf = f.GetPixelsBytes()
w, h = f.GetWidth(), f.GetHeight()
stride = f.GetBytesPerLine()

Ruby:
require "openshot"

r = Openshot::FFmpegReader.new("/home/jonathan/Pictures/ChatGPT Image Mar 27, 2025, 09_50_56 AM.png")
r.Open()
f = r.GetFrame(1)
buf = f.GetPixelsBytes
w = f.GetWidth
h = f.GetHeight
stride = f.GetBytesPerLine

Author: jonoomph

bindings/java/openshot.i

@@ -52,6 +52,34 @@
 #%template() std::vector<std::pair<std::string, std::string>>;
 %template() std::vector<std::vector<float>>;
 
+%inline %{
+typedef struct OpenShotByteBuffer {
+    const unsigned char* data;
+    int size;
+} OpenShotByteBuffer;
+%}
+
+%typemap(jni) OpenShotByteBuffer "jbyteArray"
+%typemap(jstype) OpenShotByteBuffer "byte[]"
+%typemap(jtype) OpenShotByteBuffer "byte[]"
+%typemap(javaout) OpenShotByteBuffer {
+    return $jnicall;
+}
+%typemap(out) OpenShotByteBuffer {
+    if ($1.data && $1.size > 0) {
+        jbyteArray jarr = jenv->NewByteArray($1.size);
+        if (jarr == NULL) {
+            SWIG_JavaThrowException(jenv, SWIG_JavaOutOfMemoryError, "Unable to allocate byte array");
+            return NULL;
+        }
+        jenv->SetByteArrayRegion(jarr, 0, $1.size,
+                                 reinterpret_cast<const jbyte*>($1.data));
+        $result = jarr;
+    } else {
+        $result = NULL;
+    }
+}
+
 %{
 #include "OpenShotVersion.h"
 #include "ReaderBase.h"
@@ -118,6 +146,45 @@
 /* Deprecated */
 %template(AudioDeviceInfoVector) std::vector<openshot::AudioDeviceInfo>;
 
+%extend openshot::Frame {
+    OpenShotByteBuffer GetPixelsBytes() {
+        OpenShotByteBuffer out = {NULL, 0};
+        std::shared_ptr<QImage> img = $self->GetImage();
+        if (!img) return out;
+
+        const int size = img->bytesPerLine() * img->height();
+
+        const unsigned char* p = $self->GetPixels();
+        if (!p || size <= 0) return out;
+
+        out.data = p;
+        out.size = size;
+        return out;
+    }
+
+    OpenShotByteBuffer GetPixelsRowBytes(int row) {
+        OpenShotByteBuffer out = {NULL, 0};
+        std::shared_ptr<QImage> img = $self->GetImage();
+        if (!img) return out;
+
+        if (row < 0 || row >= img->height()) {
+            return out;
+        }
+
+        const unsigned char* p = $self->GetPixels(row);
+        if (!p) return out;
+
+        out.data = p;
+        out.size = img->bytesPerLine();
+        return out;
+    }
+
+    int GetBytesPerLine() {
+        std::shared_ptr<QImage> img = $self->GetImage();
+        return img ? img->bytesPerLine() : 0;
+    }
+}
+
 %include "OpenShotVersion.h"
 %include "ReaderBase.h"
 %include "WriterBase.h"

bindings/python/openshot.i

@@ -284,6 +284,74 @@
     }
 }
 
+%extend openshot::Frame {
+    PyObject* GetPixelsBytes() {
+        PyGILState_STATE gstate = PyGILState_Ensure();
+        PyObject* result = NULL;
+
+        std::shared_ptr<QImage> img = $self->GetImage();
+        if (!img) {
+            Py_INCREF(Py_None);
+            result = Py_None;
+            PyGILState_Release(gstate);
+            return result;
+        }
+
+        const Py_ssize_t size =
+            static_cast<Py_ssize_t>(img->bytesPerLine()) *
+            static_cast<Py_ssize_t>(img->height());
+
+        const unsigned char* p = img->constBits();
+        if (!p || size <= 0) {
+            Py_INCREF(Py_None);
+            result = Py_None;
+            PyGILState_Release(gstate);
+            return result;
+        }
+
+        result = PyBytes_FromStringAndSize(reinterpret_cast<const char*>(p), size);
+        PyGILState_Release(gstate);
+        return result;
+    }
+
+    PyObject* GetPixelsRowBytes(int row) {
+        PyGILState_STATE gstate = PyGILState_Ensure();
+        PyObject* result = NULL;
+
+        std::shared_ptr<QImage> img = $self->GetImage();
+        if (!img) {
+            Py_INCREF(Py_None);
+            result = Py_None;
+            PyGILState_Release(gstate);
+            return result;
+        }
+
+        if (row < 0 || row >= img->height()) {
+            PyErr_SetString(PyExc_IndexError, "row out of range");
+            PyGILState_Release(gstate);
+            return NULL;
+        }
+
+        const unsigned char* p = img->constScanLine(row);
+        if (!p) {
+            Py_INCREF(Py_None);
+            result = Py_None;
+            PyGILState_Release(gstate);
+            return result;
+        }
+
+        const Py_ssize_t row_bytes = static_cast<Py_ssize_t>(img->bytesPerLine());
+        result = PyBytes_FromStringAndSize(reinterpret_cast<const char*>(p), row_bytes);
+        PyGILState_Release(gstate);
+        return result;
+    }
+
+    int GetBytesPerLine() {
+        std::shared_ptr<QImage> img = $self->GetImage();
+        return img ? img->bytesPerLine() : 0;
+    }
+}
+
 %include "OpenShotVersion.h"
 %include "ReaderBase.h"
 %include "WriterBase.h"

bindings/ruby/openshot.i

@@ -52,6 +52,21 @@
 %template() std::vector<std::pair<std::string, std::string>>;
 %template() std::vector<std::vector<float>>;
 
+%inline %{
+typedef struct OpenShotByteBuffer {
+    const unsigned char* data;
+    int size;
+} OpenShotByteBuffer;
+%}
+
+%typemap(out) OpenShotByteBuffer {
+    if ($1.data && $1.size > 0) {
+        $result = rb_str_new(reinterpret_cast<const char*>($1.data), $1.size);
+    } else {
+        $result = Qnil;
+    }
+}
+
 %{
 /* Ruby and FFmpeg define competing RSHIFT macros,
  * so we move Ruby's out of the way for now. We'll
@@ -136,6 +151,45 @@
 /* Deprecated */
 %template(AudioDeviceInfoVector) std::vector<openshot::AudioDeviceInfo>;
 
+%extend openshot::Frame {
+    OpenShotByteBuffer GetPixelsBytes() {
+        OpenShotByteBuffer out = {NULL, 0};
+        std::shared_ptr<QImage> img = $self->GetImage();
+        if (!img) return out;
+
+        const int size = img->bytesPerLine() * img->height();
+
+        const unsigned char* p = $self->GetPixels();
+        if (!p || size <= 0) return out;
+
+        out.data = p;
+        out.size = size;
+        return out;
+    }
+
+    OpenShotByteBuffer GetPixelsRowBytes(int row) {
+        OpenShotByteBuffer out = {NULL, 0};
+        std::shared_ptr<QImage> img = $self->GetImage();
+        if (!img) return out;
+
+        if (row < 0 || row >= img->height()) {
+            rb_raise(rb_eIndexError, "row out of range");
+        }
+
+        const unsigned char* p = $self->GetPixels(row);
+        if (!p) return out;
+
+        out.data = p;
+        out.size = img->bytesPerLine();
+        return out;
+    }
+
+    int GetBytesPerLine() {
+        std::shared_ptr<QImage> img = $self->GetImage();
+        return img ? img->bytesPerLine() : 0;
+    }
+}
+
 %include "OpenShotVersion.h"
 %include "ReaderBase.h"
 %include "WriterBase.h"