Without any additional information, it's difficult to pinpoint the cause of this issue. It fails to parse h264 NALs, which might be the effect of an h264 video not following some specification or the bug in our `Membrane.H264.FFmpeg.Parser`. 

We don't recommend using `Membrane.H264.FFmpeg.Parser`. We released our own H264 parser, written entirely in Elixir, to fix issues we faced with one based on FFmpeg SDK and add some lacking features. You can check it out here: https://github.com/membraneframework/membrane_h264_plugin

Probably the simplest thing you can do to try fixing this issue is changing `Membrane.H264.FFmpeg.Parser` to `Membrane.H264.Parser`. This should be a simple modification. You just need to substitute `Membrane.H264.FFmpeg.Parser` with `Membrane.H264.Parser` and add the `:membrane_h264_plugin` dependency.

If you want to learn more about h264, NALs, and related topics, we released an article describing what we learned during h264 parser development. Here is a link: https://membrane.stream/learn/h264 This article itself is a little bit technical, and reading it probably isn't necessary to solve your problem 🙂

I just fix this issue this is the new code
```elixir
  @impl true
  def handle_init(_ctx, socket: socket) do
    spec = [
      child(:src, %Membrane.RTMP.Source{
        socket: socket,
        validator: Membrane.RTMP.DefaultMessageValidator
      })
      |> child(:demuxer, Membrane.FLV.Demuxer),
      child(:audio_parser, %Membrane.AAC.Parser{
        in_encapsulation: :none,
        out_encapsulation: :none
      }),
      child(:video_parser, %Membrane.H264.FFmpeg.Parser{
        alignment: :au,
        attach_nalus?: true,
        skip_until_keyframe?: true
      }),
      child(:sink, %Membrane.RTMP.Sink{
        rtmp_url: "rtmp://localhost:5000"
      }),
      get_child(:demuxer)
      |> via_out(Pad.ref(:audio, 0))
      |> get_child(:audio_parser)
      |> via_in(Pad.ref(:audio, 0))
      |> get_child(:sink),
      get_child(:demuxer)
      |> via_out(Pad.ref(:video, 0))
      |> get_child(:video_parser)
      |> via_in(Pad.ref(:video, 0))
      |> get_child(:sink)
    ]

    {[spec: spec, playback: :playing], %{}}
  end


```
but still error with `/:src/ Failed to take control of the socket`

this the handler
```elixir
# Once the source initializes, we grant it the control over the tcp socket
  @impl true
  def handle_child_notification(
        {:socket_control_needed, _socket, _source} = notification,
        :source,
        _ctx,
        state
      ) do
    send(self(), notification)

    {[], state}
  end

  def handle_child_notification(_notification, _child, _ctx, state) do
    {[], state}
  end

  @impl true
  def handle_info({:socket_control_needed, socket, source} = notification, _ctx, state) do
    case Membrane.RTMP.SourceBin.pass_control(socket, source) do
      :ok ->
        :ok

      {:error, :not_owner} ->
        Process.send_after(self(), notification, 200)
    end

    {[], state}
  end

  @impl true
  def handle_element_end_of_stream(:sink, _pad, _ctx, state) do
    {[terminate: :shutdown], state}
  end

  @impl true
  def handle_element_end_of_stream(_child, _pad, _ctx, state) do
    {[], state}
  end
```

Hi,
it seems that there is a problem with passing control over the tcp socket to the `Source` element.

Usually the flow goes like this:
start the TCP Server ->
upon receiving new connection, the Server starts new pipeline (the Server gives control of the socket to the pipeline) ->
when the `Source` is started within pipeline, it sends `:socket_control_needed` notification to the pipeline ->
the pipeline gives socket control to the `Source`

You can take a look at the example inside the `membrane_rtmp_plugin` repo:
https://github.com/membraneframework/membrane_rtmp_plugin/blob/master/examples/source.exs

this error just happen when sink to rtmp server if sink to file it works.

Yes, the `RTMP.Sink` uses ffmpeg, so there is no such problem.
You may try running the example first (does it work when you try it?).
Then you may work your way up from here to your desired pipeline.

You may also try adding `IO.inspect`s inside the `RTMP.Source.TcpServer` , `RTMP.SourceBin` and `RTMP.Source` to make sure, that the control of the socket is properly passed to the Source element.

Also, is there a reason why you're using `RTMP.Source` directly and not the `RTMP.SourceBin` ? `RTMP.SourceBin` wraps the logic of receiving RTMP stream and parsing the output audio and video. Unless you have a more specific use case you can use the SourceBin inside your pipeline.

I fixed the problem but i was a payloader issue not tcp
and i use rtmp source becuase of `skip_until_parameters?`
but i still get some error

```elixir
  @impl true
  def handle_init(_ctx, socket: socket) do
    spec = [
      child(:source, %Membrane.RTMP.SourceBin{
        socket: socket
      }),
     child(:video_payloader, Membrane.MP4.Payloader.H264),
      child(:sink, %Membrane.RTMP.Sink{
        rtmp_url: "rtmp://live.restream.io/live/#{@stream_key}"
        
      }),
      get_child(:source)
      |> via_out(:audio)
      |> via_in(Pad.ref(:audio, 0))
      |> get_child(:sink),
      get_child(:source)
      |> via_out(:video)
      |> get_child(:video_payloader)
      |> via_in(Pad.ref(:video, 0))
      |> get_child(:sink)
   ]

    {[spec: spec, playback: :playing], %{}}
  end
```

i fixed with pr it was not waiting for other frame buffer

Restream.io like website.

mohammedzeglam

9 responses

Join out Discord Community