Ffmpeg compositor native code

c_src/ffmpeg_video_compositor/filter.c

@@ -1,17 +1,17 @@
 #include "filter.h"
 /**
  * @brief Append a header of the filter description to the string (buffer).
- * Creates two input pads with output pads named [in_1] and [in_2]
+ * Creates \p n_videos input nodes with output pads named [in_1], [in_2], ..,
+ * [in_ \p n_videos].
  *
  * @param filters_str Description destination string (buffer)
  * @param filters_size Remaining size of the buffer
- * @param width Width of the videos
- * @param height Height of the videos
- * @param pixel_format Pixel format code of the videos
- * @return Number of characters written to the buffer
+ * @param videos Array of input videos.
+ * @param n_videos Size of the videos array
+ * @return int
  */
-static int init_filters_string(char *filters_str, int filters_size, int width,
-                               int height, int pixel_format);
+static int init_filters_string(char *filters_str, int filters_size,
+                               RawVideo videos[], int n_videos);
 
 /**
  * @brief Append a main filter description (transformation graph) to the string
@@ -38,29 +38,28 @@ static void cs_printAVError(const char *msg, int returnCode) {
     fprintf(stderr, "%s: %s\n", msg, av_err2str(returnCode));
 }
 
-int init_filter_description(char *filter_str, int filters_size, int width,
-                            int height, int pixel_format) {
+int init_filter_description(char *filter_str, int filter_size,
+                            RawVideo videos[], int n_videos) {
     int filter_end = 0;
-    filter_end +=
-        init_filters_string(filter_str + filter_end, filters_size - filter_end,
-                            width, height, pixel_format);
+    filter_end += init_filters_string(
+        filter_str + filter_end, filter_size - filter_end, videos, n_videos);
     filter_end += apply_filters_options_string(filter_str + filter_end,
-                                               filters_size - filter_end);
+                                               filter_size - filter_end);
     filter_end += finish_filters_string(filter_str + filter_end,
-                                        filters_size - filter_end);
+                                        filter_size - filter_end);
     return filter_end;
 }
 
-static int init_filters_string(char *filters_str, int filters_size, int width,
-                               int height, int pixel_format) {
-    const int n_videos = 2;
+static int init_filters_string(char *filters_str, int filters_size,
+                               RawVideo videos[], int n_videos) {
     int filter_end = 0;
     for (int i = 0; i < n_videos; ++i) {
-        filter_end +=
-            snprintf(filters_str + filter_end, filters_size - filter_end,
-                     "buffer=video_size=%dx%d:pix_fmt=%d:time_base=%d/"
-                     "%d [in_%d];\n",
-                     width, height, pixel_format, 1, 1, i + 1);
+        RawVideo *video = &videos[i];
+        filter_end += snprintf(
+            filters_str + filter_end, filters_size - filter_end,
+            "buffer=video_size=%dx%d:pix_fmt=%d:time_base=%d/"
+            "%d [in_%d];\n",
+            video->width, video->height, video->pixel_format, 1, 1, i + 1);
     }
     return filter_end;
 }

c_src/ffmpeg_video_compositor/filter.h

@@ -27,20 +27,19 @@ typedef struct VState {
  * @param filters_descr String description of the filter graph. This should
  * follow FFmpeg filter documentation.
  * @param filter  Pointer to the filter graph.
- * @return int Return code. Return 0 on success, a negative value on failure.
+ * @return Return code. Return 0 on success, a negative value on failure.
  */
 int init_filters(const char *filters_descr, FilterState *filter);
 
 /**
  * @brief Creates a filter description string in an FFmpeg format and stores it
- * in the given string. The function assumes two input videos.
+ * in the given string.
  *
  * @param filter_str Description destination (buffer)
  * @param filter_size Maximum size of the filter description (buffer size)
- * @param width Width of the videos
- * @param height Height of the videos
- * @param pixel_format Pixel format code of the videos
- * @return Number of characters written to the buffer
+ * @param videos Array of input videos.
+ * @param n_videos Size of the videos array
+ * @return int
  */
-int init_filter_description(char *filter_str, int filter_size, int width,
-                            int height, int pixel_format);
+int init_filter_description(char *filter_str, int filter_size,
+                            RawVideo videos[], int n_videos);

c_src/ffmpeg_video_compositor/video_compositor.c

@@ -1,56 +1,79 @@
 #include "video_compositor.h"
 
+/**
+ * @brief Create a unifex filter object
+ *
+ * @param env Unifex environment
+ * @param filter_description Description of the FFmpeg filter (transformation
+ * graph), given in a string
+ * @param videos Array of input videos
+ * @param n_videos Size of the videos array
+ * @return UNIFEX_TERM
+ */
 static UNIFEX_TERM init_unifex_filter(UnifexEnv *env,
                                       const char *filter_description,
-                                      int pixel_format, int width, int height);
+                                      RawVideo videos[], int n_videos);
+
+int init_raw_video(RawVideo *raw_video, int width, int height,
+                   const char *pixel_format_name) {
+    int pixel_format = get_pixel_format(pixel_format_name);
+    if (pixel_format < 0) {
+        return -1;
+    }
+    raw_video->width = width;
+    raw_video->height = height;
+    raw_video->pixel_format = pixel_format;
+    return 0;
+}
 
 /**
- * @brief Initializes the state of the video compositor, creates a filter graph
+ * @brief Initializes the state of the video compositor and creates a filter
+ * graph. The function assumes two input videos and one output video.
  *
  * @param env Unifex environment
- * @param width Width of the videos
- * @param height Height of the videos
- * @param pixel_format_name Pixel format of the videos, given in a string
+ * @param first_width Width of the first video
+ * @param first_height Height of the first video
+ * @param first_pixel_format_name Pixel format of the first video, given in a
+ * string
+ * @param second_width Width of the second video
+ * @param second_height Height of the second video
+ * @param second_pixel_format_name Pixel format of the second video, given in a
+ * string
  * @return UNIFEX_TERM
  */
-UNIFEX_TERM init(UnifexEnv *env, int width, int height,
-                 char *pixel_format_name) {
+UNIFEX_TERM init(UnifexEnv *env, int first_width, int first_height,
+                 char *first_pixel_format_name, int second_width,
+                 int second_height, char *second_pixel_format_name) {
     UNIFEX_TERM result;
     char filter_str[512];
 
-    int pixel_format = get_pixel_format(pixel_format_name);
-    if (pixel_format < 0) {
+    RawVideo videos[2];
+    if (init_raw_video(&videos[0], first_width, first_height,
+                       first_pixel_format_name) < 0) {
+        result = init_result_error(env, "unsupported_pixel_format");
+        goto end;
+    }
+    if (init_raw_video(&videos[1], second_width, second_height,
+                       second_pixel_format_name) < 0) {
         result = init_result_error(env, "unsupported_pixel_format");
         goto end;
     }
-    init_filter_description(filter_str, sizeof filter_str, width, height,
-                            pixel_format);
-    result = init_unifex_filter(env, filter_str, pixel_format, width, height);
+
+    init_filter_description(filter_str, sizeof filter_str, videos,
+                            SIZE(videos));
+    result = init_unifex_filter(env, filter_str, videos, SIZE(videos));
 end:
     return result;
 }
 
-/**
- * @brief Create a unifex filter object
- *
- * @param env Unifex environment
- * @param filter_description Description of the FFmpeg filter (transformation
- * graph), given in a string
- * @param pixel_format Pixel format code of the videos
- * @param width Width of the videos
- * @param height Height of the videos
- * @return UNIFEX_TERM
- */
 static UNIFEX_TERM init_unifex_filter(UnifexEnv *env,
                                       const char *filter_description,
-                                      int pixel_format, int width, int height) {
+                                      RawVideo videos[], int n_videos) {
     UNIFEX_TERM result;
 
     State *state = unifex_alloc_state(env);
     for (int i = 0; i < SIZE(state->vstate.videos); i++) {
-        state->vstate.videos[i].height = height;
-        state->vstate.videos[i].width = width;
-        state->vstate.videos[i].pixel_format = pixel_format;
+        state->vstate.videos[i] = videos[i];
     }
 
     if (init_filters(filter_description, &state->vstate.filter) < 0) {

c_src/ffmpeg_video_compositor/video_compositor.spec.exs

@@ -3,9 +3,12 @@ module Membrane.VideoCompositor.FFmpeg.Native
 state_type "State"
 
 spec init(
-       width :: int,
-       height :: int,
-       pixel_format_name :: atom
+       first_width :: int,
+       first_height :: int,
+       first_pixel_format_name :: atom,
+       second_width :: int,
+       second_height :: int,
+       second_pixel_format_name :: atom
      ) :: {:ok :: label, state} | {:error :: label, reason :: atom}
 
 spec apply_filter(left_payload :: payload, right_payload :: payload, state) ::

test/video_compositor/video_compositor_ffmpeg_test.exs

@@ -12,6 +12,9 @@ defmodule VideoCompositor.FFmpeg.NativeTest do
 
     assert {:ok, ref} =
              Native.init(
+               640,
+               360,
+               :I420,
                640,
                360,
                :I420