Pipeline with RTMP source and AAC decoder

N

You are using the fake sink at the end of your pipeline. This sink just makes demand on its input (the converter) and drops the buffers. You need to use a sink which actually makes some output -- consider the file sink.

E

enzoqtvfOP•5/10/23, 9:38 AM

Got the same result with this:

 def handle_init(_ctx, socket: socket) do
    structure = [
      child(:source, %Membrane.RTMP.SourceBin{
        socket: socket,
        validator: Membrane.RTMP.DefaultMessageValidator
      })
      |> via_out(:audio)
      |> child(:decoder, Membrane.AAC.FDK.Decoder)
      |> child(:converter, %Converter{
        output_stream_format: %RawAudio{
          sample_format: :f32le,
          sample_rate: 16000,
          channels: 1
        }
      })
      |> child(:sink, %Membrane.File.Sink{location: "test.pcm"})
    ]

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

 def handle_init(_ctx, socket: socket) do
    structure = [
      child(:source, %Membrane.RTMP.SourceBin{
        socket: socket,
        validator: Membrane.RTMP.DefaultMessageValidator
      })
      |> via_out(:audio)
      |> child(:decoder, Membrane.AAC.FDK.Decoder)
      |> child(:converter, %Converter{
        output_stream_format: %RawAudio{
          sample_format: :f32le,
          sample_rate: 16000,
          channels: 1
        }
      })
      |> child(:sink, %Membrane.File.Sink{location: "test.pcm"})
    ]

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

 def handle_init(_ctx, socket: socket) do
    structure = [
      child(:source, %Membrane.RTMP.SourceBin{
        socket: socket,
        validator: Membrane.RTMP.DefaultMessageValidator
      })
      |> via_out(:audio)
      |> child(:decoder, Membrane.AAC.FDK.Decoder)
      |> child(:converter, %Converter{
        output_stream_format: %RawAudio{
          sample_format: :f32le,
          sample_rate: 16000,
          channels: 1
        }
      })
      |> child(:sink, %Membrane.File.Sink{location: "test.pcm"})
    ]

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

 def handle_init(_ctx, socket: socket) do
    structure = [
      child(:source, %Membrane.RTMP.SourceBin{
        socket: socket,
        validator: Membrane.RTMP.DefaultMessageValidator
      })
      |> via_out(:audio)
      |> child(:decoder, Membrane.AAC.FDK.Decoder)
      |> child(:converter, %Converter{
        output_stream_format: %RawAudio{
          sample_format: :f32le,
          sample_rate: 16000,
          channels: 1
        }
      })
      |> child(:sink, %Membrane.File.Sink{location: "test.pcm"})
    ]

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

V

varsill•5/10/23, 11:15 AM

It seems as if the buffer weren't flowing through the pipeline at all. Are there any logs that indicate, that the Source Bin is processing the packets?

E

enzoqtvfOP•5/10/23, 1:36 PM

I think I found my issue, I got it working by not using the Membrane.RTMP.SourceBin, but instead use Membrane.RTMP.Source, doing it that way:

def handle_init(_ctx, socket: socket) do
    structure = [
      child(:source, %Membrane.RTMP.Source{
        socket: socket,
        validator: Membrane.RTMP.DefaultMessageValidator
      })
      |> child(:demuxer, Membrane.FLV.Demuxer)
      |> via_out(Pad.ref(:audio, 0))
      |> child(:audio_parser, %Membrane.AAC.Parser{in_encapsulation: :none})
      |> child(:decoder, Membrane.AAC.FDK.Decoder)
      |> child(:converter, %Converter{
        output_stream_format: %RawAudio{
          sample_format: :f32le,
          sample_rate: 16000,
          channels: 1
        }
      })
      |> child(:fake_sink, Membrane.Fake.Sink.Buffers)
    ]

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

def handle_init(_ctx, socket: socket) do
    structure = [
      child(:source, %Membrane.RTMP.Source{
        socket: socket,
        validator: Membrane.RTMP.DefaultMessageValidator
      })
      |> child(:demuxer, Membrane.FLV.Demuxer)
      |> via_out(Pad.ref(:audio, 0))
      |> child(:audio_parser, %Membrane.AAC.Parser{in_encapsulation: :none})
      |> child(:decoder, Membrane.AAC.FDK.Decoder)
      |> child(:converter, %Converter{
        output_stream_format: %RawAudio{
          sample_format: :f32le,
          sample_rate: 16000,
          channels: 1
        }
      })
      |> child(:fake_sink, Membrane.Fake.Sink.Buffers)
    ]

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

def handle_init(_ctx, socket: socket) do
    structure = [
      child(:source, %Membrane.RTMP.Source{
        socket: socket,
        validator: Membrane.RTMP.DefaultMessageValidator
      })
      |> child(:demuxer, Membrane.FLV.Demuxer)
      |> via_out(Pad.ref(:audio, 0))
      |> child(:audio_parser, %Membrane.AAC.Parser{in_encapsulation: :none})
      |> child(:decoder, Membrane.AAC.FDK.Decoder)
      |> child(:converter, %Converter{
        output_stream_format: %RawAudio{
          sample_format: :f32le,
          sample_rate: 16000,
          channels: 1
        }
      })
      |> child(:fake_sink, Membrane.Fake.Sink.Buffers)
    ]

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

def handle_init(_ctx, socket: socket) do
    structure = [
      child(:source, %Membrane.RTMP.Source{
        socket: socket,
        validator: Membrane.RTMP.DefaultMessageValidator
      })
      |> child(:demuxer, Membrane.FLV.Demuxer)
      |> via_out(Pad.ref(:audio, 0))
      |> child(:audio_parser, %Membrane.AAC.Parser{in_encapsulation: :none})
      |> child(:decoder, Membrane.AAC.FDK.Decoder)
      |> child(:converter, %Converter{
        output_stream_format: %RawAudio{
          sample_format: :f32le,
          sample_rate: 16000,
          channels: 1
        }
      })
      |> child(:fake_sink, Membrane.Fake.Sink.Buffers)
    ]

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

Somehow the extra part:

|> bin_output(:audio),

|> bin_output(:audio),

|> bin_output(:audio),

|> bin_output(:audio), that is part of the SourceBin was causing issues. Not sure exactly why, still a noob with Membrane

N

nickdichev_fw•5/10/23, 4:26 PM

It's because of an implicit naming of the pads. Typically, pads will take in input on a pad named

:input

:input

:input

:input and output on pads named

:output

:output

:output

:output. When this is the case, you don't need to specify a

via_{in,out}

via_{in,out}

via_{in,out}

via_{in,out} between elements when building the pipeline.

We can see this is the case for the RTMP source and the FLV demuxer:

https://github.com/membraneframework/membrane_rtmp_plugin/blob/v0.11.2/lib/membrane_rtmp_plugin/rtmp/source/source.ex#L20

https://github.com/membraneframework/membrane_flv_plugin/blob/master/lib/membrane_flv_plugin/demuxer.ex#L40

However, notice that the FLV demuxer defines two output pads:

:audio

:audio

:audio

:audio and

:video

:video

:video

:video. This is to be expected since demuxing is the process of splitting the stream apart into its audio and video components.

This is why you must have the

via_out

via_out

via_out

via_out between the demuxer and the AAC parser -- you need to specify the parser will get input from the

:audio

:audio

:audio

:audio pad of the previous element.

GitHub

membrane_rtmp_plugin/source.ex at v0.11.2 · membraneframework/membr...

Contribute to membraneframework/membrane_rtmp_plugin development by creating an account on GitHub.

GitHub

membrane_flv_plugin/demuxer.ex at master · membraneframework/membra...

Contribute to membraneframework/membrane_flv_plugin development by creating an account on GitHub.

V

varsill•5/11/23, 2:46 PM

Apparently there is a small bug in Membrane Core. In your case with

SourceBin

SourceBin

SourceBin

SourceBin you haven't linked the static output

video

video

video

video pad of the

SourceBin

SourceBin

SourceBin

SourceBin, and the Core should raise an informative exception that all static pads must be linked - which does not happen. Instead, the buffers flow doesn't start. The following children specification should work, though:

 def handle_init(_ctx, socket: socket) do
    structure = [
      child(:source, %Membrane.RTMP.SourceBin{
        socket: socket,
        validator: Membrane.RTMP.DefaultMessageValidator
      })
      |> via_out(:audio)
      |> child(:decoder, Membrane.AAC.FDK.Decoder)
      |> child(:converter, %Converter{
        output_stream_format: %RawAudio{
          sample_format: :f32le,
          sample_rate: 16000,
          channels: 1
        }
      })
      |> child(:fake_sink, Membrane.Fake.Sink.Buffers),
      get_child(:source) |> via_out(:video) |>     child(:fake_sink2, Membrane.Fake.Sink.Buffers)
    ]

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

 def handle_init(_ctx, socket: socket) do
    structure = [
      child(:source, %Membrane.RTMP.SourceBin{
        socket: socket,
        validator: Membrane.RTMP.DefaultMessageValidator
      })
      |> via_out(:audio)
      |> child(:decoder, Membrane.AAC.FDK.Decoder)
      |> child(:converter, %Converter{
        output_stream_format: %RawAudio{
          sample_format: :f32le,
          sample_rate: 16000,
          channels: 1
        }
      })
      |> child(:fake_sink, Membrane.Fake.Sink.Buffers),
      get_child(:source) |> via_out(:video) |>     child(:fake_sink2, Membrane.Fake.Sink.Buffers)
    ]

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

 def handle_init(_ctx, socket: socket) do
    structure = [
      child(:source, %Membrane.RTMP.SourceBin{
        socket: socket,
        validator: Membrane.RTMP.DefaultMessageValidator
      })
      |> via_out(:audio)
      |> child(:decoder, Membrane.AAC.FDK.Decoder)
      |> child(:converter, %Converter{
        output_stream_format: %RawAudio{
          sample_format: :f32le,
          sample_rate: 16000,
          channels: 1
        }
      })
      |> child(:fake_sink, Membrane.Fake.Sink.Buffers),
      get_child(:source) |> via_out(:video) |>     child(:fake_sink2, Membrane.Fake.Sink.Buffers)
    ]

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

 def handle_init(_ctx, socket: socket) do
    structure = [
      child(:source, %Membrane.RTMP.SourceBin{
        socket: socket,
        validator: Membrane.RTMP.DefaultMessageValidator
      })
      |> via_out(:audio)
      |> child(:decoder, Membrane.AAC.FDK.Decoder)
      |> child(:converter, %Converter{
        output_stream_format: %RawAudio{
          sample_format: :f32le,
          sample_rate: 16000,
          channels: 1
        }
      })
      |> child(:fake_sink, Membrane.Fake.Sink.Buffers),
      get_child(:source) |> via_out(:video) |>     child(:fake_sink2, Membrane.Fake.Sink.Buffers)
    ]

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

E

enzoqtvfOP•5/12/23, 12:10 PM

Ah I see interesting, now it makes more sense thanks !

V

varsill•5/12/23, 12:24 PM

You are welcome! In case you are still experimenting with that, just please let us know if my proposed solution works, so we will be able to mark the thread as "closed"

E

enzoqtvfOP•5/15/23, 9:03 AM

Hey, I tried and it does work

Pipeline with RTMP source and AAC decoder

Similar Threads

Similar Threads

Similar Threads