Refactor elixir endpoints #118

Noarkhh · 2025-11-14T17:22:22Z

When using server-based endpoints (reader, writer, message), the server will now spawn the pipeline directly and communicate with elixir elements directly.

I'm not sure which approach is better for having push and pull elixir source and sink - using defdelegetes and have a common behavior module (the current one) or have a macro that generates push and pull element.

mat-hek · 2025-11-28T15:13:14Z

@Noarkhh I'd go for a macro that generates push & pull elements ;)

mat-hek · 2025-12-01T11:11:31Z

lib/boombox/server.ex

+            membrane_source_demand: non_neg_integer(),
+            pipeline_supervisor: pid() | nil,
+            pipeline: pid() | nil,
+            ghosted_client: GenServer.from() | Process.dest() | nil,


This name is a bit ambiguous, maybe client_to_reply or current_client?

mat-hek · 2025-12-01T11:14:55Z

python/src/boombox/boombox.py


 RELEASES_URL = "https://github.com/membraneframework/boombox/releases"
-PACKAGE_NAME = "boomboxlib"
+PACKAGE_NAME = "boomboxlibb"


mat-hek · 2025-12-01T11:17:41Z

python/src/boombox/boombox.py

+
+        match self._call(request):
+            case Atom("ok"):
+                print("uuuu")


mat-hek · 2025-12-01T11:20:40Z

lib/boombox/pipeline.ex

+      |> Map.update!(:input, &resolve_elixir_endpoint(&1, self()))
+      |> Map.update!(:output, &resolve_elixir_endpoint(&1, self()))


endpoint resolution happens in the internal bin, can we move this there?

not really, because we need to call self() in the parent process, not the bin

We're passing this pid as a parent option. We can pass it to the internal bin as well

mat-hek · 2025-12-01T11:32:26Z

examples.livemd

 Stream.unfold(%{}, fn _state ->
-  {result1, packet1} = Boombox.read(reader1)
-  {result2, packet2} = Boombox.read(reader2)
+  case {Boombox.read(reader1), Boombox.read(reader2)} do
+    {:finished, :finished} ->
+      nil

-  joined_image =
-    Vix.Vips.Operation.join!(packet1.payload, packet2.payload, :VIPS_DIRECTION_HORIZONTAL)
+    {{:ok, _packet}, :finished} ->
+      Boombox.close(reader1)
+      nil

-  packet = %Boombox.Packet{
-    pts: max(packet1.pts, packet2.pts),
-    payload: joined_image,
-    kind: :video
-  }
+    {:finished, {:ok, _packet}} ->
+      Boombox.close(reader2)
+      nil

-  Boombox.write(writer, packet)
+    {{:ok, packet1}, {:ok, packet2}} ->
+      joined_image =
+        Vix.Vips.Operation.join!(packet1.payload, packet2.payload, :VIPS_DIRECTION_HORIZONTAL)

-  if :finished in [result1, result2] do
-    if result1 == :ok, do:
-      Boombox.close(reader1)
-    if result2 == :ok, do:
-      Boombox.close(reader2)
-    nil
-  else
-    {nil, %{}}
+      packet = %Boombox.Packet{
+        pts: max(packet1.pts, packet2.pts),
+        payload: joined_image,
+        kind: :video
+      }
+
+      Boombox.write(writer, packet)
+
+      {nil, %{}}
  end


Stream.unfold with an ignored state looks weird. Also, matching on all the possibilities seems redundant. I'd go for

Suggested change

Stream.unfold(%{}, fn _state ->

{result1, packet1} = Boombox.read(reader1)

{result2, packet2} = Boombox.read(reader2)

case {Boombox.read(reader1), Boombox.read(reader2)} do

{:finished, :finished} ->

nil

joined_image =

Vix.Vips.Operation.join!(packet1.payload, packet2.payload, :VIPS_DIRECTION_HORIZONTAL)

{{:ok, _packet}, :finished} ->

Boombox.close(reader1)

nil

packet = %Boombox.Packet{

pts: max(packet1.pts, packet2.pts),

payload: joined_image,

kind: :video

}

{:finished, {:ok, _packet}} ->

Boombox.close(reader2)

nil

Boombox.write(writer, packet)

{{:ok, packet1}, {:ok, packet2}} ->

joined_image =

Vix.Vips.Operation.join!(packet1.payload, packet2.payload, :VIPS_DIRECTION_HORIZONTAL)

if :finished in [result1, result2] do

if result1 == :ok, do:

Boombox.close(reader1)

if result2 == :ok, do:

Boombox.close(reader2)

nil

else

{nil, %{}}

packet = %Boombox.Packet{

pts: max(packet1.pts, packet2.pts),

payload: joined_image,

kind: :video

}

Boombox.write(writer, packet)

{nil, %{}}

end

Stream.repeatedly(fn ->

case {Boombox.read(reader1), Boombox.read(reader2)} do

{{:ok, packet1}, {:ok, packet2}} ->

joined_image =

Vix.Vips.Operation.join!(packet1.payload, packet2.payload, :VIPS_DIRECTION_HORIZONTAL)

packet = %Boombox.Packet{

pts: max(packet1.pts, packet2.pts),

payload: joined_image,

kind: :video

}

:ok = Boombox.write(writer, packet)

_finished ->

:eos

end

end)

|> Enum.find(& &1 == :eos)

@mat-hek it looks good we just need to remember to call Boombox.close()

Right, missed that. Maybe Boombox.close on already closed boombox could be a noop, so we could just close both boomboxes no matter what?

varsill · 2025-12-02T14:42:31Z

lib/boombox/internal_bin/elixir_endpoints/pull_sink.ex

+
+  alias Boombox.InternalBin.ElixirEndpoints.Sink
+
+  def_input_pad :input,


How many pads of this type can exist? Wouldn't max_instances be applicable here?

varsill · 2025-12-02T14:45:01Z

examples.livemd

+       bb_states: %{
         bb1: %{last_packet: nil, eos: false},
         bb2: %{last_packet: nil, eos: false}
       },
-       input_boomboxes: %{bb1 => :bb1, bb2 => :bb2},
+       bbs: %{bb1 => :bb1, bb2 => :bb2},


[NIT] I am not 100% encouraged by this change, bbs look quite funny to me :D

varsill · 2025-12-02T14:47:56Z

examples.livemd

 Stream.unfold(%{}, fn _state ->
-  {result1, packet1} = Boombox.read(reader1)
-  {result2, packet2} = Boombox.read(reader2)
+  case {Boombox.read(reader1), Boombox.read(reader2)} do
+    {:finished, :finished} ->
+      nil

-  joined_image =
-    Vix.Vips.Operation.join!(packet1.payload, packet2.payload, :VIPS_DIRECTION_HORIZONTAL)
+    {{:ok, _packet}, :finished} ->
+      Boombox.close(reader1)
+      nil

-  packet = %Boombox.Packet{
-    pts: max(packet1.pts, packet2.pts),
-    payload: joined_image,
-    kind: :video
-  }
+    {:finished, {:ok, _packet}} ->
+      Boombox.close(reader2)
+      nil

-  Boombox.write(writer, packet)
+    {{:ok, packet1}, {:ok, packet2}} ->
+      joined_image =
+        Vix.Vips.Operation.join!(packet1.payload, packet2.payload, :VIPS_DIRECTION_HORIZONTAL)

-  if :finished in [result1, result2] do
-    if result1 == :ok, do:
-      Boombox.close(reader1)
-    if result2 == :ok, do:
-      Boombox.close(reader2)
-    nil
-  else
-    {nil, %{}}
+      packet = %Boombox.Packet{
+        pts: max(packet1.pts, packet2.pts),
+        payload: joined_image,
+        kind: :video
+      }
+
+      Boombox.write(writer, packet)
+
+      {nil, %{}}
  end


@mat-hek it looks good we just need to remember to call Boombox.close()

varsill · 2025-12-02T14:56:57Z

test/boombox_test.exs

            Stream.unfold(:ok, fn
              :ok ->
-                {result, packet} = Boombox.read(boombox)
-                {packet, result}
-
-              :finished ->
-                nil
+                case Boombox.read(boombox) do
+                  {:ok, packet} -> {packet, :ok}
+                  :finished -> nil
+                end


[NIT] This "state" here is useless so you can remove it
And similarly to the case in examples.livemd, you could use Enum.repeatedly here

varsill · 2025-12-02T14:59:58Z

python/src/boombox/boombox.py

                if not self._response.done():
                    self._response.set_result(response)
            case (Atom("DOWN"), _, Atom("process"), _, Atom("normal")):
+                print(self._boombox_mode)


I think you can remove these :D

varsill · 2025-12-02T15:05:13Z

lib/boombox/internal_bin/elixir_endpoints/sink.ex


-  @impl true
-  def handle_info(:boombox_demand, _ctx, state) do
+  def handle_info({:boombox_demand, consumer}, _ctx, %{consumer: consumer} = state) do


shouldn't we buffer that demand up if consumer is not yet available?

Actually after looking at the whole module I am not sure if the consumer field in the state is defined anywhere

the consumer is passed with options, but I agree, this needs better typing

varsill · 2025-12-02T15:08:59Z

lib/boombox/internal_bin/elixir_endpoints/push_sink.ex

+  def_input_pad :input,
+    accepted_format: any_of(Membrane.RawAudio, Membrane.RawVideo),
+    availability: :on_request,
+    flow_control: :auto


Why :auto instead of :push?

Noarkhh self-assigned this Nov 14, 2025

Noarkhh added this to Smackore Nov 14, 2025

Noarkhh moved this to In Progress in Smackore Nov 14, 2025

Noarkhh changed the base branch from master to message-endpoint November 14, 2025 17:23

Noarkhh force-pushed the refactor-elixir-endpoints branch from 7cb399c to e85f6a1 Compare November 14, 2025 17:23

Noarkhh force-pushed the message-endpoint branch 2 times, most recently from 31ca721 to 88a148a Compare November 26, 2025 09:21

Noarkhh added 11 commits November 26, 2025 16:13

Implement a message endpoint

0992e91

refactor wip

8dc5598

WIP

be187e5

wip

43420c1

Make the refactor work for pull flow control

8cbe6fa

Refactor working

0c85013

Fix receiving finished

085de72

Fix typespecs

7ae75a2

Fix sink

36cb5c5

Handle termination requests correctly

bd7808e

Fix examples

b4ac36b

Noarkhh force-pushed the message-endpoint branch from 88a148a to e44efe8 Compare November 26, 2025 15:17

Noarkhh force-pushed the refactor-elixir-endpoints branch 2 times, most recently from 9ac398d to b729d70 Compare November 26, 2025 15:20

Noarkhh requested review from mat-hek and varsill November 26, 2025 15:54

Noarkhh force-pushed the refactor-elixir-endpoints branch from b729d70 to 4c07d31 Compare November 26, 2025 15:55

Fix naming

a053f6c

Noarkhh force-pushed the refactor-elixir-endpoints branch from 4c07d31 to a053f6c Compare November 26, 2025 15:59

Noarkhh moved this from In Progress to In Review in Smackore Nov 26, 2025

mat-hek requested changes Dec 1, 2025

View reviewed changes

varsill requested changes Dec 2, 2025

View reviewed changes

Noarkhh force-pushed the refactor-elixir-endpoints branch 3 times, most recently from 7cf42c2 to ade6ffc Compare December 3, 2025 14:56

Apply reviewers suggestions

5a236ad

Noarkhh force-pushed the refactor-elixir-endpoints branch from ade6ffc to 5a236ad Compare December 3, 2025 14:57

Noarkhh added 2 commits December 3, 2025 16:09

Add max_instances to elements

fee9b60

Satisfy 1.19 compiler

e99f2d6

Noarkhh force-pushed the refactor-elixir-endpoints branch from b46ae53 to e99f2d6 Compare December 3, 2025 17:05

Noarkhh requested review from mat-hek and varsill December 4, 2025 15:21

		\|> Map.update!(:input, &resolve_elixir_endpoint(&1, self()))
		\|> Map.update!(:output, &resolve_elixir_endpoint(&1, self()))


		alias Boombox.InternalBin.ElixirEndpoints.Sink

		def_input_pad :input,

Refactor elixir endpoints #118

Are you sure you want to change the base?

Refactor elixir endpoints #118

Uh oh!

Conversation

Noarkhh commented Nov 14, 2025 • edited Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

Uh oh!

mat-hek commented Nov 28, 2025

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Reviewers

Assignees

Labels

Projects

Milestone

Development

Uh oh!

4 participants

Noarkhh commented Nov 14, 2025 •

edited

Loading