2 |
4 |
5 |
--------------------------------------------------------------------------------
/examples/webrtc_to_hls/lib/webrtc_to_hls_web/templates/page/player.html.heex:
--------------------------------------------------------------------------------
1 |
2 |
3 |
15 |
--------------------------------------------------------------------------------
/examples/webrtc_to_hls/lib/webrtc_to_hls_web/user_socket.ex:
--------------------------------------------------------------------------------
1 | defmodule WebRTCToHLSWeb.UserSocket do
2 | use Phoenix.Socket
3 |
4 | channel("stream", WebRTCToHLSWeb.StreamChannel)
5 |
6 | @impl true
7 | def connect(_params, socket, _connect_info) do
8 | {:ok, socket}
9 | end
10 |
11 | @impl true
12 | def id(_socket), do: nil
13 | end
14 |
--------------------------------------------------------------------------------
/examples/webrtc_to_hls/lib/webrtc_to_hls_web/views/error_view.ex:
--------------------------------------------------------------------------------
1 | defmodule WebRTCToHLSWeb.ErrorView do
2 | use WebRTCToHLSWeb, :view
3 |
4 | # If you want to customize a particular status code
5 | # for a certain format, you may uncomment below.
6 | # def render("500.html", _assigns) do
7 | # "Internal Server Error"
8 | # end
9 |
10 | # By default, Phoenix returns the status message from
11 | # the template name. For example, "404.html" becomes
12 | # "Not Found".
13 | def template_not_found(template, _assigns) do
14 | Phoenix.Controller.status_message_from_template(template)
15 | end
16 | end
17 |
--------------------------------------------------------------------------------
/examples/webrtc_to_hls/lib/webrtc_to_hls_web/views/layout_view.ex:
--------------------------------------------------------------------------------
1 | defmodule WebRTCToHLSWeb.LayoutView do
2 | use WebRTCToHLSWeb, :view
3 | end
4 |
--------------------------------------------------------------------------------
/examples/webrtc_to_hls/lib/webrtc_to_hls_web/views/page_view.ex:
--------------------------------------------------------------------------------
1 | defmodule WebRTCToHLSWeb.PageView do
2 | use WebRTCToHLSWeb, :view
3 | end
4 |
--------------------------------------------------------------------------------
/examples/webrtc_to_hls/mix.exs:
--------------------------------------------------------------------------------
1 | defmodule WebRTCToHLS.MixProject do
2 | use Mix.Project
3 |
4 | def project do
5 | [
6 | app: :membrane_webrtc_to_hls_demo,
7 | version: "0.1.0",
8 | elixir: "~> 1.14",
9 | start_permanent: Mix.env() == :prod,
10 | aliases: aliases(),
11 | deps: deps()
12 | ]
13 | end
14 |
15 | def application do
16 | [
17 | mod: {WebRTCToHLS.Application, []},
18 | extra_applications: [:logger, :crypto]
19 | ]
20 | end
21 |
22 | defp deps do
23 | [
24 | {:plug_cowboy, "~> 2.5.2"},
25 | {:phoenix, "~> 1.6"},
26 | {:phoenix_html, "~> 3.0"},
27 | {:phoenix_live_view, "~> 0.16.0"},
28 | {:phoenix_live_reload, "~> 1.3"},
29 | {:jason, "~> 1.2"},
30 | {:phoenix_inline_svg, "~> 1.4"},
31 | {:elixir_uuid, "~> 1.2"},
32 | {:esbuild, "~> 0.4", runtime: Mix.env() == :dev},
33 | {:cowlib, "~> 2.11.0", override: true},
34 |
35 | # rtc engine dependencies
36 | {:membrane_rtc_engine, "~> 0.22.0"},
37 | {:membrane_rtc_engine_hls, "~> 0.7.0"},
38 | {:membrane_rtc_engine_webrtc, "~> 0.8.0"},
39 |
40 | # hls dependencies
41 | {:membrane_audio_mix_plugin, "~> 0.16.0", optional: true},
42 | {:membrane_video_compositor_plugin, "~> 0.7.0", optional: true}
43 | ]
44 | end
45 |
46 | defp aliases do
47 | [
48 | setup: ["deps.get", "cmd --cd assets npm ci"],
49 | "assets.deploy": [
50 | "cmd --cd assets npm run deploy",
51 | "esbuild default --minify",
52 | "phx.digest"
53 | ]
54 | ]
55 | end
56 | end
57 |
--------------------------------------------------------------------------------
/examples/webrtc_to_hls/package-lock.json:
--------------------------------------------------------------------------------
1 | {
2 | "name": "webrtc_to_hls",
3 | "lockfileVersion": 3,
4 | "requires": true,
5 | "packages": {}
6 | }
7 |
--------------------------------------------------------------------------------
/examples/webrtc_to_hls/priv/certs/.gitkeep:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/fishjam-dev/membrane_rtc_engine/2b519efdcdecd737eeeaa74be8e50904f2c5d0c0/examples/webrtc_to_hls/priv/certs/.gitkeep
--------------------------------------------------------------------------------
/examples/webrtc_to_hls/test/test_helper.exs:
--------------------------------------------------------------------------------
1 | ExUnit.start()
2 |
--------------------------------------------------------------------------------
/examples/webrtc_videoroom/.formatter.exs:
--------------------------------------------------------------------------------
1 | # Used by "mix format"
2 | [
3 | inputs: ["{mix,.formatter}.exs", "{config,lib,test}/**/*.{ex,exs}"]
4 | ]
5 |
--------------------------------------------------------------------------------
/examples/webrtc_videoroom/.gitignore:
--------------------------------------------------------------------------------
1 | .idea/
2 | *.iml
3 | priv/certs/*.pem
4 | priv/static/assets
5 | priv/static/js
6 |
7 | # The directory Mix will write compiled artifacts to.
8 | /_build/
9 |
10 | # If you run "mix test --cover", coverage assets end up here.
11 | /cover/
12 |
13 | # The directory Mix downloads your dependencies sources to.
14 | /deps/
15 |
16 | # Where third-party dependencies like ExDoc output generated docs.
17 | /doc/
18 |
19 | # Ignore .fetch files in case you like to edit your project deps locally.
20 | /.fetch
21 |
22 | # If the VM crashes, it generates a dump, let's ignore it too.
23 | erl_crash.dump
24 |
25 | # Also ignore archive artifacts (built via "mix archive.build").
26 | *.ez
27 |
28 | # Ignore package tarball (built via "mix hex.build").
29 | videoroom-*.tar
30 |
31 | .elixir_ls
32 |
33 | node_modules
34 |
35 | # macOS
36 | .DS_Store
37 |
--------------------------------------------------------------------------------
/examples/webrtc_videoroom/assets/css/app.css:
--------------------------------------------------------------------------------
1 | @import "tailwindcss/base";
2 | @import "tailwindcss/components";
3 | @import "tailwindcss/utilities";
4 |
5 | .flip-horizontally {
6 | transform: scaleX(-1);
7 | }
8 |
9 | .text-shadow-lg {
10 | text-shadow: 3px 1px 10px rgb(22, 22, 22);
11 | }
12 |
13 | .ratio-video {
14 | aspect-ratio: 16 / 9;
15 | }
16 |
--------------------------------------------------------------------------------
/examples/webrtc_videoroom/assets/esbuild.js:
--------------------------------------------------------------------------------
1 | const esbuild = require("esbuild");
2 | const path = require("path");
3 |
4 | esbuild
5 | .build({
6 | entryPoints: ["src/index.ts"],
7 | outdir: path.resolve(__dirname, "../priv/static/"),
8 | bundle: true,
9 | sourcemap: true,
10 | minify: true,
11 | format: "cjs",
12 | target: ["es6"],
13 | })
14 | .catch(() => process.exit(1));
15 |
--------------------------------------------------------------------------------
/examples/webrtc_videoroom/assets/package.json:
--------------------------------------------------------------------------------
1 | {
2 | "license": "MIT",
3 | "scripts": {
4 | "deploy": "NODE_ENV=production tailwindcss --postcss --minify -i css/app.css -o ../priv/static/assets/css/app.css",
5 | "format": "prettier --write .",
6 | "format:check": "prettier --check ."
7 | },
8 | "dependencies": {
9 | "@fishjam-dev/ts-client": "0.5.0",
10 | "phoenix": "file:../deps/phoenix",
11 | "phoenix_html": "file:../deps/phoenix_html",
12 | "query-string": "^7.0.0",
13 | "uuid": "^8.3.2"
14 | },
15 | "devDependencies": {
16 | "@tailwindcss/aspect-ratio": "^0.3.0",
17 | "@types/phoenix": "^1.6.4",
18 | "autoprefixer": "^10.2.0",
19 | "postcss": "^8.3.5",
20 | "postcss-import": "^14.0.2",
21 | "prettier": "^2.2.1",
22 | "tailwindcss": "^2.2.4"
23 | }
24 | }
25 |
--------------------------------------------------------------------------------
/examples/webrtc_videoroom/assets/postcss.config.js:
--------------------------------------------------------------------------------
1 | module.exports = {
2 | plugins: {
3 | "postcss-import": {},
4 | tailwindcss: {},
5 | autoprefixer: {},
6 | },
7 | };
8 |
--------------------------------------------------------------------------------
/examples/webrtc_videoroom/assets/src/consts.ts:
--------------------------------------------------------------------------------
1 | export const MEDIA_CONSTRAINTS: MediaStreamConstraints = {
2 | audio: true,
3 | video: { width: 640, height: 360, frameRate: 24 },
4 | };
5 |
6 | export const LOCAL_ENDPOINT_ID = "local-endpoint";
7 |
--------------------------------------------------------------------------------
/examples/webrtc_videoroom/assets/src/index.ts:
--------------------------------------------------------------------------------
1 | import { Room } from "./room";
2 |
3 | const room = new Room();
4 | room.join();
5 |
--------------------------------------------------------------------------------
/examples/webrtc_videoroom/assets/static/favicon.ico:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/fishjam-dev/membrane_rtc_engine/2b519efdcdecd737eeeaa74be8e50904f2c5d0c0/examples/webrtc_videoroom/assets/static/favicon.ico
--------------------------------------------------------------------------------
/examples/webrtc_videoroom/assets/tailwind.config.js:
--------------------------------------------------------------------------------
1 | module.exports = {
2 | mode: "jit",
3 | purge: {
4 | content: ["./js/**/*.js", "../lib/*_web/**/*.*ex"],
5 | safelist: [
6 | "grid",
7 | "grid-cols-1",
8 | "md:grid-cols-1",
9 | "md:grid-cols-2",
10 | "md:grid-cols-3",
11 | "md:grid-cols-4",
12 | ],
13 | },
14 | theme: {},
15 | variants: {
16 | extend: {},
17 | },
18 | plugins: [require("@tailwindcss/aspect-ratio")],
19 | };
20 |
--------------------------------------------------------------------------------
/examples/webrtc_videoroom/assets/tsconfig.json:
--------------------------------------------------------------------------------
1 | {
2 | "compilerOptions": {
3 | "allowJs": true,
4 | "declaration": true,
5 | "declarationMap": true,
6 | "esModuleInterop": true,
7 | "forceConsistentCasingInFileNames": true,
8 | "module": "commonjs",
9 | "moduleResolution": "node",
10 | "outDir": "../priv/static",
11 | "strict": true,
12 | "target": "es2018"
13 | },
14 | "include": ["src/index.ts"],
15 | "exclude": ["/node_modules/**/*"]
16 | }
17 |
--------------------------------------------------------------------------------
/examples/webrtc_videoroom/config/config.exs:
--------------------------------------------------------------------------------
1 | import Config
2 |
3 | config :phoenix, :json_library, Jason
4 | config :opentelemetry, traces_exporter: :none
5 |
6 | config :esbuild,
7 | version: "0.12.15",
8 | default: [
9 | args:
10 | ~w(src/index.ts --bundle --target=es2016 --outfile=../priv/static/assets/js/app.js --external:/images/*),
11 | cd: Path.expand("../assets", __DIR__),
12 | env: %{"NODE_PATH" => Path.expand("../deps", __DIR__)}
13 | ]
14 |
15 | config :membrane_videoroom_demo, VideoRoomWeb.Endpoint, pubsub_server: VideoRoom.PubSub
16 |
17 | config :membrane_videoroom_demo, version: System.get_env("VERSION", "unknown")
18 |
19 | config :logger,
20 | compile_time_purge_matching: [
21 | [level_lower_than: :info],
22 | # Silence irrelevant warnings caused by resending handshake events
23 | [module: Membrane.SRTP.Encryptor, function: "handle_event/4", level_lower_than: :error],
24 | [module: MDNS.Client, level_lower_than: :error]
25 | ]
26 |
27 | config :logger, :console, metadata: [:room, :peer]
28 |
29 | import_config("#{config_env()}.exs")
30 |
--------------------------------------------------------------------------------
/examples/webrtc_videoroom/config/dev.exs:
--------------------------------------------------------------------------------
1 | import Config
2 |
3 | config :membrane_videoroom_demo, VideoRoomWeb.Endpoint,
4 | code_reloader: true,
5 | watchers: [
6 | esbuild:
7 | {Esbuild, :install_and_run,
8 | [
9 | :default,
10 | ~w(--sourcemap=inline --bundle --watch)
11 | ]},
12 | npx: [
13 | "tailwindcss",
14 | "--input=css/app.css",
15 | "--output=../priv/static/assets/css/app.css",
16 | "--postcss",
17 | "--watch",
18 | cd: Path.expand("../assets", __DIR__)
19 | ]
20 | ]
21 |
22 | config :membrane_videoroom_demo, VideoRoomWeb.Endpoint,
23 | live_reload: [
24 | patterns: [
25 | ~r"priv/static/.*(js|css|png|jpeg|jpg|gif|svg)$",
26 | ~r"priv/gettext/.*(po)$",
27 | ~r"lib/videoroom_web/(live|views)/.*(ex)$",
28 | ~r"lib/videoroom_web/templates/.*(eex)$"
29 | ]
30 | ]
31 |
32 | config :logger, level: :info
33 |
--------------------------------------------------------------------------------
/examples/webrtc_videoroom/config/prod.exs:
--------------------------------------------------------------------------------
1 | import Config
2 |
3 | config :logger, level: :info
4 |
5 | config :membrane_videoroom_demo, VideoRoomWeb.Endpoint, server: true
6 |
--------------------------------------------------------------------------------
/examples/webrtc_videoroom/config/runtime.exs:
--------------------------------------------------------------------------------
1 | import Config
2 |
3 | defmodule ConfigParser do
4 | def parse_external_ip(ip) do
5 | with {:ok, parsed_ip} <- ip |> to_charlist() |> :inet.parse_address() do
6 | parsed_ip
7 | else
8 | _ ->
9 | raise("""
10 | Bad EXTERNAL_IP format. Expected IPv4, got: \
11 | #{inspect(ip)}
12 | """)
13 | end
14 | end
15 |
16 | def parse_port_range(range) do
17 | with [str1, str2] <- String.split(range, "-"),
18 | from when from in 0..65_535 <- String.to_integer(str1),
19 | to when to in from..65_535 and from <= to <- String.to_integer(str2) do
20 | {from, to}
21 | else
22 | _else ->
23 | raise("""
24 | Bad PORT_RANGE enviroment variable value. Expected "from-to", where `from` and `to` \
25 | are numbers between 0 and 65535 and `from` is not bigger than `to`, got: \
26 | #{inspect(range)}
27 | """)
28 | end
29 | end
30 | end
31 |
32 | config :membrane_videoroom_demo,
33 | external_ip: System.get_env("EXTERNAL_IP", "127.0.0.1") |> ConfigParser.parse_external_ip(),
34 | port_range:
35 | System.get_env("PORT_RANGE", "50000-59999")
36 | |> ConfigParser.parse_port_range()
37 |
38 | config :membrane_videoroom_demo, VideoRoomWeb.Endpoint, [
39 | {:url, [host: "localhost"]},
40 | {:http, [otp_app: :membrane_videoroom_demo, port: System.get_env("SERVER_PORT") || 4000]}
41 | ]
42 |
--------------------------------------------------------------------------------
/examples/webrtc_videoroom/config/test.exs:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/fishjam-dev/membrane_rtc_engine/2b519efdcdecd737eeeaa74be8e50904f2c5d0c0/examples/webrtc_videoroom/config/test.exs
--------------------------------------------------------------------------------
/examples/webrtc_videoroom/lib/videoroom/application.ex:
--------------------------------------------------------------------------------
1 | defmodule VideoRoom.Application do
2 | @moduledoc false
3 | use Application
4 |
5 | @impl true
6 | def start(_type, _args) do
7 | config_common_dtls_key_cert()
8 |
9 | children = [
10 | VideoRoomWeb.Endpoint,
11 | {Phoenix.PubSub, name: VideoRoom.PubSub},
12 | {Registry, keys: :unique, name: Videoroom.Room.Registry}
13 | ]
14 |
15 | opts = [strategy: :one_for_one, name: __MODULE__]
16 | Supervisor.start_link(children, opts)
17 | end
18 |
19 | defp config_common_dtls_key_cert() do
20 | {:ok, pid} = ExDTLS.start_link(client_mode: false, dtls_srtp: true)
21 | {:ok, pkey} = ExDTLS.get_pkey(pid)
22 | {:ok, cert} = ExDTLS.get_cert(pid)
23 | :ok = ExDTLS.stop(pid)
24 | Application.put_env(:membrane_videoroom_demo, :dtls_pkey, pkey)
25 | Application.put_env(:membrane_videoroom_demo, :dtls_cert, cert)
26 | end
27 | end
28 |
--------------------------------------------------------------------------------
/examples/webrtc_videoroom/lib/videoroom_web.ex:
--------------------------------------------------------------------------------
1 | defmodule VideoRoomWeb do
2 | def controller do
3 | quote do
4 | use Phoenix.Controller, namespace: VideoRoomWeb
5 | import Plug.Conn
6 | alias VideoRoomWeb.Router.Helpers, as: Routes
7 | end
8 | end
9 |
10 | def view do
11 | quote do
12 | use Phoenix.View,
13 | root: "lib/videoroom_web/templates",
14 | pattern: "**/*",
15 | namespace: VideoRoomWeb
16 |
17 | import VideoRoomWeb.Router.Helpers
18 | use PhoenixInlineSvg.Helpers
19 |
20 | use Phoenix.HTML
21 | end
22 | end
23 |
24 | def router do
25 | quote do
26 | use Phoenix.Router
27 | import Plug.Conn
28 | end
29 | end
30 |
31 | def channel do
32 | quote do
33 | use Phoenix.Channel
34 | end
35 | end
36 |
37 | defmacro __using__(which) when is_atom(which) do
38 | apply(__MODULE__, which, [])
39 | end
40 | end
41 |
--------------------------------------------------------------------------------
/examples/webrtc_videoroom/lib/videoroom_web/controllers/page_controller.ex:
--------------------------------------------------------------------------------
1 | defmodule VideoRoomWeb.PageController do
2 | use VideoRoomWeb, :controller
3 |
4 | def index(conn, params) do
5 | render(conn, "index.html", room_id: Map.get(params, "room_id"))
6 | end
7 |
8 | def enter(conn, %{"room_name" => room_name, "display_name" => display_name}) do
9 | path =
10 | Routes.room_path(
11 | conn,
12 | :index,
13 | room_name,
14 | %{"display_name" => display_name}
15 | )
16 |
17 | redirect(conn, to: path)
18 | end
19 |
20 | def healthcheck(conn, _params) do
21 | conn
22 | |> send_resp(200, "")
23 | end
24 | end
25 |
--------------------------------------------------------------------------------
/examples/webrtc_videoroom/lib/videoroom_web/controllers/room_controller.ex:
--------------------------------------------------------------------------------
1 | defmodule VideoRoomWeb.RoomController do
2 | use VideoRoomWeb, :controller
3 |
4 | def index(conn, %{"room_id" => id, "display_name" => _name}) do
5 | render(conn, "index.html", room_id: id)
6 | end
7 |
8 | # display name is not present, redirect to home page with filled in room name
9 | def index(conn, %{"room_id" => id}) do
10 | redirect(conn, to: Routes.page_path(conn, :index, %{room_id: id}))
11 | end
12 | end
13 |
--------------------------------------------------------------------------------
/examples/webrtc_videoroom/lib/videoroom_web/endpoint.ex:
--------------------------------------------------------------------------------
1 | defmodule VideoRoomWeb.Endpoint do
2 | use Phoenix.Endpoint, otp_app: :membrane_videoroom_demo
3 |
4 | socket("/socket", VideoRoomWeb.UserSocket,
5 | websocket: true,
6 | longpoll: false
7 | )
8 |
9 | plug(Plug.Static,
10 | at: "/",
11 | from: :membrane_videoroom_demo,
12 | brotli: true,
13 | gzip: true,
14 | only: ~w(assets images html svg robots.txt favicon.ico)
15 | )
16 |
17 | if code_reloading? do
18 | socket("/phoenix/live_reload/socket", Phoenix.LiveReloader.Socket)
19 | plug(Phoenix.LiveReloader)
20 | plug(Phoenix.CodeReloader)
21 | end
22 |
23 | plug(Plug.Parsers,
24 | parsers: [:urlencoded, :multipart, :json],
25 | pass: ["*/*"],
26 | json_decoder: Phoenix.json_library()
27 | )
28 |
29 | plug(VideoRoomWeb.Router)
30 | end
31 |
--------------------------------------------------------------------------------
/examples/webrtc_videoroom/lib/videoroom_web/peer_channel.ex:
--------------------------------------------------------------------------------
1 | defmodule VideoRoomWeb.PeerChannel do
2 | use Phoenix.Channel
3 |
4 | require Logger
5 |
6 | @impl true
7 | def join("room:" <> room_id, _params, socket) do
8 | case :global.whereis_name(room_id) do
9 | :undefined -> Videoroom.Room.start(room_id, name: {:global, room_id})
10 | pid -> {:ok, pid}
11 | end
12 | |> case do
13 | {:ok, room_pid} ->
14 | do_join(socket, room_pid, room_id)
15 |
16 | {:error, {:already_started, room_pid}} ->
17 | do_join(socket, room_pid, room_id)
18 |
19 | {:error, reason} ->
20 | Logger.error("""
21 | Failed to start room.
22 | Room: #{inspect(room_id)}
23 | Reason: #{inspect(reason)}
24 | """)
25 |
26 | {:error, %{reason: "failed to start room"}}
27 | end
28 | end
29 |
30 | defp do_join(socket, room_pid, room_id) do
31 | peer_id = "#{UUID.uuid4()}"
32 | # TODO handle crash of room?
33 | Process.monitor(room_pid)
34 | send(room_pid, {:add_peer_channel, self(), peer_id})
35 |
36 | {:ok,
37 | Phoenix.Socket.assign(socket, %{room_id: room_id, room_pid: room_pid, peer_id: peer_id})}
38 | end
39 |
40 | @impl true
41 | def handle_in("mediaEvent", %{"data" => event}, socket) do
42 | send(socket.assigns.room_pid, {:media_event, socket.assigns.peer_id, event})
43 |
44 | {:noreply, socket}
45 | end
46 |
47 | @impl true
48 | def handle_info({:media_event, event}, socket) do
49 | push(socket, "mediaEvent", %{data: event})
50 |
51 | {:noreply, socket}
52 | end
53 |
54 | @impl true
55 | def handle_info(
56 | {:DOWN, _ref, :process, _pid, _reason},
57 | socket
58 | ) do
59 | {:stop, :normal, socket}
60 | end
61 | end
62 |
--------------------------------------------------------------------------------
/examples/webrtc_videoroom/lib/videoroom_web/router.ex:
--------------------------------------------------------------------------------
1 | defmodule VideoRoomWeb.Router do
2 | use VideoRoomWeb, :router
3 |
4 | pipeline :browser do
5 | plug(:accepts, ["html"])
6 | end
7 |
8 | scope "/", VideoRoomWeb do
9 | pipe_through(:browser)
10 |
11 | get("/", PageController, :index)
12 |
13 | post("/", PageController, :enter)
14 |
15 | get("/room/:room_id", RoomController, :index)
16 |
17 | get("/healthcheck", PageController, :healthcheck)
18 | end
19 | end
20 |
--------------------------------------------------------------------------------
/examples/webrtc_videoroom/lib/videoroom_web/templates/layout/app.html.heex:
--------------------------------------------------------------------------------
1 |
2 |
3 |
4 |
5 |
6 |
7 |
8 |
9 |
10 |
11 | Membrane WebRTC to HLS demo
3 |
6 | Waiting for HLS playlist to become playable...
7 |
8 |
9 |
20 |
21 |
22 |
23 |
24 |
--------------------------------------------------------------------------------
/examples/webrtc_videoroom/lib/videoroom_web/templates/page/index.html.heex:
--------------------------------------------------------------------------------
1 |
2 |
33 |
--------------------------------------------------------------------------------
/examples/webrtc_videoroom/lib/videoroom_web/templates/room/index.html.heex:
--------------------------------------------------------------------------------
1 |
3 | 
4 |
6 |
32 |
4 | Join room!
5 |
2 |
3 |
4 |
5 |
12 |
13 |
27 |
31 |
32 |
33 |
--------------------------------------------------------------------------------
/examples/webrtc_videoroom/lib/videoroom_web/user_socket.ex:
--------------------------------------------------------------------------------
1 | defmodule VideoRoomWeb.UserSocket do
2 | use Phoenix.Socket
3 |
4 | channel("room:*", VideoRoomWeb.PeerChannel)
5 |
6 | @impl true
7 | def connect(_params, socket, _connect_info) do
8 | {:ok, socket}
9 | end
10 |
11 | @impl true
12 | def id(_socket), do: nil
13 | end
14 |
--------------------------------------------------------------------------------
/examples/webrtc_videoroom/lib/videoroom_web/views/error_view.ex:
--------------------------------------------------------------------------------
1 | defmodule VideoRoomWeb.ErrorView do
2 | use VideoRoomWeb, :view
3 |
4 | # If you want to customize a particular status code
5 | # for a certain format, you may uncomment below.
6 | # def render("500.html", _assigns) do
7 | # "Internal Server Error"
8 | # end
9 |
10 | # By default, Phoenix returns the status message from
11 | # the template name. For example, "404.html" becomes
12 | # "Not Found".
13 | def template_not_found(template, _assigns) do
14 | Phoenix.Controller.status_message_from_template(template)
15 | end
16 | end
17 |
--------------------------------------------------------------------------------
/examples/webrtc_videoroom/lib/videoroom_web/views/layout_view.ex:
--------------------------------------------------------------------------------
1 | defmodule VideoRoomWeb.LayoutView do
2 | use VideoRoomWeb, :view
3 |
4 | def version() do
5 | Application.fetch_env!(:membrane_videoroom_demo, :version)
6 | end
7 | end
8 |
--------------------------------------------------------------------------------
/examples/webrtc_videoroom/lib/videoroom_web/views/page_view.ex:
--------------------------------------------------------------------------------
1 | defmodule VideoRoomWeb.PageView do
2 | use VideoRoomWeb, :view
3 | end
4 |
--------------------------------------------------------------------------------
/examples/webrtc_videoroom/lib/videoroom_web/views/room_view.ex:
--------------------------------------------------------------------------------
1 | defmodule VideoRoomWeb.RoomView do
2 | use VideoRoomWeb, :view
3 | end
4 |
--------------------------------------------------------------------------------
/examples/webrtc_videoroom/mix.exs:
--------------------------------------------------------------------------------
1 | defmodule VideoRoom.MixProject do
2 | use Mix.Project
3 |
4 | def project do
5 | [
6 | app: :membrane_videoroom_demo,
7 | version: "0.1.0",
8 | elixir: "~> 1.14",
9 | aliases: aliases(),
10 | start_permanent: Mix.env() == :prod,
11 | deps: deps()
12 | ]
13 | end
14 |
15 | def application do
16 | [
17 | mod: {VideoRoom.Application, []},
18 | extra_applications: [:logger]
19 | ]
20 | end
21 |
22 | defp deps do
23 | [
24 | {:plug_cowboy, "~> 2.0"},
25 | {:phoenix, "~> 1.6"},
26 | {:phoenix_html, "~> 3.0"},
27 | {:phoenix_live_view, "~> 0.16.0"},
28 | {:phoenix_live_reload, "~> 1.2"},
29 | {:poison, "~> 3.1"},
30 | {:jason, "~> 1.2"},
31 | {:phoenix_inline_svg, "~> 1.4"},
32 | {:telemetry, "~> 1.0.0", override: true},
33 | {:esbuild, "~> 0.4", runtime: Mix.env() == :dev},
34 |
35 | # rtc engine dependencies
36 | {:membrane_rtc_engine, "~> 0.22.0"},
37 | {:membrane_rtc_engine_webrtc, "~> 0.8.0"}
38 | ]
39 | end
40 |
41 | defp aliases do
42 | [
43 | setup: ["deps.get", "cmd --cd assets npm ci"],
44 | "assets.deploy": [
45 | "cmd --cd assets npm run deploy",
46 | "esbuild default --minify",
47 | "phx.digest"
48 | ]
49 | ]
50 | end
51 | end
52 |
--------------------------------------------------------------------------------
/examples/webrtc_videoroom/priv/static/favicon.ico:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/fishjam-dev/membrane_rtc_engine/2b519efdcdecd737eeeaa74be8e50904f2c5d0c0/examples/webrtc_videoroom/priv/static/favicon.ico
--------------------------------------------------------------------------------
/examples/webrtc_videoroom/priv/static/images/logo.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/fishjam-dev/membrane_rtc_engine/2b519efdcdecd737eeeaa74be8e50904f2c5d0c0/examples/webrtc_videoroom/priv/static/images/logo.png
--------------------------------------------------------------------------------
/examples/webrtc_videoroom/priv/static/robots.txt:
--------------------------------------------------------------------------------
1 | # See http://www.robotstxt.org/robotstxt.html for documentation on how to use the robots.txt file
2 | #
3 | # To ban all spiders from the entire site uncomment the next two lines:
4 | # User-agent: *
5 | # Disallow: /
6 |
--------------------------------------------------------------------------------
/file/.formatter.exs:
--------------------------------------------------------------------------------
1 | [
2 | inputs: [
3 | "{lib,test,config}/**/*.{ex,exs}",
4 | ".formatter.exs",
5 | "*.exs"
6 | ],
7 | import_deps: [:membrane_core]
8 | ]
9 |
--------------------------------------------------------------------------------
/file/.gitignore:
--------------------------------------------------------------------------------
1 | # The directory Mix will write compiled artifacts to.
2 | /_build/
3 |
4 | # If you run "mix test --cover", coverage assets end up here.
5 | /cover/
6 |
7 | # The directory Mix downloads your dependencies sources to.
8 | /deps/
9 |
10 | # Where third-party dependencies like ExDoc output generated docs.
11 | /doc/
12 |
13 | # Ignore .fetch files in case you like to edit your project deps locally.
14 | /.fetch
15 |
16 | # If the VM crashes, it generates a dump, let's ignore it too.
17 | erl_crash.dump
18 |
19 | # Also ignore archive artifacts (built via "mix archive.build").
20 | *.ez
21 |
22 | # Ignore package tarball (built via "mix hex.build").
23 | hls-*.tar
24 |
25 | # Temporary files, for example, from tests.
26 | /tmp/
27 |
--------------------------------------------------------------------------------
/file/CHANGELOG.md:
--------------------------------------------------------------------------------
1 | # Changelog
2 |
3 | ## 0.6.0-dev
4 |
5 | ## 0.5.0
6 | * Move to membrane_h26x_plugin. Update deps [#374](https://github.com/jellyfish-dev/membrane_rtc_engine/pull/374)
7 |
8 | ## 0.4.0
9 | * Change option `autoplay` to `playback_mode` in FileEndpoint [#357](https://github.com/jellyfish-dev/membrane_rtc_engine/pull/357)
10 | * Add `Membrane.RTC.Engine.Message.TrackRemoved` notification to File Source Endpoint [#356](https://github.com/jellyfish-dev/membrane_rtc_engine/pull/356)
11 |
12 | ## 0.3.0
13 | * Add autoend option [#340](https://github.com/jellyfish-dev/membrane_rtc_engine/pull/340)
14 | * Micro refactor File Endpoint [#354](https://github.com/jellyfish-dev/membrane_rtc_engine/pull/354)
15 |
16 | ## 0.2.0
17 | * Update to Membrane Core 1.0 [#331](https://github.com/jellyfish-dev/membrane_rtc_engine/pull/331)
18 | * Added track config [#329](https://github.com/jellyfish-dev/membrane_rtc_engine/pull/329)
19 | * Add demuxing for Ogg encapsulated OPUS [#333](https://github.com/jellyfish-dev/membrane_rtc_engine/pull/333)
20 | * Add autoplay feature [#336](https://github.com/jellyfish-dev/membrane_rtc_engine/pull/336)
21 |
22 | ## 0.1.0
23 | * Initial release [#323](https://github.com/jellyfish-dev/membrane_rtc_engine/pull/323)
24 |
--------------------------------------------------------------------------------
/file/README.md:
--------------------------------------------------------------------------------
1 | # Membrane RTC Engine File Endpoint
2 |
3 | [](https://hex.pm/packages/membrane_rtc_engine_file)
4 | [](https://hexdocs.pm/membrane_rtc_engine_file)
5 | [](https://codecov.io/gh/jellyfish-dev/membrane_rtc_engine)
6 | [](https://circleci.com/gh/jellyfish-dev/membrane_rtc_engine)
7 |
8 | File Endpoint for the [Membrane RTC Engine](https://github.com/jellyfish-dev/membrane_rtc_engine)
9 |
10 | ## Installation
11 |
12 | The package can be installed by adding `membrane_rtc_engine_file` to your list of dependencies in `mix.exs`:
13 |
14 | ```elixir
15 | def deps do
16 | [
17 | {:membrane_rtc_engine_file, "~> 0.5.0"}
18 | ]
19 | end
20 | ```
21 |
22 | ## Copyright and License
23 |
24 | Copyright 2023, [Software Mansion](https://swmansion.com/?utm_source=git&utm_medium=readme&utm_campaign=membrane_rtc_engine)
25 |
26 | [](https://swmansion.com/?utm_source=git&utm_medium=readme&utm_campaign=membrane_rtc_engine)
27 |
28 | Licensed under the [Apache License, Version 2.0](LICENSE)
29 |
--------------------------------------------------------------------------------
/file/lib/file/track_config.ex:
--------------------------------------------------------------------------------
1 | defmodule Membrane.RTC.Engine.Endpoint.File.TrackConfig do
2 | @moduledoc """
3 | Track Configuration, used to create track after
4 | initialization of File Endpoint.
5 | """
6 | alias ExSDP.Attribute.FMTP
7 | alias Membrane.RTC.Engine.Track
8 |
9 | @typedoc """
10 | The options passed to the `Membrane.RTC.Engine.Track.new/7`
11 | """
12 | @type t() :: %__MODULE__{
13 | type: :audio | :video,
14 | stream_id: String.t() | nil,
15 | encoding: Track.encoding(),
16 | clock_rate: Membrane.RTP.clock_rate_t(),
17 | fmtp: FMTP.t(),
18 | opts: Track.opts_t()
19 | }
20 |
21 | @enforce_keys [:type, :encoding, :clock_rate, :fmtp]
22 |
23 | defstruct @enforce_keys ++ [opts: [], stream_id: nil]
24 | end
25 |
--------------------------------------------------------------------------------
/file/test/fixtures/audio.ogg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/fishjam-dev/membrane_rtc_engine/2b519efdcdecd737eeeaa74be8e50904f2c5d0c0/file/test/fixtures/audio.ogg
--------------------------------------------------------------------------------
/file/test/fixtures/out_audio.opus:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/fishjam-dev/membrane_rtc_engine/2b519efdcdecd737eeeaa74be8e50904f2c5d0c0/file/test/fixtures/out_audio.opus
--------------------------------------------------------------------------------
/file/test/fixtures/video.h264:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/fishjam-dev/membrane_rtc_engine/2b519efdcdecd737eeeaa74be8e50904f2c5d0c0/file/test/fixtures/video.h264
--------------------------------------------------------------------------------
/file/test/test_helper.exs:
--------------------------------------------------------------------------------
1 | ExUnit.start(capture_log: true, exclude: [:skip])
2 |
--------------------------------------------------------------------------------
/hls/.formatter.exs:
--------------------------------------------------------------------------------
1 | [
2 | inputs: [
3 | "{lib,test,config}/**/*.{ex,exs}",
4 | ".formatter.exs",
5 | "*.exs"
6 | ],
7 | import_deps: [:membrane_core]
8 | ]
9 |
--------------------------------------------------------------------------------
/hls/.gitignore:
--------------------------------------------------------------------------------
1 | # The directory Mix will write compiled artifacts to.
2 | /_build/
3 |
4 | # If you run "mix test --cover", coverage assets end up here.
5 | /cover/
6 |
7 | # The directory Mix downloads your dependencies sources to.
8 | /deps/
9 |
10 | # Where third-party dependencies like ExDoc output generated docs.
11 | /doc/
12 |
13 | # Ignore .fetch files in case you like to edit your project deps locally.
14 | /.fetch
15 |
16 | # If the VM crashes, it generates a dump, let's ignore it too.
17 | erl_crash.dump
18 |
19 | # Also ignore archive artifacts (built via "mix archive.build").
20 | *.ez
21 |
22 | # Ignore package tarball (built via "mix hex.build").
23 | hls-*.tar
24 |
25 | # Temporary files, for example, from tests.
26 | /tmp/
27 |
--------------------------------------------------------------------------------
/hls/README.md:
--------------------------------------------------------------------------------
1 | # Membrane RTC Engine HLS Endpoint
2 |
3 | [](https://hex.pm/packages/membrane_rtc_engine_hls)
4 | [](https://hexdocs.pm/membrane_rtc_engine_hls)
5 | [](https://codecov.io/gh/jellyfish-dev/membrane_rtc_engine)
6 | [](https://circleci.com/gh/jellyfish-dev/membrane_rtc_engine)
7 |
8 | HLS Endpoint for the [Membrane RTC Engine](https://github.com/jellyfish-dev/membrane_rtc_engine)
9 |
10 | ## Installation
11 |
12 | The package can be installed by adding `membrane_rtc_engine_hls` to your list of dependencies in `mix.exs`:
13 |
14 | ```elixir
15 | def deps do
16 | [
17 | {:membrane_rtc_engine_hls, "~> 0.7.0"}
18 | ]
19 | end
20 | ```
21 |
22 | ## Copyright and License
23 |
24 | Copyright 2023, [Software Mansion](https://swmansion.com/?utm_source=git&utm_medium=readme&utm_campaign=membrane_rtc_engine)
25 |
26 | [](https://swmansion.com/?utm_source=git&utm_medium=readme&utm_campaign=membrane_rtc_engine)
27 |
28 | Licensed under the [Apache License, Version 2.0](LICENSE)
29 |
--------------------------------------------------------------------------------
/hls/lib/hls/config/audio_mixer_config.ex:
--------------------------------------------------------------------------------
1 | defmodule Membrane.RTC.Engine.Endpoint.HLS.AudioMixerConfig do
2 | @moduledoc """
3 | Module representing audio mixer configuration for the HLS endpoint.
4 | """
5 |
6 | alias Membrane.RawAudio
7 |
8 | @typedoc """
9 | * `stream_format` - defines audio mixer output stream_format.
10 | """
11 | @type t() :: %__MODULE__{
12 | stream_format: RawAudio.t()
13 | }
14 | defstruct stream_format: %RawAudio{
15 | channels: 1,
16 | sample_rate: 48_000,
17 | sample_format: :s16le
18 | }
19 | end
20 |
--------------------------------------------------------------------------------
/hls/lib/hls/config/compositor_config.ex:
--------------------------------------------------------------------------------
1 | defmodule Membrane.RTC.Engine.Endpoint.HLS.CompositorConfig do
2 | @moduledoc """
3 | Module representing compositor configuration for the HLS endpoint.
4 |
5 | Compositor is the element responsible for positioning input video streams
6 | into one video output.
7 | """
8 |
9 | @typedoc """
10 | * `stream_format` - output video specification in Membrane.RawVideo format
11 | * `layout_module` - Module implementing `Membrane.RTC.Engine.Endpoint.HLS.VideoLayoutMaker`
12 | behavior that should be used by the HLS endpoint.
13 | """
14 | @type t() :: %__MODULE__{
15 | stream_format: Membrane.RawVideo.t(),
16 | layout_module: module()
17 | }
18 | defstruct stream_format: %Membrane.RawVideo{
19 | width: 1280,
20 | height: 720,
21 | pixel_format: :I420,
22 | framerate: {24, 1},
23 | aligned: true
24 | },
25 | layout_module: Membrane.RTC.Engine.Endpoint.HLS.RecordingHandler
26 | end
27 |
--------------------------------------------------------------------------------
/hls/lib/hls/config/hls_config.ex:
--------------------------------------------------------------------------------
1 | defmodule Membrane.RTC.Engine.Endpoint.HLS.HLSConfig do
2 | @moduledoc """
3 | Module representing `Membrane.HTTPAdaptiveStream.SinkBin` configuration for the HLS endpoint.
4 | """
5 |
6 | alias Membrane.HTTPAdaptiveStream.{Manifest, Storage}
7 | alias Membrane.Time
8 |
9 | @typedoc """
10 | To read more about config options go to module `Membrane.HTTPAdaptiveStream.SinkBin` and read options descriptions.
11 | * `segment_duration` - The target duration of the regular segments.
12 | * `partial_segment_duration` - The target duration of the partial segments. If not set then the bin won't produce any partial segments.
13 | """
14 | @type t() :: %__MODULE__{
15 | manifest_name: String.t(),
16 | manifest_module: Manifest.t(),
17 | storage: (Path.t() -> Storage.config_t()),
18 | target_window_duration: pos_integer | :infinity,
19 | persist?: boolean,
20 | mode: :live | :vod,
21 | hls_mode: :muxed_av | :separate_av,
22 | header_naming_fun: (Manifest.Track.t(), counter :: non_neg_integer() -> String.t()),
23 | segment_naming_fun: (Manifest.Track.t() -> String.t()),
24 | segment_duration: Membrane.Time.t(),
25 | partial_segment_duration: Membrane.Time.t() | nil,
26 | cleanup_after: Membrane.Time.t() | nil
27 | }
28 |
29 | defstruct manifest_name: "index",
30 | manifest_module: Membrane.HTTPAdaptiveStream.HLS,
31 | storage: &__MODULE__.default_storage/1,
32 | target_window_duration: Membrane.Time.seconds(40),
33 | persist?: false,
34 | mode: :live,
35 | hls_mode: :separate_av,
36 | header_naming_fun: &Manifest.Track.default_header_naming_fun/2,
37 | segment_naming_fun: &Manifest.Track.default_segment_naming_fun/1,
38 | segment_duration: Time.seconds(5),
39 | partial_segment_duration: nil,
40 | cleanup_after: nil
41 |
42 | @spec default_storage(String.t()) :: any
43 | def default_storage(directory),
44 | do: %Membrane.HTTPAdaptiveStream.Storages.FileStorage{directory: directory}
45 | end
46 |
--------------------------------------------------------------------------------
/hls/lib/hls/config/mixer_config.ex:
--------------------------------------------------------------------------------
1 | if Enum.all?([Membrane.RawAudio, Membrane.RawVideo], &Code.ensure_loaded?/1) do
2 | defmodule Membrane.RTC.Engine.Endpoint.HLS.MixerConfig do
3 | @moduledoc """
4 | Module representing mixer configuration for the HLS endpoint.
5 | """
6 |
7 | alias Membrane.RTC.Engine.Endpoint.HLS.{AudioMixerConfig, CompositorConfig}
8 |
9 | @typedoc """
10 | * `video` - video compositor configuration.
11 | * `audio` - audio mixer configuration.
12 | """
13 | @type t() :: %__MODULE__{
14 | video: CompositorConfig.t(),
15 | audio: AudioMixerConfig.t()
16 | }
17 | defstruct video: %CompositorConfig{},
18 | audio: %AudioMixerConfig{}
19 | end
20 | end
21 |
--------------------------------------------------------------------------------
/integration_test/.formatter.exs:
--------------------------------------------------------------------------------
1 | # Used by "mix format"
2 | [
3 | inputs: ["{mix,.formatter}.exs", "{config,lib,test}/**/*.{ex,exs}"]
4 | ]
5 |
--------------------------------------------------------------------------------
/integration_test/.gitignore:
--------------------------------------------------------------------------------
1 | asterisk/recordings/*
2 |
3 | asterisk/config/sip.conf
4 |
5 | asterisk/config/sip.tmp.conf
6 |
7 |
8 | # The directory Mix will write compiled artifacts to.
9 | /_build/
10 |
11 | # If you run "mix test --cover", coverage assets end up here.
12 | /cover/
13 |
14 | # The directory Mix downloads your dependencies sources to.
15 | /deps/
16 |
17 | # Where third-party dependencies like ExDoc output generated docs.
18 | /doc/
19 |
20 | # Ignore .fetch files in case you like to edit your project deps locally.
21 | /.fetch
22 |
23 | # If the VM crashes, it generates a dump, let's ignore it too.
24 | erl_crash.dump
25 |
26 | # Also ignore archive artifacts (built via "mix archive.build").
27 | *.ez
28 |
29 | # Ignore package tarball (built via "mix hex.build").
30 | integration_test-*.tar
31 |
32 | # Temporary files, for example, from tests.
33 | /tmp/
34 |
35 | # Env file
36 | .env
37 |
--------------------------------------------------------------------------------
/integration_test/README.md:
--------------------------------------------------------------------------------
1 | # Integration tests
2 |
3 | Directory containing integration tests utilising multiple different Endpoints
4 | of the `membrane_rtc_engine`.
5 |
6 | To run, execute `mix test`.
7 |
--------------------------------------------------------------------------------
/integration_test/asterisk/config/extensions.conf:
--------------------------------------------------------------------------------
1 | [general]
2 |
3 | [globals]
4 |
5 | [outgoing_calls]
6 | exten => 1230,1,Answer()
7 | same => n,Monitor(alaw,my-file1230,i)
8 | same => n,Playback(audio0_short)
9 | same => n,Hangup()
10 | exten => 1231,1,Answer()
11 | same => n,Monitor(alaw,my-file1231,i)
12 | same => n,Playback(audio0_short)
13 | same => n,Hangup()
14 | exten => 1232,1,Answer()
15 | same => n,Monitor(alaw,my-file1232,i)
16 | same => n,Playback(audio0_short)
17 | same => n,Hangup()
18 | exten => 1233,1,Answer()
19 | same => n,Monitor(alaw,my-file1233,i)
20 | same => n,Playback(audio0_short)
21 | same => n,Hangup()
22 | exten => 1234,1,Answer()
23 | same => n,Monitor(alaw,my-file1234,i)
24 | same => n,Playback(audio0_short)
25 | same => n,Hangup()
26 |
27 |
28 | exten => 1240,1,Answer()
29 | same => n,Monitor(alaw,my-file1240,i)
30 | same => n,Playback(audio1_short)
31 | same => n,Hangup()
32 | exten => 1241,1,Answer()
33 | same => n,Monitor(alaw,my-file1241,i)
34 | same => n,Playback(audio1_short)
35 | same => n,Hangup()
36 |
37 | exten => 1250,1,Wait(5)
38 | same => n,Hangup()
39 |
40 | exten => 1260,1,Transfer(SIP/1234)
41 |
42 | exten => 1270,1,Answer()
43 | same => n,Monitor(alaw,my-file1270,i)
44 | same => n,Playback(audio1_long)
45 | same => n,Hangup()
46 |
47 |
48 |
49 |
50 |
--------------------------------------------------------------------------------
/integration_test/asterisk/config/modules.conf:
--------------------------------------------------------------------------------
1 | [modules]
2 | autoload=yes
--------------------------------------------------------------------------------
/integration_test/asterisk/config/rtp.conf:
--------------------------------------------------------------------------------
1 | [general]
2 | rtpstart=10000
3 | rtpend=10100
--------------------------------------------------------------------------------
/integration_test/asterisk/config/sip.conf.template:
--------------------------------------------------------------------------------
1 | [general]
2 | # context=unauthenticated
3 | context=default
4 | allowoverlap=no
5 | bindport=5061
6 | bindaddr=0.0.0.0
7 | localnet=$LOCAL_NET # using placeholder here
8 | externip=$EXTERNAL_IP # using placeholder here
9 | allowexternaldomains=yes
10 | srvlookup=yes
11 | transport=udp
12 |
13 | [mymediaserver0]
14 | type=friend
15 | host=dynamic
16 | username=mymediaserver0
17 | secret=yourpassword
18 | context=outgoing_calls
19 | disallow=all
20 | allow=alaw ; allow ulaw codec
21 |
22 | [mymediaserver1]
23 | type=friend
24 | host=dynamic
25 | username=mymediaserver1
26 | secret=yourpassword
27 | context=outgoing_calls
28 | disallow=all
29 | allow=alaw ; allow ulaw codec
--------------------------------------------------------------------------------
/integration_test/asterisk/config/startup.sh:
--------------------------------------------------------------------------------
1 | #!/bin/bash
2 |
3 |
4 | rm /etc/asterisk/sip.conf
5 |
6 | # # # Substitute environment variables
7 | sed 's#\$LOCAL_NET#'"$LOCAL_NET"'#g' /etc/asterisk/sip.conf.template > /etc/asterisk/sip.tmp.conf
8 | sed 's#\$EXTERNAL_IP#'"$EXTERNAL_IP"'#g' /etc/asterisk/sip.tmp.conf > /etc/asterisk/sip.conf
9 |
10 |
11 | # Start Asterisk
12 | exec asterisk -fvvvvvvvv
--------------------------------------------------------------------------------
/integration_test/asterisk/sounds/audio0.aac:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/fishjam-dev/membrane_rtc_engine/2b519efdcdecd737eeeaa74be8e50904f2c5d0c0/integration_test/asterisk/sounds/audio0.aac
--------------------------------------------------------------------------------
/integration_test/asterisk/sounds/audio0_short.alaw:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/fishjam-dev/membrane_rtc_engine/2b519efdcdecd737eeeaa74be8e50904f2c5d0c0/integration_test/asterisk/sounds/audio0_short.alaw
--------------------------------------------------------------------------------
/integration_test/asterisk/sounds/audio1.aac:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/fishjam-dev/membrane_rtc_engine/2b519efdcdecd737eeeaa74be8e50904f2c5d0c0/integration_test/asterisk/sounds/audio1.aac
--------------------------------------------------------------------------------
/integration_test/asterisk/sounds/audio1_long.alaw:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/fishjam-dev/membrane_rtc_engine/2b519efdcdecd737eeeaa74be8e50904f2c5d0c0/integration_test/asterisk/sounds/audio1_long.alaw
--------------------------------------------------------------------------------
/integration_test/asterisk/sounds/audio1_short.alaw:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/fishjam-dev/membrane_rtc_engine/2b519efdcdecd737eeeaa74be8e50904f2c5d0c0/integration_test/asterisk/sounds/audio1_short.alaw
--------------------------------------------------------------------------------
/integration_test/docker-compose-test.yaml:
--------------------------------------------------------------------------------
1 | version: '3.1'
2 |
3 | services:
4 | test:
5 | image: membraneframeworklabs/docker_membrane
6 | command: sh -c "cd /app/integration_test && mix deps.get && mix coveralls.json --warnings-as-errors --exclude gpu "
7 | volumes:
8 | - ..:/app
9 | - /app/integration_test/deps
10 | - /app/*/_build
11 | - /app/*/deps
12 | environment:
13 | - EXTERNAL_IP=$EXTERNAL_IP
14 | - SIP_DOMAIN=asterisk:5061
15 | ports:
16 | - "5060:5060/udp"
17 | - "21000-21100:21000-21100/udp"
18 | - "500:500/udp"
19 | depends_on:
20 | - asterisk
21 |
22 | asterisk:
23 | extends:
24 | file: docker-compose.yaml
25 | service: asterisk
26 | ports:
27 | - 5061:5061/udp
28 | - 5061:5061/tcp
29 | - "10000-10100:10000-10100/udp"
30 | environment:
31 | - EXTERNAL_IP=$EXTERNAL_IP
32 | - LOCAL_NET=$EXTERNAL_IP/16
33 | entrypoint: [ "/etc/asterisk/startup.sh" ]
34 |
--------------------------------------------------------------------------------
/integration_test/docker-compose.yaml:
--------------------------------------------------------------------------------
1 | version: '3.1'
2 |
3 | services:
4 | asterisk:
5 | image: dougbtv/asterisk
6 | volumes:
7 | - ./asterisk/config:/etc/asterisk
8 | - ./asterisk/sounds:/var/lib/asterisk/sounds
9 | - ./asterisk/recordings:/var/spool/asterisk/monitor
10 | ports:
11 | - 5061:5061/udp
12 | - 5061:5061/tcp
13 | - "10000-10100:10000-10100/udp"
14 | environment:
15 | # add your environment variables here
16 | - EXTERNAL_IP=$EXTERNAL_IP
17 | - LOCAL_NET=${LOCAL_NET:-$EXTERNAL_IP/24}
18 | container_name: my-asterisk
19 | entrypoint: [ "/etc/asterisk/startup.sh" ] # replace "command" with "entrypoint"
20 |
--------------------------------------------------------------------------------
/integration_test/test/fixtures/audio.aac:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/fishjam-dev/membrane_rtc_engine/2b519efdcdecd737eeeaa74be8e50904f2c5d0c0/integration_test/test/fixtures/audio.aac
--------------------------------------------------------------------------------
/integration_test/test/fixtures/audio0.aac:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/fishjam-dev/membrane_rtc_engine/2b519efdcdecd737eeeaa74be8e50904f2c5d0c0/integration_test/test/fixtures/audio0.aac
--------------------------------------------------------------------------------
/integration_test/test/fixtures/audio0_short.aac:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/fishjam-dev/membrane_rtc_engine/2b519efdcdecd737eeeaa74be8e50904f2c5d0c0/integration_test/test/fixtures/audio0_short.aac
--------------------------------------------------------------------------------
/integration_test/test/fixtures/one_second.h264:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/fishjam-dev/membrane_rtc_engine/2b519efdcdecd737eeeaa74be8e50904f2c5d0c0/integration_test/test/fixtures/one_second.h264
--------------------------------------------------------------------------------
/integration_test/test/fixtures/recorded_video.h264:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/fishjam-dev/membrane_rtc_engine/2b519efdcdecd737eeeaa74be8e50904f2c5d0c0/integration_test/test/fixtures/recorded_video.h264
--------------------------------------------------------------------------------
/integration_test/test/fixtures/two_seconds.h264:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/fishjam-dev/membrane_rtc_engine/2b519efdcdecd737eeeaa74be8e50904f2c5d0c0/integration_test/test/fixtures/two_seconds.h264
--------------------------------------------------------------------------------
/integration_test/test/fixtures/variable_framerate.h264:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/fishjam-dev/membrane_rtc_engine/2b519efdcdecd737eeeaa74be8e50904f2c5d0c0/integration_test/test/fixtures/variable_framerate.h264
--------------------------------------------------------------------------------
/integration_test/test/fixtures/video.h264:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/fishjam-dev/membrane_rtc_engine/2b519efdcdecd737eeeaa74be8e50904f2c5d0c0/integration_test/test/fixtures/video.h264
--------------------------------------------------------------------------------
/integration_test/test/fixtures/video_baseline.h264:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/fishjam-dev/membrane_rtc_engine/2b519efdcdecd737eeeaa74be8e50904f2c5d0c0/integration_test/test/fixtures/video_baseline.h264
--------------------------------------------------------------------------------
/integration_test/test/support/file_endpont_generator.ex:
--------------------------------------------------------------------------------
1 | defmodule FileEndpointGenerator do
2 | @moduledoc false
3 |
4 | import Membrane.ChildrenSpec
5 |
6 | alias ExSDP.Attribute.FMTP
7 | alias Membrane.RTC.Engine.Endpoint.File, as: FileEndpoint
8 |
9 | def create_video_file_endpoint(rtc_engine, video_file_path, opts \\ []) do
10 | video_track_config = %FileEndpoint.TrackConfig{
11 | type: :video,
12 | stream_id: Keyword.get(opts, :stream_id),
13 | encoding: :H264,
14 | clock_rate: 90_000,
15 | fmtp: %FMTP{
16 | pt: 96
17 | },
18 | opts: [
19 | metadata: %{"mainPresenter" => true, "isScreenSharing" => false},
20 | framerate: {60, 1}
21 | ]
22 | }
23 |
24 | %FileEndpoint{
25 | rtc_engine: rtc_engine,
26 | file_path: video_file_path,
27 | track_config: video_track_config,
28 | payload_type: 96,
29 | playback_mode: Keyword.get(opts, :playback_mode, :wait_for_first_subscriber),
30 | autoend: Keyword.get(opts, :autoend, true)
31 | }
32 | end
33 |
34 | def create_audio_file_endpoint(rtc_engine, audio_file_path, opts \\ []) do
35 | audio_track_config = %FileEndpoint.TrackConfig{
36 | type: :audio,
37 | stream_id: Keyword.get(opts, :stream_id),
38 | encoding: :OPUS,
39 | clock_rate: 48_000,
40 | fmtp: %FMTP{
41 | pt: 108
42 | }
43 | }
44 |
45 | %FileEndpoint{
46 | rtc_engine: rtc_engine,
47 | file_path: audio_file_path,
48 | track_config: audio_track_config,
49 | payload_type: 108,
50 | after_source_transformation: &transform_aac_to_opus/1,
51 | playback_mode: Keyword.get(opts, :playback_mode, :wait_for_first_subscriber),
52 | autoend: Keyword.get(opts, :autoend, true)
53 | }
54 | end
55 |
56 | defp transform_aac_to_opus(link_builder) do
57 | link_builder
58 | |> child(:decoder, Membrane.AAC.FDK.Decoder)
59 | |> child(:encoder, %Membrane.Opus.Encoder{
60 | input_stream_format: %Membrane.RawAudio{
61 | channels: 1,
62 | sample_rate: 48_000,
63 | sample_format: :s16le
64 | }
65 | })
66 | end
67 | end
68 |
--------------------------------------------------------------------------------
/integration_test/test/support/precise_realtimer.ex:
--------------------------------------------------------------------------------
1 | defmodule Membrane.RTC.Engine.PreciseRealtimer do
2 | @moduledoc false
3 |
4 | use Membrane.Filter
5 |
6 | def_input_pad(:input, accepted_format: _any)
7 | def_output_pad(:output, accepted_format: _any)
8 |
9 | def_options(
10 | timer_resolution: [
11 | spec: Membrane.Time.t()
12 | ]
13 | )
14 |
15 | @impl true
16 | def handle_init(_ctx, opts) do
17 | {[],
18 | %{
19 | tick_idx: 0,
20 | resolution: opts.timer_resolution,
21 | queue: Qex.new()
22 | }}
23 | end
24 |
25 | @impl true
26 | def handle_playing(_ctx, state) do
27 | {[start_timer: {:timer, state.resolution}], state}
28 | end
29 |
30 | @impl true
31 | def handle_buffer(:input, buffer, _ctx, state) do
32 | {[], %{state | queue: Qex.push(state.queue, {:buffer, {:output, buffer}})}}
33 | end
34 |
35 | @impl true
36 | def handle_end_of_stream(:input, _ctx, state) do
37 | {[], %{state | queue: Qex.push(state.queue, {:end_of_stream, :output})}}
38 | end
39 |
40 | @impl true
41 | def handle_tick(:timer, _ctx, %{tick_idx: tick_idx} = state) do
42 | current_ts = tick_idx * state.resolution
43 | state = %{state | tick_idx: tick_idx + 1}
44 |
45 | if Enum.empty?(state.queue) do
46 | {[], state}
47 | else
48 | {actions, buffered} =
49 | Enum.split_while(state.queue, fn
50 | {:buffer, {:output, buffer}} ->
51 | Membrane.Buffer.get_dts_or_pts(buffer) <= current_ts
52 |
53 | _other ->
54 | true
55 | end)
56 |
57 | {actions, %{state | queue: Qex.new(buffered)}}
58 | end
59 | end
60 | end
61 |
--------------------------------------------------------------------------------
/integration_test/test/test_helper.exs:
--------------------------------------------------------------------------------
1 | Mox.defmock(ExAws.Request.HttpMock, for: ExAws.Request.HttpClient)
2 | Application.put_env(:ex_aws, :http_client, ExAws.Request.HttpMock)
3 |
4 | ExUnit.start(capture_log: true, exclude: [:skip])
5 |
--------------------------------------------------------------------------------
/recording/.formatter.exs:
--------------------------------------------------------------------------------
1 | [
2 | inputs: [
3 | "{lib,test,config}/**/*.{ex,exs}",
4 | ".formatter.exs",
5 | "*.exs"
6 | ],
7 | import_deps: [:membrane_core]
8 | ]
9 |
--------------------------------------------------------------------------------
/recording/.gitignore:
--------------------------------------------------------------------------------
1 | # The directory Mix will write compiled artifacts to.
2 | /_build/
3 |
4 | # If you run "mix test --cover", coverage assets end up here.
5 | /cover/
6 |
7 | # The directory Mix downloads your dependencies sources to.
8 | /deps/
9 |
10 | # Where third-party dependencies like ExDoc output generated docs.
11 | /doc/
12 |
13 | # Ignore .fetch files in case you like to edit your project deps locally.
14 | /.fetch
15 |
16 | # If the VM crashes, it generates a dump, let's ignore it too.
17 | erl_crash.dump
18 |
19 | # Also ignore archive artifacts (built via "mix archive.build").
20 | *.ez
21 |
22 | # Ignore package tarball (built via "mix hex.build").
23 | hls-*.tar
24 |
25 | # Temporary files, for example, from tests.
26 | /tmp/
27 |
--------------------------------------------------------------------------------
/recording/README.md:
--------------------------------------------------------------------------------
1 | # Membrane RTC Engine Recording Endpoint
2 |
3 | [](https://hex.pm/packages/membrane_rtc_engine_recording)
4 | [](https://hexdocs.pm/membrane_rtc_engine_recording)
5 | [](https://codecov.io/gh/jellyfish-dev/membrane_rtc_engine)
6 | [](https://circleci.com/gh/jellyfish-dev/membrane_rtc_engine)
7 |
8 | Recording Endpoint for the [Membrane RTC Engine](https://github.com/jellyfish-dev/membrane_rtc_engine)
9 |
10 | ## Installation
11 |
12 | The package can be installed by adding `membrane_rtc_engine_recording` to your list of dependencies in `mix.exs`:
13 |
14 | ```elixir
15 | def deps do
16 | [
17 | {:membrane_rtc_engine_recording, "~> 0.1.0"}
18 | ]
19 | end
20 | ```
21 |
22 | ## Copyright and License
23 |
24 | Copyright 2024, [Software Mansion](https://swmansion.com/?utm_source=git&utm_medium=readme&utm_campaign=membrane_rtc_engine)
25 |
26 | [](https://swmansion.com/?utm_source=git&utm_medium=readme&utm_campaign=membrane_rtc_engine)
27 |
28 | Licensed under the [Apache License, Version 2.0](LICENSE)
29 |
--------------------------------------------------------------------------------
/recording/lib/application.ex:
--------------------------------------------------------------------------------
1 | defmodule Membrane.RTC.Engine.Endpoint.Recording.Application do
2 | @moduledoc false
3 | use Application
4 |
5 | alias Membrane.RTC.Engine.Endpoint.Recording
6 |
7 | @impl true
8 | def start(_start_type, _start_args) do
9 | children = [
10 | {Task.Supervisor, name: Recording.TaskSupervisor, strategy: :one_for_one}
11 | ]
12 |
13 | Supervisor.start_link(children, strategy: :one_for_one)
14 | end
15 | end
16 |
--------------------------------------------------------------------------------
/recording/lib/guard.ex:
--------------------------------------------------------------------------------
1 | defmodule Membrane.RTC.Engine.Endpoint.Recording.Guard do
2 | @moduledoc false
3 |
4 | alias Membrane.RTC.Engine.Endpoint.Recording.Storage
5 |
6 | @type storage :: {module(), opts :: any()}
7 |
8 | @spec close_recording([storage()], String.t()) :: [storage()]
9 | def close_recording(stores, recording_id) do
10 | case List.keytake(stores, Storage.File, 0) do
11 | nil ->
12 | stores
13 |
14 | {file_store, other_stores} ->
15 | valid_stores = close_stores(file_store, other_stores, recording_id)
16 | [file_store | valid_stores]
17 | end
18 | end
19 |
20 | defp close_stores({file_storage, file_opts}, stores, recording_id) do
21 | files = file_storage.list_files(file_opts)
22 |
23 | if map_size(files) > 0 do
24 | Enum.filter(stores, fn {module, opts} ->
25 | module.on_close(files, recording_id, opts) == :ok
26 | end)
27 | else
28 | stores
29 | end
30 | end
31 | end
32 |
--------------------------------------------------------------------------------
/recording/lib/metrics.ex:
--------------------------------------------------------------------------------
1 | defmodule Membrane.RTC.Engine.Endpoint.Recording.Metrics do
2 | @moduledoc """
3 | Defines list of metrics, that Reporter instance can aggregate by listening on events emitted in RTC Engine.
4 | Suggested Reporter implementation is `Membrane.TelemetryMetrics.Reporter` from
5 | [`membrane_telemetry_metrics`](https://github.com/membraneframework/membrane_telemetry_metrics).
6 | You can see usage example in [`jellyfish`](https://github.com/jellyfish-dev/jellyfish).
7 |
8 | See also `Metrics` guide for more details and example report that you can obtain with
9 | `Membrane.TelemetryMetrics.Reporter`.
10 | """
11 |
12 | require Membrane.TelemetryMetrics
13 |
14 | @upload_event [Membrane.RTC.Engine.Endpoint.Recording, :S3]
15 |
16 | @spec metrics() :: [Telemetry.Metrics.t()]
17 | def metrics() do
18 | [
19 | Telemetry.Metrics.counter(
20 | "recording.s3.upload.completed",
21 | event_name: @upload_event ++ [:completed]
22 | ),
23 | Telemetry.Metrics.counter(
24 | "recording.s3.upload.aborted",
25 | event_name: @upload_event ++ [:aborted]
26 | )
27 | ]
28 | end
29 |
30 | @doc false
31 | @spec emit_completed_upload_event(Membrane.TelemetryMetrics.label()) :: :ok
32 | def emit_completed_upload_event(telemetry_label) do
33 | Membrane.TelemetryMetrics.execute(
34 | @upload_event ++ [:completed],
35 | %{},
36 | %{},
37 | telemetry_label
38 | )
39 |
40 | :ok
41 | end
42 |
43 | @doc false
44 | @spec emit_aborted_upload_event(Membrane.TelemetryMetrics.label()) :: :ok
45 | def emit_aborted_upload_event(telemetry_label) do
46 | Membrane.TelemetryMetrics.execute(
47 | @upload_event ++ [:aborted],
48 | %{},
49 | %{},
50 | telemetry_label
51 | )
52 |
53 | :ok
54 | end
55 | end
56 |
--------------------------------------------------------------------------------
/recording/lib/storage.ex:
--------------------------------------------------------------------------------
1 | defmodule Membrane.RTC.Engine.Endpoint.Recording.Storage do
2 | @moduledoc """
3 | An interface for Recording endpoint storage configuration.
4 | """
5 |
6 | alias Membrane.RTC.Engine.Track
7 |
8 | @type recording_config :: %{
9 | track: Track.t(),
10 | recording_id: String.t(),
11 | filename: String.t()
12 | }
13 |
14 | @type object_config :: %{
15 | object: binary(),
16 | recording_id: String.t(),
17 | filename: String.t()
18 | }
19 |
20 | @type files() :: %{(filename :: String.t()) => {Path.t(), size :: pos_integer()}}
21 |
22 | @doc """
23 | Callback invoked when a new track is added to `RecordingEndpoint`.
24 | It should return a struct that will be further added as a child to the spec.
25 | """
26 | @callback get_sink(recording_config :: recording_config(), opts :: any()) :: struct()
27 |
28 | @doc """
29 | Callback invoked once all tracks have been processed by `RecordingEndpoint`.
30 | The returned object can be of two types:
31 |
32 | * `report` - a file containing all the necessary information for deserializing the processed tracks.
33 | * `recording` - a file that captures a complete track recording.
34 | """
35 | @callback save_object(object_config :: object_config(), opts :: any()) ::
36 | :ok | {:error, String.t()}
37 | @doc """
38 | This callback gets invoked exclusively when `FileStorage` is in use and a recording session is being closed.
39 | Within this callback, you can perform the following actions:
40 |
41 | * Clean up all resources
42 | * Attempt to rectify any discrepancies between the saved objects and local files
43 |
44 | If error is returned report won't be sent to the storage.
45 | """
46 | @callback on_close(file_config :: files(), recording_id :: String.t(), opts :: any()) ::
47 | :ok | :error
48 | end
49 |
--------------------------------------------------------------------------------
/recording/lib/storage/file.ex:
--------------------------------------------------------------------------------
1 | defmodule Membrane.RTC.Engine.Endpoint.Recording.Storage.File do
2 | @moduledoc """
3 | `Membrane.RTC.Engine.Endpoint.Recording.Storage` implementation that saves the stream to files locally.
4 | """
5 | @behaviour Membrane.RTC.Engine.Endpoint.Recording.Storage
6 |
7 | @impl true
8 | def get_sink(config, %{output_dir: output_dir}) do
9 | location = Path.join(output_dir, config.filename)
10 | File.touch!(location)
11 | %Membrane.File.Sink{location: location}
12 | end
13 |
14 | @impl true
15 | def save_object(config, %{output_dir: output_dir}) do
16 | location = Path.join(output_dir, config.filename)
17 |
18 | with :ok <- File.touch(location) do
19 | File.write(location, config.object)
20 | end
21 | end
22 |
23 | @impl true
24 | def on_close(_file_config, _recording_id, _opts), do: :ok
25 |
26 | @spec list_files(%{output_dir: Path.t()}) :: %{
27 | String.t() => {path :: Path.t(), size :: pos_integer()}
28 | }
29 | def list_files(%{output_dir: output_dir}) do
30 | output_dir
31 | |> File.ls!()
32 | |> Map.new(fn file ->
33 | path = Path.join(output_dir, file)
34 | %{size: size} = File.stat!(path)
35 | {file, {path, size}}
36 | end)
37 | end
38 | end
39 |
--------------------------------------------------------------------------------
/recording/test/fixtures/big.txt:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/fishjam-dev/membrane_rtc_engine/2b519efdcdecd737eeeaa74be8e50904f2c5d0c0/recording/test/fixtures/big.txt
--------------------------------------------------------------------------------
/recording/test/fixtures/empty.txt:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/fishjam-dev/membrane_rtc_engine/2b519efdcdecd737eeeaa74be8e50904f2c5d0c0/recording/test/fixtures/empty.txt
--------------------------------------------------------------------------------
/recording/test/fixtures/small.txt:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/fishjam-dev/membrane_rtc_engine/2b519efdcdecd737eeeaa74be8e50904f2c5d0c0/recording/test/fixtures/small.txt
--------------------------------------------------------------------------------
/recording/test/storage/file_test.exs:
--------------------------------------------------------------------------------
1 | defmodule Membrane.RTC.Engine.Endpoint.Recording.Storage.FileTest do
2 | use ExUnit.Case, async: true
3 |
4 | import MockTrack
5 |
6 | alias Membrane.RTC.Engine.Endpoint.Recording.{Reporter, Storage}
7 |
8 | @tag :tmp_dir
9 | test "create file sink", %{tmp_dir: output_dir} do
10 | filename = "track_1"
11 |
12 | config = %{
13 | track: %{},
14 | recording_id: "recording_1",
15 | filename: filename
16 | }
17 |
18 | location = Path.join(output_dir, filename)
19 |
20 | assert %Membrane.File.Sink{location: ^location} =
21 | Storage.File.get_sink(config, %{output_dir: output_dir})
22 |
23 | assert output_dir |> Path.join(config.filename) |> File.exists?()
24 | end
25 |
26 | @tag :tmp_dir
27 | test "save report", %{tmp_dir: output_dir} do
28 | recording_id = UUID.uuid4()
29 | {:ok, reporter} = Reporter.start(recording_id)
30 |
31 | filename = "track_1.msr"
32 | track = create_track(:video)
33 | offset = 0
34 |
35 | :ok = Reporter.add_track(reporter, track, filename, offset)
36 |
37 | report_json =
38 | reporter
39 | |> Reporter.get_report()
40 | |> Jason.encode!()
41 |
42 | config = %{
43 | object: report_json,
44 | recording_id: "recording_1",
45 | filename: "report.json"
46 | }
47 |
48 | :ok = Storage.File.save_object(config, %{output_dir: output_dir})
49 |
50 | assert output_dir |> Path.join("report.json") |> File.exists?()
51 |
52 | saved_report = output_dir |> Path.join("report.json") |> File.read!()
53 |
54 | assert saved_report == report_json
55 |
56 | :ok = Reporter.stop(reporter)
57 | end
58 | end
59 |
--------------------------------------------------------------------------------
/recording/test/support/mock_track.ex:
--------------------------------------------------------------------------------
1 | defmodule MockTrack do
2 | @moduledoc false
3 |
4 | alias ExSDP.Attribute.FMTP
5 | alias Membrane.RTC.Engine.Track
6 | alias Membrane.RTCP.SenderReportPacket
7 |
8 | @spec create_track(:audio | :video) :: Track.t()
9 | def create_track(type) do
10 | id = UUID.uuid1()
11 |
12 | clock_rate =
13 | case type do
14 | :audio -> 48_000
15 | :video -> 90_000
16 | end
17 |
18 | %Track{
19 | type: type,
20 | stream_id: "stream_id",
21 | id: "#{id}_#{type}",
22 | origin: "origin",
23 | fmtp: %FMTP{pt: nil},
24 | encoding: :h264,
25 | variants: [:high],
26 | clock_rate: clock_rate,
27 | active?: true,
28 | metadata: %{},
29 | ctx: %{},
30 | framerate: nil,
31 | disabled_variants: []
32 | }
33 | end
34 |
35 | @spec create_rtcp_report(non_neg_integer(), non_neg_integer(), non_neg_integer()) ::
36 | SenderReportPacket.t()
37 | def create_rtcp_report(rtp_timestamp, wallclock_timestamp, clock_rate \\ 0) do
38 | %SenderReportPacket{
39 | ssrc: 1,
40 | reports: [],
41 | sender_info: %{
42 | wallclock_timestamp: wallclock_timestamp,
43 | rtp_timestamp: rtp_timestamp + clock_rate,
44 | sender_packet_count: 0,
45 | sender_octet_count: 0
46 | }
47 | }
48 | end
49 | end
50 |
--------------------------------------------------------------------------------
/recording/test/test_helper.exs:
--------------------------------------------------------------------------------
1 | Mox.defmock(ExAws.Request.HttpMock, for: ExAws.Request.HttpClient)
2 | Application.put_env(:ex_aws, :http_client, ExAws.Request.HttpMock)
3 |
4 | ExUnit.start(capture_log: true, exclude: [:skip])
5 |
--------------------------------------------------------------------------------
/rtsp/.formatter.exs:
--------------------------------------------------------------------------------
1 | [
2 | inputs: [
3 | "{lib,test,config}/**/*.{ex,exs}",
4 | ".formatter.exs",
5 | "*.exs"
6 | ],
7 | import_deps: [:membrane_core]
8 | ]
9 |
--------------------------------------------------------------------------------
/rtsp/.gitignore:
--------------------------------------------------------------------------------
1 | # The directory Mix will write compiled artifacts to.
2 | /_build/
3 |
4 | # If you run "mix test --cover", coverage assets end up here.
5 | /cover/
6 |
7 | # The directory Mix downloads your dependencies sources to.
8 | /deps/
9 |
10 | # Where third-party dependencies like ExDoc output generated docs.
11 | /doc/
12 |
13 | # Ignore .fetch files in case you like to edit your project deps locally.
14 | /.fetch
15 |
16 | # If the VM crashes, it generates a dump, let's ignore it too.
17 | erl_crash.dump
18 |
19 | # Also ignore archive artifacts (built via "mix archive.build").
20 | *.ez
21 |
22 | # Ignore package tarball (built via "mix hex.build").
23 | rtsp-*.tar
24 |
25 | # Temporary files, for example, from tests.
26 | /tmp/
27 |
--------------------------------------------------------------------------------
/rtsp/CHANGELOG.md:
--------------------------------------------------------------------------------
1 | # Changelog
2 |
3 | ## 0.8.0-dev
4 | * Update deps [#393](https://github.com/fishjam-dev/membrane_rtc_engine/pull/393)
5 |
6 | ## 0.7.0
7 | * Move to membrane_h26x_plugin. Update deps [#374](https://github.com/jellyfish-dev/membrane_rtc_engine/pull/374)
8 |
9 | ## 0.6.0
10 | * Update deps [#363](https://github.com/jellyfish-dev/membrane_rtc_engine/pull/363)
11 |
12 | ## 0.5.0
13 | * Update deps [#340](https://github.com/jellyfish-dev/membrane_rtc_engine/pull/340)
14 |
15 | ## 0.4.0
16 | * Update to Membrane Core 1.0 [#331](https://github.com/jellyfish-dev/membrane_rtc_engine/pull/331)
17 | * Change core dependency in mix.exs from 1.0.0 to 1.0
18 |
19 | ## 0.3.0
20 | * Bump deps [#323](https://github.com/jellyfish-dev/membrane_rtc_engine/pull/323)
21 |
22 | ## 0.2.1
23 | * Bump deps [#318](https://github.com/jellyfish-dev/membrane_rtc_engine/pull/318)
24 |
25 | ## 0.2.0
26 | * Bump deps [#309](https://github.com/jellyfish-dev/membrane_rtc_engine/pull/309)
27 | * RTSP to WebRTC support [#311](https://github.com/jellyfish-dev/membrane_rtc_engine/pull/311)
28 |
29 | ## 0.1.0
30 | * Initial release
31 |
--------------------------------------------------------------------------------
/rtsp/README.md:
--------------------------------------------------------------------------------
1 | # Membrane RTC Engine RTSP Endpoint
2 |
3 | [](https://hex.pm/packages/membrane_rtc_engine_rtsp)
4 | [](https://hexdocs.pm/membrane_rtc_engine_rtsp)
5 | [](https://codecov.io/gh/jellyfish-dev/membrane_rtc_engine)
6 | [](https://circleci.com/gh/jellyfish-dev/membrane_rtc_engine)
7 |
8 | RTSP Endpoint for the [Membrane RTC Engine](https://github.com/jellyfish-dev/membrane_rtc_engine)
9 |
10 | ## Installation
11 |
12 | The package can be installed by adding `membrane_rtc_engine_rtsp` to your list of dependencies in `mix.exs`:
13 |
14 | ```elixir
15 | def deps do
16 | [
17 | {:membrane_rtc_engine_rtsp, "~> 0.7.0"}
18 | ]
19 | end
20 | ```
21 |
22 | ## Copyright and License
23 |
24 | Copyright 2023, [Software Mansion](https://swmansion.com/?utm_source=git&utm_medium=readme&utm_campaign=membrane_rtc_engine)
25 |
26 | [](https://swmansion.com/?utm_source=git&utm_medium=readme&utm_campaign=membrane_rtc_engine)
27 |
28 | Licensed under the [Apache License, Version 2.0](LICENSE)
29 |
--------------------------------------------------------------------------------
/rtsp/test/support/precise_realtimer.ex:
--------------------------------------------------------------------------------
1 | defmodule Membrane.RTC.Engine.PreciseRealtimer do
2 | @moduledoc false
3 |
4 | use Membrane.Filter
5 |
6 | def_input_pad :input, accepted_format: _any
7 | def_output_pad :output, accepted_format: _any
8 |
9 | def_options timer_resolution: [
10 | spec: Membrane.Time.t()
11 | ]
12 |
13 | @impl true
14 | def handle_init(_ctx, opts) do
15 | {[],
16 | %{
17 | tick_idx: 0,
18 | resolution: opts.timer_resolution,
19 | queue: Qex.new()
20 | }}
21 | end
22 |
23 | @impl true
24 | def handle_playing(_ctx, state) do
25 | {[start_timer: {:timer, state.resolution}], state}
26 | end
27 |
28 | @impl true
29 | def handle_buffer(:input, buffer, _ctx, state) do
30 | {[], %{state | queue: Qex.push(state.queue, {:buffer, {:output, buffer}})}}
31 | end
32 |
33 | @impl true
34 | def handle_end_of_stream(:input, _ctx, state) do
35 | {[], %{state | queue: Qex.push(state.queue, {:end_of_stream, :output})}}
36 | end
37 |
38 | @impl true
39 | def handle_tick(:timer, _ctx, %{tick_idx: tick_idx} = state) do
40 | current_ts = tick_idx * state.resolution
41 | state = %{state | tick_idx: tick_idx + 1}
42 |
43 | if Enum.empty?(state.queue) do
44 | {[], state}
45 | else
46 | {actions, buffered} =
47 | Enum.split_while(state.queue, fn
48 | {:buffer, {:output, buffer}} ->
49 | Membrane.Buffer.get_dts_or_pts(buffer) <= current_ts
50 |
51 | _other ->
52 | true
53 | end)
54 |
55 | {actions, %{state | queue: Qex.new(buffered)}}
56 | end
57 | end
58 | end
59 |
--------------------------------------------------------------------------------
/rtsp/test/test_helper.exs:
--------------------------------------------------------------------------------
1 | ExUnit.start(capture_log: true, exclude: [:skip])
2 |
--------------------------------------------------------------------------------
/sip/.formatter.exs:
--------------------------------------------------------------------------------
1 | [
2 | inputs: [
3 | "{lib,test,config}/**/*.{ex,exs}",
4 | ".formatter.exs",
5 | "*.exs"
6 | ],
7 | import_deps: [:membrane_core]
8 | ]
9 |
--------------------------------------------------------------------------------
/sip/.gitignore:
--------------------------------------------------------------------------------
1 | asterisk/recordings/*
2 |
3 | asterisk/config/sip.conf
4 |
5 | asterisk/config/sip.tmp.conf
6 |
7 | .env
8 |
9 | # The directory Mix will write compiled artifacts to.
10 | /_build/
11 |
12 | # If you run "mix test --cover", coverage assets end up here.
13 | /cover/
14 |
15 | # The directory Mix downloads your dependencies sources to.
16 | /deps/
17 |
18 | # Where third-party dependencies like ExDoc output generated docs.
19 | /doc/
20 |
21 | # Ignore .fetch files in case you like to edit your project deps locally.
22 | /.fetch
23 |
24 | # If the VM crashes, it generates a dump, let's ignore it too.
25 | erl_crash.dump
26 |
27 | # Also ignore archive artifacts (built via "mix archive.build").
28 | *.ez
29 |
30 | # Ignore package tarball (built via "mix hex.build").
31 | rtsp-*.tar
32 |
33 | # Temporary files, for example, from tests.
34 | /tmp/
35 |
--------------------------------------------------------------------------------
/sip/CHANGELOG.md:
--------------------------------------------------------------------------------
1 | # Changelog
2 |
3 | ## 0.4.0-dev
4 | * Update deps [#393](https://github.com/fishjam-dev/membrane_rtc_engine/pull/393)
5 | * Lower log level for some logs [#401](https://github.com/fishjam-dev/membrane_rtc_engine/pull/401)
6 |
7 | ## 0.3.0
8 | * Update deps [#374](https://github.com/jellyfish-dev/membrane_rtc_engine/pull/374)
9 | * Update the use of Engine.subscribe [#381](https://github.com/jellyfish-dev/membrane_rtc_engine/pull/381)
10 | * Use auto subscribe mode. [#383](https://github.com/jellyfish-dev/membrane_rtc_engine/pull/383)
11 |
12 | ## 0.2.0
13 | * Update deps [#363](https://github.com/jellyfish-dev/membrane_rtc_engine/pull/363)
14 |
15 | ## 0.1.0
16 | * Initial release [#340](https://github.com/jellyfish-dev/membrane_rtc_engine/pull/340)
17 |
--------------------------------------------------------------------------------
/sip/README.md:
--------------------------------------------------------------------------------
1 | # Membrane RTC Engine SIP Endpoint
2 |
3 | [](https://hex.pm/packages/membrane_rtc_engine_sip)
4 | [](https://hexdocs.pm/membrane_rtc_engine_sip)
5 | [](https://codecov.io/gh/jellyfish-dev/membrane_rtc_engine)
6 | [](https://circleci.com/gh/jellyfish-dev/membrane_rtc_engine)
7 |
8 | SIP Endpoint for the [Membrane RTC Engine](https://github.com/jellyfish-dev/membrane_rtc_engine)
9 |
10 | ## Installation
11 |
12 | The package can be installed by adding `membrane_rtc_engine_sip` to your list of dependencies in `mix.exs`:
13 |
14 | ```elixir
15 | def deps do
16 | [
17 | {:membrane_rtc_engine_sip, "~> 0.3.0"}
18 | ]
19 | end
20 | ```
21 |
22 | ## Copyright and License
23 |
24 | Copyright 2023, [Software Mansion](https://swmansion.com/?utm_source=git&utm_medium=readme&utm_campaign=membrane_rtc_engine)
25 |
26 | [](https://swmansion.com/?utm_source=git&utm_medium=readme&utm_campaign=membrane_rtc_engine)
27 |
28 | Licensed under the [Apache License, Version 2.0](LICENSE)
29 |
--------------------------------------------------------------------------------
/sip/internal_docs/sip_endpoint.md:
--------------------------------------------------------------------------------
1 | # SIP Endpoint
2 |
3 | This document holds design information about the SIP Endpoint.
4 |
5 | ## Architecture
6 |
7 | The Endpoint is a `Membrane.Bin` behaving like a state machine.
8 |
9 | ### State diagram
10 | ```mermaid
11 | flowchart TD
12 | U1[:unregistered] -->|receive :registered| R[:registered]
13 | U2[:unregistered_call_pending] -->|receive :registered| C[:calling]
14 | U1 ==>|SIP.dial/3| U2
15 | R ==>|SIP.dial/3| C
16 | C -->|"receive {:call_info, {:call_ready, options}}"| I[:in_call]
17 | U2 & C & I ==>|SIP.end_call/2| E[:ending_call]
18 | C & I & E -->|"receive {:call_info, {:end, reason}}"| T[:terminating]
19 | ```
20 |
--------------------------------------------------------------------------------
/sip/lib/application.ex:
--------------------------------------------------------------------------------
1 | defmodule Membrane.RTC.Engine.Endpoint.SIP.Application do
2 | @moduledoc false
3 | use Application
4 |
5 | alias Membrane.RTC.Engine.Endpoint.SIP
6 | alias Membrane.RTC.Engine.Endpoint.SIP.SippetCore
7 |
8 | @impl true
9 | def start(_start_type, _start_args) do
10 | SippetCore.setup()
11 |
12 | children = [
13 | {Registry, keys: :unique, name: SIP.CallRegistry},
14 | SIP.PortAllocator
15 | ]
16 |
17 | Supervisor.start_link(children, strategy: :one_for_one)
18 | end
19 | end
20 |
--------------------------------------------------------------------------------
/sip/lib/sip/call/auth.ex:
--------------------------------------------------------------------------------
1 | defmodule Membrane.RTC.Engine.Endpoint.SIP.Call.Auth do
2 | @moduledoc false
3 |
4 | alias Membrane.RTC.Engine.Endpoint.SIP.RegistrarCredentials
5 |
6 | @spec apply_digest(
7 | Sippet.Message.request(),
8 | Sippet.Message.response(),
9 | RegistrarCredentials.t()
10 | ) :: Sippet.Message.request()
11 | def apply_digest(request, response, credentials) do
12 | {:ok, request} =
13 | Sippet.DigestAuth.make_request(
14 | request,
15 | response,
16 | fn realm -> get_userinfo(realm, credentials) end
17 | )
18 |
19 | request =
20 | update_in(request[:headers][:via], fn [elem] ->
21 | [put_elem(elem, 3, %{"branch" => Sippet.Message.create_branch()})]
22 | end)
23 |
24 | request =
25 | update_in(request[:headers][:cseq], fn {cseq, method} ->
26 | {cseq + 1, method}
27 | end)
28 |
29 | request
30 | end
31 |
32 | defp get_userinfo(_realm, credentials) do
33 | {:ok, credentials.username, credentials.password}
34 | end
35 | end
36 |
--------------------------------------------------------------------------------
/sip/lib/sip/call/headers.ex:
--------------------------------------------------------------------------------
1 | defmodule Membrane.RTC.Engine.Endpoint.SIP.Call.Headers do
2 | @moduledoc false
3 |
4 | @caller_identifier "Engine"
5 | @user_agent "RTC Engine/SIP/0.1"
6 | @max_forwards 70
7 |
8 | @type t :: map()
9 |
10 | @spec create_headers_base(Sippet.URI.t()) :: t()
11 | def create_headers_base(from_address) do
12 | %{
13 | from: {
14 | @caller_identifier,
15 | from_address,
16 | %{"tag" => Sippet.Message.create_tag()}
17 | },
18 | via: {{2, 0}, :udp, {from_address.host, from_address.port || 0}},
19 | contact: [
20 | {
21 | @caller_identifier,
22 | from_address,
23 | %{}
24 | }
25 | ],
26 | user_agent: @user_agent,
27 | max_forwards: @max_forwards
28 | }
29 | end
30 | end
31 |
--------------------------------------------------------------------------------
/sip/lib/sip/call/settings.ex:
--------------------------------------------------------------------------------
1 | defmodule Membrane.RTC.Engine.Endpoint.SIP.Call.Settings do
2 | @moduledoc false
3 |
4 | alias Membrane.RTC.Engine.Endpoint.SIP.RegistrarCredentials
5 |
6 | @type t :: %__MODULE__{
7 | endpoint: pid(),
8 | rtp_port: 1..65_535,
9 | sip_port: 1..65_535,
10 | registrar_credentials: RegistrarCredentials.t(),
11 | external_ip: String.t(),
12 | register_interval_ms: non_neg_integer(),
13 | phone_number: String.t() | nil
14 | }
15 |
16 | @enforce_keys [
17 | :endpoint,
18 | :rtp_port,
19 | :sip_port,
20 | :registrar_credentials,
21 | :external_ip,
22 | :register_interval_ms,
23 | :phone_number
24 | ]
25 |
26 | defstruct @enforce_keys
27 |
28 | @spec new(struct()) :: t()
29 | def new(endpoint_state) do
30 | endpoint_state
31 | |> Map.from_struct()
32 | |> Map.put(:endpoint, self())
33 | |> then(&struct(__MODULE__, &1))
34 | end
35 | end
36 |
--------------------------------------------------------------------------------
/sip/lib/sip/port_allocator.ex:
--------------------------------------------------------------------------------
1 | defmodule Membrane.RTC.Engine.Endpoint.SIP.PortAllocator do
2 | @moduledoc false
3 |
4 | use GenServer
5 | require Logger
6 |
7 | @default_port_range {21_000, 21_100}
8 |
9 | @spec start_link(term()) :: GenServer.on_start()
10 | def start_link(opts) do
11 | GenServer.start_link(__MODULE__, opts, name: __MODULE__)
12 | end
13 |
14 | @spec get_port() :: {:ok, pos_integer()} | {:error, :no_available_port}
15 | def get_port() do
16 | GenServer.call(__MODULE__, :get_port)
17 | end
18 |
19 | @spec free_ports(pid()) :: :ok
20 | def free_ports(port_owner) do
21 | GenServer.cast(__MODULE__, {:free_ports, port_owner})
22 | end
23 |
24 | @impl true
25 | def init(_opts) do
26 | {from, to} = Application.get_env(:membrane_rtc_engine_sip, :port_range, @default_port_range)
27 |
28 | state = %{
29 | available: from..to |> Enum.to_list() |> :queue.from_list(),
30 | in_use: %{}
31 | }
32 |
33 | {:ok, state}
34 | end
35 |
36 | @impl true
37 | def handle_call(:get_port, {pid, _tag} = from, state) do
38 | case :queue.out(state.available) do
39 | {{:value, port}, available} ->
40 | state = %{state | available: available}
41 |
42 | case :gen_udp.open(port) do
43 | {:ok, socket} ->
44 | :ok = :gen_udp.close(socket)
45 |
46 | state = %{state | in_use: Map.update(state.in_use, pid, [port], &[port | &1])}
47 |
48 | {:reply, {:ok, port}, state}
49 |
50 | {:error, reason} ->
51 | Logger.warning("Opening port #{port} failed with reason: #{reason}")
52 |
53 | handle_call(:get_port, from, state)
54 | end
55 |
56 | {:empty, _available} ->
57 | {:reply, {:error, :no_available_port}, state}
58 | end
59 | end
60 |
61 | @impl true
62 | def handle_cast({:free_ports, pid}, state) do
63 | {ports, in_use} = Map.pop(state.in_use, pid, [])
64 |
65 | available =
66 | Enum.reduce(ports, state.available, fn elem, acc ->
67 | :queue.in(elem, acc)
68 | end)
69 |
70 | state = %{state | available: available, in_use: in_use}
71 |
72 | {:noreply, state}
73 | end
74 | end
75 |
--------------------------------------------------------------------------------
/sip/lib/sip/register_call.ex:
--------------------------------------------------------------------------------
1 | defmodule Membrane.RTC.Engine.Endpoint.SIP.RegisterCall do
2 | @moduledoc false
3 |
4 | use Membrane.RTC.Engine.Endpoint.SIP.Call
5 |
6 | alias Membrane.RTC.Engine.Endpoint.SIP.Call
7 |
8 | @impl Call
9 | def after_init(state) do
10 | send(self(), :register)
11 | state
12 | end
13 |
14 | @impl Call
15 | def handle_response(:register, 200, _response, state) do
16 | send(state.endpoint, :registered)
17 | state
18 | end
19 |
20 | @impl Call
21 | def handle_response(:register, status_code, response, state) do
22 | Call.handle_generic_response(status_code, response, state)
23 | end
24 |
25 | @impl GenServer
26 | def handle_info(:register, state) do
27 | registrar = %{
28 | state.registrar_credentials.uri
29 | | userinfo: state.registrar_credentials.username
30 | }
31 |
32 | headers = Call.build_headers(:register, state, %{to: {"", registrar, %{}}})
33 |
34 | message =
35 | :register
36 | |> Sippet.Message.build_request(to_string(registrar))
37 | |> Map.put(:headers, headers)
38 |
39 | state = Call.make_request(message, state)
40 |
41 | Process.send_after(self(), :register, state.register_interval_ms)
42 | {:noreply, state}
43 | end
44 | end
45 |
--------------------------------------------------------------------------------
/sip/lib/sip/registrar_credentials.ex:
--------------------------------------------------------------------------------
1 | defmodule Membrane.RTC.Engine.Endpoint.SIP.RegistrarCredentials do
2 | @moduledoc """
3 | Module describing credentials needed to connect with SIP registrar server
4 | """
5 |
6 | @typedoc """
7 | Describes SIP registrar credentials structure.
8 |
9 | * `uri` - URI with address of the registrar server.
10 | * `username` - your username in the registrar service
11 | * `password` - your password in the registrar service
12 | """
13 | @type t :: %__MODULE__{
14 | uri: Sippet.URI.t(),
15 | username: String.t(),
16 | password: String.t()
17 | }
18 |
19 | @enforce_keys [:uri, :username, :password]
20 | defstruct @enforce_keys
21 |
22 | @doc """
23 | Creates a `RegistrarCredentials` struct from strings.
24 |
25 | The address is parsed and can be:
26 | - an FQDN, e.g. `"my-sip-registrar.net"`,
27 | - an IPv4 in string form, e.g. `"1.2.3.4"`.
28 |
29 | Both can have a specified port, e.g. `"5.6.7.8:9999"`.
30 | If not given, the default SIP port `5060` will be assumed.
31 | """
32 | @spec new(address: String.t(), username: String.t(), password: String.t()) ::
33 | t() | no_return()
34 | def new(opts) do
35 | uri =
36 | opts
37 | |> Keyword.fetch!(:address)
38 | |> then(&("sip:" <> &1))
39 | |> Sippet.URI.parse!()
40 |
41 | %__MODULE__{
42 | uri: uri,
43 | username: Keyword.fetch!(opts, :username),
44 | password: Keyword.fetch!(opts, :password)
45 | }
46 | end
47 | end
48 |
--------------------------------------------------------------------------------
/sip/test/sip/call/auth_test.exs:
--------------------------------------------------------------------------------
1 | defmodule Membrane.RTC.AuthTest do
2 | use ExUnit.Case, async: true
3 |
4 | alias Membrane.RTC.Engine.Endpoint.SIP.Call.Auth
5 | alias Membrane.RTC.Engine.Endpoint.SIP.RegistrarCredentials
6 | alias Sippet.{DigestAuth, Message}
7 |
8 | @address "my-sip-server.net"
9 | @credentials RegistrarCredentials.new(
10 | address: @address,
11 | username: "my-username",
12 | password: "my-password"
13 | )
14 | @call_id Message.create_call_id()
15 | @original_branch Message.create_branch()
16 | @original_cseq {1, :register}
17 |
18 | test "digest auth works correctly" do
19 | sender_uri = Sippet.URI.parse!("sip:user0@1.2.3.4")
20 |
21 | headers = %{
22 | via: [{{2, 0}, :udp, {"1.2.3.4", 0}, %{"branch" => @original_branch}}],
23 | to: {"", nil, %{}},
24 | from: {"Engine", sender_uri, %{"tag" => Message.create_tag()}},
25 | user_agent: "RTC Engine/SIP/0.1",
26 | content_length: 0,
27 | call_id: @call_id,
28 | contact: [{"Engine", sender_uri, %{}}],
29 | cseq: @original_cseq,
30 | max_forwards: 70
31 | }
32 |
33 | request =
34 | Message.build_request(:register, "sip:#{@address}")
35 | |> Map.put(:headers, headers)
36 |
37 | {:ok, response} = DigestAuth.make_response(request, 401, "hyperborea")
38 |
39 | start_line = request.start_line
40 |
41 | %Message{
42 | start_line: ^start_line,
43 | headers: %{
44 | via: [{_, _, _, %{"branch" => new_branch}}],
45 | call_id: @call_id,
46 | cseq: cseq,
47 | authorization: [{"Digest", digest_params}]
48 | }
49 | } = Auth.apply_digest(request, response, @credentials)
50 |
51 | {sn, method} = @original_cseq
52 | {new_sn, ^method} = cseq
53 | assert new_sn == sn + 1
54 |
55 | assert new_branch != @original_branch
56 | refute Enum.empty?(digest_params)
57 | end
58 | end
59 |
--------------------------------------------------------------------------------
/sip/test/sip/call/sdp_test.exs:
--------------------------------------------------------------------------------
1 | defmodule Membrane.RTC.CallSDPTest do
2 | use ExUnit.Case, async: true
3 |
4 | alias Membrane.RTC.Engine.Endpoint.SIP.Call
5 |
6 | @connection_data %ExSDP.ConnectionData{address: {1, 2, 3, 4}, network_type: "IN"}
7 | @rtp_port 2140
8 | @pt 8
9 | @encoding_name :PCMA
10 | @clock_rate 8000
11 |
12 | @medialess_sdp_answer ExSDP.new(session_name: "MySuperDuperSession")
13 | |> Map.put(:connection_data, @connection_data)
14 |
15 | @acceptable_sdp_answer ExSDP.add_media(
16 | @medialess_sdp_answer,
17 | ExSDP.Media.new(:audio, @rtp_port, "RTP/AVP", @pt)
18 | )
19 |
20 | test "parsing sdp answer works correctly" do
21 | {:ok,
22 | %{
23 | rtp_payload_fmt: {@pt, %{encoding_name: @encoding_name, clock_rate: @clock_rate}},
24 | connection_data: @connection_data,
25 | port: @rtp_port
26 | }} = Call.SDP.parse(@acceptable_sdp_answer |> to_string())
27 |
28 | {:error, :no_audio_media} = Call.SDP.parse(@medialess_sdp_answer |> to_string())
29 |
30 | {:error, :no_audio_media} =
31 | Call.SDP.parse(
32 | @medialess_sdp_answer
33 | |> ExSDP.add_media(ExSDP.Media.new(:video, 1234, "RTP/AVP", 96))
34 | |> to_string()
35 | )
36 |
37 | {:error, :unknown_fmt} =
38 | Call.SDP.parse(
39 | @medialess_sdp_answer
40 | |> ExSDP.add_media(ExSDP.Media.new(:audio, 1234, "other", "???"))
41 | |> to_string()
42 | )
43 |
44 | {:error, :no_common_fmt} =
45 | Call.SDP.parse(
46 | @medialess_sdp_answer
47 | |> ExSDP.add_media(ExSDP.Media.new(:audio, 1234, "RTP/AVP", 0))
48 | |> to_string()
49 | )
50 |
51 | {:error, :no_common_fmt} =
52 | Call.SDP.parse(
53 | @medialess_sdp_answer
54 | |> ExSDP.add_media(ExSDP.Media.new(:audio, 1234, "RTP/AVP", [0, 1, 2, 3, 4, 5, 6, 7]))
55 | |> to_string()
56 | )
57 | end
58 | end
59 |
--------------------------------------------------------------------------------
/sip/test/sip/port_allocator_test.exs:
--------------------------------------------------------------------------------
1 | defmodule Membrane.RTC.PortAllocatorTest do
2 | use ExUnit.Case, async: false
3 |
4 | alias Membrane.RTC.Engine.Endpoint.SIP.PortAllocator
5 |
6 | test "handles port allocation" do
7 | restart_port_allocator()
8 |
9 | task =
10 | Task.async(fn ->
11 | {:ok, port} = PortAllocator.get_port()
12 | {self(), port}
13 | end)
14 |
15 | {someone_else, their_port} = Task.await(task)
16 | {:ok, my_port1} = PortAllocator.get_port()
17 | assert my_port1 != their_port
18 |
19 | :ok = PortAllocator.free_ports(someone_else)
20 | {:ok, my_port2} = PortAllocator.get_port()
21 | assert my_port1 != my_port2
22 | end
23 |
24 | test "handles port range config, returns error if no available ports" do
25 | :ok = Application.put_env(:membrane_rtc_engine_sip, :port_range, {2137, 2138})
26 | restart_port_allocator()
27 |
28 | {:ok, 2137} = PortAllocator.get_port()
29 | {:ok, 2138} = PortAllocator.get_port()
30 | {:error, :no_available_port} = PortAllocator.get_port()
31 |
32 | :ok = Application.delete_env(:membrane_rtc_engine_sip, :port_range)
33 | end
34 |
35 | defp restart_port_allocator() do
36 | # PortAllocator gets started during application startup, so we have to kill it
37 | if GenServer.whereis(PortAllocator),
38 | do: GenServer.stop(PortAllocator, :kill)
39 |
40 | PortAllocator.start_link(nil)
41 | end
42 | end
43 |
--------------------------------------------------------------------------------
/sip/test/test_helper.exs:
--------------------------------------------------------------------------------
1 | ExUnit.start(capture_log: true, exclude: [:skip])
2 |
--------------------------------------------------------------------------------
/webrtc/.formatter.exs:
--------------------------------------------------------------------------------
1 | [
2 | inputs: [
3 | "{lib,test,config}/**/*.{ex,exs}",
4 | ".formatter.exs",
5 | "*.exs"
6 | ],
7 | import_deps: [:membrane_core]
8 | ]
9 |
--------------------------------------------------------------------------------
/webrtc/.gitignore:
--------------------------------------------------------------------------------
1 | # The directory Mix will write compiled artifacts to.
2 | /_build/
3 |
4 | # If you run "mix test --cover", coverage assets end up here.
5 | /cover/
6 |
7 | # The directory Mix downloads your dependencies sources to.
8 | /deps/
9 |
10 | # Where third-party dependencies like ExDoc output generated docs.
11 | /doc/
12 |
13 | # Ignore .fetch files in case you like to edit your project deps locally.
14 | /.fetch
15 |
16 | # If the VM crashes, it generates a dump, let's ignore it too.
17 | erl_crash.dump
18 |
19 | # Also ignore archive artifacts (built via "mix archive.build").
20 | *.ez
21 |
22 | # Ignore package tarball (built via "mix hex.build").
23 | webrtc-*.tar
24 |
25 | # Temporary files, for example, from tests.
26 | /tmp/
27 |
--------------------------------------------------------------------------------
/webrtc/README.md:
--------------------------------------------------------------------------------
1 | # Membrane RTC Engine WebRTC Endpoint
2 |
3 | [](https://hex.pm/packages/membrane_rtc_engine_webrtc)
4 | [](https://hexdocs.pm/membrane_rtc_engine_webrtc)
5 | [](https://codecov.io/gh/jellyfish-dev/membrane_rtc_engine)
6 | [](https://circleci.com/gh/fishjam-dev/membrane_rtc_engine)
7 |
8 | WebRTC Endpoint for the [Membrane RTC Engine](https://github.com/jellyfish-dev/membrane_rtc_engine)
9 |
10 | ## Client SDKs
11 |
12 | - [JS/TS](https://github.com/jellyfish-dev/membrane-webrtc-js)
13 | - [Android](https://github.com/jellyfish-dev/membrane-webrtc-android)
14 | - [iOS](https://github.com/jellyfish-dev/membrane-webrtc-ios)
15 | - [React Native](https://github.com/jellyfish-dev/react-native-membrane-webrtc)
16 |
17 | ## Installation
18 |
19 | The package can be installed by adding `membrane_rtc_engine_webrtc` to your list of dependencies in `mix.exs`:
20 |
21 | ```elixir
22 | def deps do
23 | [
24 | {:membrane_rtc_engine_webrtc, "~> 0.8.0"}
25 | ]
26 | end
27 | ```
28 |
29 | ## Developing
30 |
31 | Integration tests using the `test_videoroom` app can be run by executing `mix test.webrtc.integration`
32 | in the `membrane_rtc_engine` package.
33 |
34 | Alternatively, you can use the commands specified [here](integration_test/test_videoroom/README.md).
35 |
36 | ## Copyright and License
37 |
38 | Copyright 2023, [Software Mansion](https://swmansion.com/?utm_source=git&utm_medium=readme&utm_campaign=membrane_rtc_engine)
39 |
40 | [](https://swmansion.com/?utm_source=git&utm_medium=readme&utm_campaign=membrane_rtc_engine)
41 |
42 | Licensed under the [Apache License, Version 2.0](LICENSE)
43 |
--------------------------------------------------------------------------------
/webrtc/config/config.exs:
--------------------------------------------------------------------------------
1 | import Config
2 |
3 | import_config "#{config_env()}.exs"
4 |
--------------------------------------------------------------------------------
/webrtc/config/dev.exs:
--------------------------------------------------------------------------------
1 | import Config
2 |
3 | config :membrane_telemetry_metrics, :enabled, true
4 |
--------------------------------------------------------------------------------
/webrtc/config/prod.exs:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/fishjam-dev/membrane_rtc_engine/2b519efdcdecd737eeeaa74be8e50904f2c5d0c0/webrtc/config/prod.exs
--------------------------------------------------------------------------------
/webrtc/config/test.exs:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/fishjam-dev/membrane_rtc_engine/2b519efdcdecd737eeeaa74be8e50904f2c5d0c0/webrtc/config/test.exs
--------------------------------------------------------------------------------
/webrtc/guides/simulcast.md:
--------------------------------------------------------------------------------
1 | # Simulcast
2 |
3 | Simulcast is a technique where a client sends multiple encodings of the same video to the server and the server is responsible for choosing and forwarding proper encoding to proper receiver (other client). The encoding selection is dynamic (i.e. SFU switches between encodings in time) and it is based on:
4 |
5 | * receiver available bandwidth
6 | * receiver preferences (e.g. explicit request to receive video in HD resolution instead of FHD)
7 | * UI layout (e.g. videos being displayed in smaller video tiles will be sent in a lower resolution)
8 |
9 | At the moment, Membrane supports only receiver preferences i.e. receiver can chose which encoding it is willing to receive. Additionally, sender can turn off/on specific encoding. Membrane RTC Engine will detect changes and switch to another available encoding.
10 |
11 | ## Turning simulcast on/off
12 |
13 | ### Server side
14 |
15 | On the server side, simulcast can be configured while adding new WebRTC Endpoint by setting its `simulcast_config` option.
16 | Remember to ensure `Rid`, `Mid` and `TWCC` extensions are used.
17 |
18 | For example
19 |
20 | ```elixir
21 | alias Membrane.RTC.Engine.Endpoint.WebRTC
22 | alias Membrane.RTC.Engine.Endpoint.WebRTC.SimulcastConfig
23 | alias Membrane.WebRTC.Extension.{Mid, Rid, TWCC}
24 | # ...
25 | %WebRTC{
26 | rtc_engine: rtc_engine,
27 | # ...
28 | webrtc_extensions: [Rid, Mid, TWCC],
29 | simulcast_config: %SimulcastConfig{
30 | enabled: true,
31 | initial_target_variant: fn _track_ -> :medium end
32 | }
33 | }
34 | ```
35 |
36 | Here we turn simulcast on and choose `:medium` variant as a target for each track
37 | that is going to be forwarded to the browser.
38 | Target variant means that it will be chosen whenever it is active.
39 | If for some reason `:medium` variant is inactive we will temporarily forward some other variant.
40 |
41 | On the other hand, setting `enabled` to `false` will result in rejecting all incoming simulcast tracks i.e. client will not send them to the server.
42 |
43 | ### Client side
44 |
45 | On the client side simulcast can be enabled while adding a new track and might differ depending
46 | on the client type e.g. for JS see https://docs.membrane.stream/membrane-webrtc-js/classes/membranewebrtc.html#addtrack
47 |
--------------------------------------------------------------------------------
/webrtc/integration_test/README.md:
--------------------------------------------------------------------------------
1 | # Integration tests
2 |
3 | Directory containing test scenarios for running integration against `membrane_rtc_engine` with the
4 | use of containerised headless browsers and containerised `test_videoroom` app.
5 |
6 | To run the container-less suite of integration tests, refer to [the videoroom app](test_videoroom/README.md).
7 |
8 | ## Test scenarios
9 |
10 | ### Packet loss
11 |
12 | Simple test using four containers: `test_videoroom` and three `test_browser`s. The browsers connect
13 | to videoroom, start sending and receiving media, then we apply packet loss on one of the browser
14 | containers and verify that other browsers receive less frames only from this particular one.
15 |
16 | To run, execute `./run_packet_loss_test.sh`
17 |
--------------------------------------------------------------------------------
/webrtc/integration_test/docker-compose.yml:
--------------------------------------------------------------------------------
1 | version: "3"
2 |
3 | x-browser-template: &browser-template
4 | image: test_videoroom_browser_image
5 | environment:
6 | ERL_COOKIE: "panuozzo-pollo-e-pancetta"
7 | SERVER_HOSTNAME: "mediaserver"
8 | networks:
9 | - network
10 | depends_on:
11 | - server
12 |
13 | services:
14 | server:
15 | build:
16 | context: ../..
17 | dockerfile: webrtc/integration_test/test_videoroom/Dockerfile
18 | container_name: mediaserver
19 | hostname: mediaserver
20 | environment:
21 | ERL_COOKIE: "panuozzo-pollo-e-pancetta"
22 | VIRTUAL_HOST: "mediaserver"
23 | INTEGRATED_TURN_IP: "192.168.0.50"
24 | INTEGRATED_TURN_PORT_RANGE: "50000-50050"
25 | USE_TLS: "true"
26 | KEY_FILE_PATH: "priv/cert/selfsigned_key.pem"
27 | CERT_FILE_PATH: "priv/cert/selfsigned.pem"
28 | networks:
29 | network:
30 | ipv4_address: 192.168.0.50
31 | volumes:
32 | - ./tmp/shared:/app/shared
33 |
34 | # Necessary for the browser container image to be built once instead of three times
35 | browser_base:
36 | build: test_browser
37 | image: test_videoroom_browser_image
38 | networks:
39 | - network
40 |
41 | browser0:
42 | <<: *browser-template
43 | container_name: browser0
44 | hostname: browser0
45 |
46 | browser1:
47 | <<: *browser-template
48 | container_name: browser1
49 | hostname: browser1
50 |
51 | browser2:
52 | <<: *browser-template
53 | container_name: browser2
54 | hostname: browser2
55 |
56 | networks:
57 | network:
58 | driver: bridge
59 | ipam:
60 | driver: default
61 | config:
62 | - subnet: 192.168.0.0/24
63 |
--------------------------------------------------------------------------------
/webrtc/integration_test/run_packet_loss_test.sh:
--------------------------------------------------------------------------------
1 | #!/bin/bash
2 |
3 | TEST_DEPS="docker pumba"
4 |
5 | # test phase durations (in seconds)
6 | LOSS_DURATION=60
7 |
8 | SHARED_VOLUME_DIR="./tmp/shared"
9 |
10 | APPLY_LOSS_TO="browser0"
11 |
12 | # Terminate on errors
13 | set -e
14 |
15 | rm -rf $SHARED_VOLUME_DIR
16 |
17 | for dep in $TEST_DEPS; do
18 | if [ ! $(which $dep) ]; then
19 | echo "Unable to run test (missing dependency: $dep)"
20 | exit 1
21 | fi
22 | done
23 |
24 | docker compose build
25 | echo "Running packet loss test"
26 | docker compose up --exit-code-from=server server browser0 browser1 browser2 &
27 | COMPOSE_JOB_ID=$!
28 |
29 | cleanup() {
30 | docker compose down --rmi local --volumes
31 | }
32 |
33 | trap cleanup EXIT
34 |
35 | echo "Sleeping until told to enable packet loss..."
36 | while [ ! -f "${SHARED_VOLUME_DIR}/ENABLE_PACKET_LOSS" ]; do
37 | if ! jobs %% >/dev/null 2>&1; then
38 | echo "ERROR: docker compose job finished too early"
39 | exit 1
40 | fi
41 |
42 | sleep 1
43 | done
44 |
45 | echo "Applying packet loss to $APPLY_LOSS_TO for $LOSS_DURATION seconds"
46 | pumba netem \
47 | --duration "${LOSS_DURATION}s" \
48 | loss \
49 | --percent 50 \
50 | $APPLY_LOSS_TO &
51 |
52 | NETEM_JOB_ID=$!
53 | trap "set +e; kill $NETEM_JOB_ID; cleanup" EXIT
54 |
55 | wait $COMPOSE_JOB_ID
56 | exit $?
57 |
--------------------------------------------------------------------------------
/webrtc/integration_test/test_browser/.dockerignore:
--------------------------------------------------------------------------------
1 | # The directory Mix will write compiled artifacts to.
2 | /_build/
3 |
4 | # If you run "mix test --cover", coverage assets end up here.
5 | /cover/
6 |
7 | # The directory Mix downloads your dependencies sources to.
8 | /deps/
9 |
10 | # Where 3rd-party dependencies like ExDoc output generated docs.
11 | /doc/
12 |
13 | # Ignore .fetch files in case you like to edit your project deps locally.
14 | /.fetch
15 |
16 | # If the VM crashes, it generates a dump, let's ignore it too.
17 | erl_crash.dump
18 |
19 | # Also ignore archive artifacts (built via "mix archive.build").
20 | *.ez
21 |
22 | # Ignore package tarball (built via "mix hex.build").
23 | test_browser-*.tar
24 |
25 | # Ignore assets that are produced by build tools.
26 | /priv/static/*
27 | /priv/cert/*
28 |
29 | # Ignore digested assets cache.
30 | /priv/static/cache_manifest.json
31 |
32 | # In case you use Node.js/npm, you want to ignore these.
33 | npm-debug.log
34 | /assets/node_modules/
35 |
36 | # Ignore git files
37 | .git/
38 | .gitignore
39 | *.gitkeep
40 |
--------------------------------------------------------------------------------
/webrtc/integration_test/test_browser/.formatter.exs:
--------------------------------------------------------------------------------
1 | # Used by "mix format"
2 | [
3 | inputs: ["{mix,.formatter}.exs", "{config,lib,test}/**/*.{ex,exs}"]
4 | ]
5 |
--------------------------------------------------------------------------------
/webrtc/integration_test/test_browser/.gitignore:
--------------------------------------------------------------------------------
1 | # The directory Mix will write compiled artifacts to.
2 | /_build/
3 |
4 | # If you run "mix test --cover", coverage assets end up here.
5 | /cover/
6 |
7 | # The directory Mix downloads your dependencies sources to.
8 | /deps/
9 |
10 | # Where third-party dependencies like ExDoc output generated docs.
11 | /doc/
12 |
13 | # Ignore .fetch files in case you like to edit your project deps locally.
14 | /.fetch
15 |
16 | # If the VM crashes, it generates a dump, let's ignore it too.
17 | erl_crash.dump
18 |
19 | # Also ignore archive artifacts (built via "mix archive.build").
20 | *.ez
21 |
22 | # Ignore package tarball (built via "mix hex.build").
23 | test_browser-*.tar
24 |
25 | # Temporary files, for example, from tests.
26 | /tmp/
27 |
--------------------------------------------------------------------------------
/webrtc/integration_test/test_browser/Dockerfile:
--------------------------------------------------------------------------------
1 | # Playwright doesn't play nicely with alpine.
2 | # Moreover, the official Elixir container images seem to be missing several libraries necessary for
3 | # the browsers to work. These libraries don't get installed when running `mix stampede.setup`...
4 | FROM ubuntu:jammy
5 |
6 | RUN \
7 | apt-get update && \
8 | apt-get -y install \
9 | locales \
10 | git \
11 | nodejs \
12 | iproute2 \
13 | erlang \
14 | unzip && \
15 | # Clear apt cache
16 | rm -rf /var/lib/apt/lists/*
17 |
18 | ADD https://github.com/elixir-lang/elixir/releases/download/v1.14.4/elixir-otp-24.zip /tmp/ex.zip
19 | RUN \
20 | unzip /tmp/ex.zip -d /elixir/ && \
21 | rm /tmp/ex.zip /elixir/bin/*.bat && \
22 | ln -s /elixir/bin/* /bin
23 |
24 | # Set the locale
25 | RUN sed -i '/en_US.UTF-8/s/^# //g' /etc/locale.gen && \
26 | locale-gen
27 | ENV LANG en_US.UTF-8
28 | ENV LANGUAGE en_US:en
29 | ENV LC_ALL en_US.UTF-8
30 |
31 | RUN mix local.hex --force && \
32 | mix local.rebar --force
33 |
34 | ENV MIX_ENV=test
35 |
36 | WORKDIR /app
37 |
38 | COPY mix.exs mix.lock ./
39 | RUN mix deps.get --only $MIX_ENV && \
40 | mix deps.compile && \
41 | mix stampede.setup
42 |
43 | COPY lib lib/
44 | RUN mix compile
45 |
46 | COPY test test/
47 |
48 | COPY docker-entrypoint.sh ./
49 | RUN chmod +x docker-entrypoint.sh
50 |
51 | ENTRYPOINT ["./docker-entrypoint.sh"]
52 |
--------------------------------------------------------------------------------
/webrtc/integration_test/test_browser/README.md:
--------------------------------------------------------------------------------
1 | # TestBrowser
2 |
3 | Standalone test application running a headless browser using Playwright. Extracted from the
4 | `test_videoroom` app, used in a container for running integration against `membrane_rtc_engine`.
5 |
6 | ## Building the container
7 | ```bash
8 | docker build -t test_browser .
9 | ```
10 |
11 | For use in tests, run `docker compose build` in the [parent of this directory](../).
12 |
--------------------------------------------------------------------------------
/webrtc/integration_test/test_browser/docker-entrypoint.sh:
--------------------------------------------------------------------------------
1 | #!/bin/sh
2 |
3 | # If a command is passed to the script, execute it instead of the default one
4 | if [ $# -gt 0 ]; then
5 | exec "$@"
6 | else
7 | # Run the test, if successful then keep idling (no way to pass `--no-halt` to `mix test`)
8 | elixir --sname $(hostname) --cookie "$ERL_COOKIE" -S mix test && tail -f /dev/null
9 | fi
10 |
--------------------------------------------------------------------------------
/webrtc/integration_test/test_browser/lib/test_browser/utils.ex:
--------------------------------------------------------------------------------
1 | defmodule TestBrowser.Utils do
2 | @moduledoc false
3 |
4 | # in milliseconds
5 | @send_interval 1000
6 |
7 | def receive_stats(recipient, acc \\ %{}) do
8 | receive do
9 | {browser_id, :end} ->
10 | # HACK: If packet loss emulation is enabled, this message may get dropped - so, we keep
11 | # sending it over and over again...
12 | # TODO: Remove once the netem command is fully synchronised with the browsers and server
13 | send_loop(recipient, {:stats, browser_id, acc})
14 | :ok
15 |
16 | {browser_id, tag, data} ->
17 | acc
18 | |> then(fn acc ->
19 | default_map = %{browser_id => [data]}
20 |
21 | Map.update(
22 | acc,
23 | tag,
24 | default_map,
25 | fn tag_map -> Map.update(tag_map, browser_id, [data], &(&1 ++ [data])) end
26 | )
27 | end)
28 | |> then(&receive_stats(recipient, &1))
29 | end
30 | end
31 |
32 | defp send_loop(recipient, msg) do
33 | send(recipient, msg)
34 |
35 | # Can't use `Process.send_after/3` as it doesn't work with remote nodes
36 | Process.sleep(@send_interval)
37 |
38 | send_loop(recipient, msg)
39 | end
40 | end
41 |
--------------------------------------------------------------------------------
/webrtc/integration_test/test_browser/mix.exs:
--------------------------------------------------------------------------------
1 | defmodule TestBrowser.MixProject do
2 | use Mix.Project
3 |
4 | def project do
5 | [
6 | app: :test_browser,
7 | version: "0.1.0",
8 | elixir: "~> 1.14",
9 | elixirc_paths: elixirc_paths(Mix.env()),
10 | start_permanent: Mix.env() == :prod,
11 | deps: deps()
12 | ]
13 | end
14 |
15 | def application do
16 | [
17 | extra_applications: [:logger]
18 | ]
19 | end
20 |
21 | defp elixirc_paths(_env), do: ["lib"]
22 |
23 | defp deps do
24 | [
25 | {:cowlib, "~> 2.11", override: true},
26 | {:stampede, github: "membraneframework-labs/stampede-elixir"}
27 | ]
28 | end
29 | end
30 |
--------------------------------------------------------------------------------
/webrtc/integration_test/test_browser/test/test_browser_test.exs:
--------------------------------------------------------------------------------
1 | defmodule TestBrowserTest do
2 | use ExUnit.Case
3 |
4 | import TestBrowser.Utils
5 |
6 | # in milliseconds
7 | @test_warmup_time 5000
8 | @browser_warmup_time 5000
9 | @packet_loss_warmup_time 5000
10 | @max_test_duration 400_000
11 |
12 | @start_button "start-all"
13 | @simulcast_inbound_stats "simulcast-inbound-stats"
14 | @simulcast_outbound_stats "simulcast-outbound-stats"
15 | @browser_options %{count: 1, headless: true, args: ["--ignore-certificate-errors"]}
16 |
17 | @stats_number 15
18 | @stats_interval 1_000
19 |
20 | @tag timeout: @max_test_duration
21 | test "run browser for packet loss test" do
22 | # Overhead for media server startup
23 | Process.sleep(@test_warmup_time)
24 |
25 | server = System.get_env("SERVER_HOSTNAME", "localhost")
26 |
27 | server_receiver =
28 | {TestVideoroom.Integration.ResultReceiver, String.to_atom(server <> "@" <> server)}
29 |
30 | stats_task = Task.async(fn -> receive_stats(server_receiver) end)
31 |
32 | hostname = with {:ok, hostname} <- :inet.gethostname(), do: to_string(hostname)
33 |
34 | mustang_options = %{
35 | target_url: "https://" <> server <> ":4005",
36 | warmup_time: @browser_warmup_time,
37 | start_button: @start_button,
38 | receiver: stats_task.pid,
39 | server: server_receiver,
40 | actions: [
41 | {:get_stats, @simulcast_inbound_stats, @stats_number, @stats_interval,
42 | tag: :after_warmup},
43 | {:wait, @packet_loss_warmup_time},
44 | {:notify_server, :enable_packet_loss},
45 | {:wait, @packet_loss_warmup_time},
46 | {:get_stats, @simulcast_inbound_stats, @stats_number, @stats_interval,
47 | tag: :after_applying_packet_loss_on_one_user},
48 |
49 | # Get local stream stats so that we know our peer ID
50 | {:get_stats, @simulcast_outbound_stats, 1, 0, tag: :local_stream_stats}
51 | ],
52 | id: hostname
53 | }
54 |
55 | Task.async(fn ->
56 | Stampede.start({TestBrowser.Mustang, mustang_options}, @browser_options)
57 | end)
58 | |> Task.await(:infinity)
59 |
60 | Task.await(stats_task, :infinity)
61 | end
62 | end
63 |
--------------------------------------------------------------------------------
/webrtc/integration_test/test_browser/test/test_helper.exs:
--------------------------------------------------------------------------------
1 | ExUnit.start()
2 |
--------------------------------------------------------------------------------
/webrtc/integration_test/test_videoroom/.dockerignore:
--------------------------------------------------------------------------------
1 | # The directory Mix will write compiled artifacts to.
2 | /_build/
3 |
4 | # If you run "mix test --cover", coverage assets end up here.
5 | /cover/
6 |
7 | # The directory Mix downloads your dependencies sources to.
8 | /deps/
9 |
10 | # Where 3rd-party dependencies like ExDoc output generated docs.
11 | /doc/
12 |
13 | # Ignore .fetch files in case you like to edit your project deps locally.
14 | /.fetch
15 |
16 | # If the VM crashes, it generates a dump, let's ignore it too.
17 | erl_crash.dump
18 |
19 | # Also ignore archive artifacts (built via "mix archive.build").
20 | *.ez
21 |
22 | # Ignore package tarball (built via "mix hex.build").
23 | test_videoroom-*.tar
24 |
25 | # Ignore assets that are produced by build tools.
26 | /priv/static/*
27 | /priv/cert/*
28 |
29 | # Ignore digested assets cache.
30 | /priv/static/cache_manifest.json
31 |
32 | # In case you use Node.js/npm, you want to ignore these.
33 | npm-debug.log
34 | /assets/node_modules/
35 |
36 | # Ignore git files
37 | .git/
38 | .gitignore
39 | *.gitkeep
40 |
--------------------------------------------------------------------------------
/webrtc/integration_test/test_videoroom/.formatter.exs:
--------------------------------------------------------------------------------
1 | [
2 | import_deps: [:phoenix],
3 | inputs: ["*.{ex,exs}", "priv/*/seeds.exs", "{config,lib,test}/**/*.{ex,exs}"]
4 | ]
5 |
--------------------------------------------------------------------------------
/webrtc/integration_test/test_videoroom/.gitignore:
--------------------------------------------------------------------------------
1 | # The directory Mix will write compiled artifacts to.
2 | /_build/
3 |
4 | # If you run "mix test --cover", coverage assets end up here.
5 | /cover/
6 |
7 | # The directory Mix downloads your dependencies sources to.
8 | /deps/
9 |
10 | # Where 3rd-party dependencies like ExDoc output generated docs.
11 | /doc/
12 |
13 | # Ignore .fetch files in case you like to edit your project deps locally.
14 | /.fetch
15 |
16 | # If the VM crashes, it generates a dump, let's ignore it too.
17 | erl_crash.dump
18 |
19 | # Also ignore archive artifacts (built via "mix archive.build").
20 | *.ez
21 |
22 | # Ignore package tarball (built via "mix hex.build").
23 | test_videoroom-*.tar
24 |
25 | # Ignore assets that are produced by build tools.
26 | /priv/static/*
27 | /priv/cert/*
28 |
29 | # Ignore digested assets cache.
30 | /priv/static/cache_manifest.json
31 |
32 | # In case you use Node.js/npm, you want to ignore these.
33 | npm-debug.log
34 | /assets/node_modules/
35 |
36 |
--------------------------------------------------------------------------------
/webrtc/integration_test/test_videoroom/Dockerfile:
--------------------------------------------------------------------------------
1 | FROM elixir:1.14.3-otp-24-alpine
2 |
3 | RUN \
4 | apk add --no-cache \
5 | git \
6 | nodejs \
7 | npm \
8 | gcc \
9 | musl-dev \
10 | pkgconfig \
11 | libsrtp-dev \
12 | openssl1.1-compat-dev \
13 | ffmpeg-dev
14 |
15 | RUN mix local.hex --force && \
16 | mix local.rebar --force
17 |
18 | WORKDIR /engine
19 | COPY engine/lib lib/
20 | COPY engine/mix.exs engine/mix.lock ./
21 | ENV RTC_ENGINE_PATH=/engine
22 |
23 | WORKDIR /webrtc
24 | COPY webrtc/config config/
25 | COPY webrtc/lib lib/
26 | COPY webrtc/mix.exs webrtc/mix.lock ./
27 |
28 | ARG APP_PATH=webrtc/integration_test/test_videoroom
29 | ENV MIX_ENV=test
30 |
31 | WORKDIR /app
32 | COPY ${APP_PATH}/mix.exs ${APP_PATH}/mix.lock ./
33 | RUN mix deps.get --only $MIX_ENV
34 |
35 | COPY ${APP_PATH}/config/config.exs ${APP_PATH}/config/${MIX_ENV}.exs config/
36 | RUN mix deps.compile
37 |
38 | COPY ${APP_PATH}/lib lib/
39 | RUN mix compile
40 |
41 | COPY ${APP_PATH}/test test/
42 |
43 | COPY ${APP_PATH}/config/runtime.exs config/
44 |
45 | COPY ${APP_PATH}/assets assets/
46 | RUN cd assets && npm install
47 | RUN mix assets.deploy
48 |
49 | # Generate self-signed cert for SSL
50 | RUN mix phx.gen.cert
51 |
52 | COPY ${APP_PATH}/docker-entrypoint.sh ./
53 | RUN chmod +x docker-entrypoint.sh
54 |
55 | ENTRYPOINT ["./docker-entrypoint.sh"]
56 |
--------------------------------------------------------------------------------
/webrtc/integration_test/test_videoroom/assets/package.json:
--------------------------------------------------------------------------------
1 | {
2 | "license": "MIT",
3 | "dependencies": {
4 | "@jellyfish-dev/membrane-webrtc-js": "github:jellyfish-dev/membrane-webrtc-js",
5 | "phoenix": "file:../deps/phoenix",
6 | "playwright": "1.18.1"
7 | }
8 | }
9 |
--------------------------------------------------------------------------------
/webrtc/integration_test/test_videoroom/config/config.exs:
--------------------------------------------------------------------------------
1 | import Config
2 |
3 | config :test_videoroom,
4 | ecto_repos: [TestVideoroom.Repo]
5 |
6 | # Configures the endpoint
7 | config :test_videoroom, TestVideoroomWeb.Endpoint,
8 | url: [host: "localhost"],
9 | render_errors: [view: TestVideoroomWeb.ErrorView, accepts: ~w(html json), layout: false],
10 | pubsub_server: TestVideoroom.PubSub
11 |
12 | # Configure esbuild (the version is required)
13 | config :esbuild,
14 | version: "0.12.18",
15 | default: [
16 | args:
17 | ~w(js/app.js --bundle --target=es2016 --outdir=../priv/static/assets --external:/fonts/* --external:/images/*),
18 | cd: Path.expand("../assets", __DIR__),
19 | env: %{"NODE_PATH" => Path.expand("../deps", __DIR__)}
20 | ]
21 |
22 | config :logger, :console,
23 | format: "$time $metadata[$level] $message\n",
24 | metadata: [:request_id]
25 |
26 | config :logger,
27 | compile_time_purge_matching: [
28 | [level_lower_than: :info],
29 | # Silence irrelevant warnings caused by resending handshake events
30 | [module: Membrane.SRTP.Encryptor, function: "handle_event/4", level_lower_than: :error],
31 | [module: Membrane.ICE, level_lower_than: :error]
32 | ]
33 |
34 | config :logger, level: :debug
35 |
36 | config :phoenix, :json_library, Jason
37 |
38 | # The CI image is too old for the precompiled deps to work
39 | config :bundlex, :disable_precompiled_os_deps, apps: [:ex_libsrtp]
40 |
41 | import_config "#{config_env()}.exs"
42 |
--------------------------------------------------------------------------------
/webrtc/integration_test/test_videoroom/config/dev.exs:
--------------------------------------------------------------------------------
1 | import Config
2 |
3 | config :test_videoroom, TestVideoroomWeb.Endpoint,
4 | http: [ip: {0, 0, 0, 0}, port: 4001],
5 | debug_errors: true,
6 | watchers: [
7 | # Start the esbuild watcher by calling Esbuild.install_and_run(:default, args)
8 | esbuild: {Esbuild, :install_and_run, [:default, ~w(--sourcemap=inline --watch)]}
9 | ]
10 |
11 | config :logger, :console, format: "[$level] $message\n"
12 | config :phoenix, :stacktrace_depth, 20
13 | config :phoenix, :plug_init_mode, :runtime
14 |
--------------------------------------------------------------------------------
/webrtc/integration_test/test_videoroom/config/prod.exs:
--------------------------------------------------------------------------------
1 | import Config
2 |
3 | config :logger, level: :info
4 |
5 | config :test_videoroom, TestVideoroomWeb.Endpoint, server: true
6 |
--------------------------------------------------------------------------------
/webrtc/integration_test/test_videoroom/config/test.exs:
--------------------------------------------------------------------------------
1 | import Config
2 |
3 | config :logger, level: :info
4 |
5 | config :test_videoroom, TestVideoroomWeb.Endpoint,
6 | http: [ip: {0, 0, 0, 0}, port: 4001],
7 | server: true
8 |
--------------------------------------------------------------------------------
/webrtc/integration_test/test_videoroom/docker-entrypoint.sh:
--------------------------------------------------------------------------------
1 | #!/bin/sh
2 |
3 | # If a command is passed to the script, execute it instead of the default one
4 | if [ $# -gt 0 ]; then
5 | exec "$@"
6 | else
7 | elixir --sname $(hostname) --cookie "$ERL_COOKIE" -S mix test.containerised --only packet_loss_test
8 | fi
9 |
--------------------------------------------------------------------------------
/webrtc/integration_test/test_videoroom/lib/test_videoroom/application.ex:
--------------------------------------------------------------------------------
1 | defmodule TestVideoroom.Application do
2 | @moduledoc false
3 |
4 | use Application
5 |
6 | @impl true
7 | def start(_type, _args) do
8 | children = [
9 | {Phoenix.PubSub, name: TestVideoroom.PubSub},
10 | TestVideoroomWeb.Endpoint
11 | ]
12 |
13 | opts = [strategy: :one_for_one, name: TestVideoroom.Supervisor]
14 |
15 | Supervisor.start_link(children, opts)
16 | end
17 |
18 | @impl true
19 | def config_change(changed, _new, removed) do
20 | TestVideoroomWeb.Endpoint.config_change(changed, removed)
21 | :ok
22 | end
23 | end
24 |
--------------------------------------------------------------------------------
/webrtc/integration_test/test_videoroom/lib/test_videoroom_web.ex:
--------------------------------------------------------------------------------
1 | defmodule TestVideoroomWeb do
2 | def controller do
3 | quote do
4 | use Phoenix.Controller, namespace: TestVideoroomWeb
5 |
6 | import Plug.Conn
7 | alias TestVideoroomWeb.Router.Helpers, as: Routes
8 | end
9 | end
10 |
11 | def view do
12 | quote do
13 | use Phoenix.View,
14 | root: "lib/test_videoroom_web/templates",
15 | namespace: TestVideoroomWeb
16 |
17 | # Import convenience functions from controllers
18 | import Phoenix.Controller,
19 | only: [get_flash: 1, get_flash: 2, view_module: 1, view_template: 1]
20 |
21 | # Include shared imports and aliases for views
22 | unquote(view_helpers())
23 | end
24 | end
25 |
26 | def live_view do
27 | quote do
28 | use Phoenix.LiveView,
29 | layout: {TestVideoroomWeb.LayoutView, "live.html"}
30 |
31 | unquote(view_helpers())
32 | end
33 | end
34 |
35 | def live_component do
36 | quote do
37 | use Phoenix.LiveComponent
38 |
39 | unquote(view_helpers())
40 | end
41 | end
42 |
43 | def router do
44 | quote do
45 | use Phoenix.Router
46 |
47 | import Plug.Conn
48 | import Phoenix.Controller
49 | import Phoenix.LiveView.Router
50 | end
51 | end
52 |
53 | def channel do
54 | quote do
55 | use Phoenix.Channel
56 | end
57 | end
58 |
59 | defp view_helpers do
60 | quote do
61 | # Use all HTML functionality (forms, tags, etc)
62 | use Phoenix.HTML
63 |
64 | # Import LiveView and .heex helpers (live_render, live_patch, <.form>, etc)
65 | import Phoenix.LiveView.Helpers
66 |
67 | # Import basic rendering functionality (render, render_layout, etc)
68 | import Phoenix.View
69 |
70 | alias TestVideoroomWeb.Router.Helpers, as: Routes
71 | end
72 | end
73 |
74 | @doc """
75 | When used, dispatch to the appropriate controller/view/etc.
76 | """
77 | defmacro __using__(which) when is_atom(which) do
78 | apply(__MODULE__, which, [])
79 | end
80 | end
81 |
--------------------------------------------------------------------------------
/webrtc/integration_test/test_videoroom/lib/test_videoroom_web/channels/room_channel.ex:
--------------------------------------------------------------------------------
1 | defmodule TestVideoroomWeb.RoomChannel do
2 | use TestVideoroomWeb, :channel
3 |
4 | require Logger
5 |
6 | @impl true
7 | def join("room" = room_id, _params, socket) do
8 | case :global.whereis_name(room_id) do
9 | :undefined -> TestVideoroom.Room.start(name: {:global, room_id})
10 | pid -> {:ok, pid}
11 | end
12 | |> case do
13 | {:ok, room} ->
14 | join_room(room_id, room, socket)
15 |
16 | {:error, {:already_started, _pid}} ->
17 | room = :global.whereis_name(room_id)
18 | join_room(room_id, room, socket)
19 |
20 | {:error, reason} ->
21 | Logger.error("""
22 | Failed to start room.
23 | Room: #{inspect(room_id)}
24 | Reason: #{inspect(reason)}
25 | """)
26 |
27 | {:error, %{reason: "failed to start room"}}
28 | end
29 | end
30 |
31 | defp join_room(room_id, room, socket) do
32 | peer_id = "#{UUID.uuid4()}"
33 | Process.monitor(room)
34 | TestVideoroom.Room.add_peer_channel(room, self(), peer_id)
35 | {:ok, Phoenix.Socket.assign(socket, %{room_id: room_id, room: room, peer_id: peer_id})}
36 | end
37 |
38 | @impl true
39 | def handle_in("mediaEvent", %{"data" => event}, socket) do
40 | send(socket.assigns.room, {:media_event, socket.assigns.peer_id, event})
41 |
42 | {:noreply, socket}
43 | end
44 |
45 | @impl true
46 | def handle_info({:media_event, event}, socket) do
47 | push(socket, "mediaEvent", %{data: event})
48 |
49 | {:noreply, socket}
50 | end
51 |
52 | @impl true
53 | def handle_info({:DOWN, _ref, :process, room, :normal}, %{assigns: %{room: room}} = state) do
54 | {:stop, :normal, state}
55 | end
56 | end
57 |
--------------------------------------------------------------------------------
/webrtc/integration_test/test_videoroom/lib/test_videoroom_web/channels/user_socket.ex:
--------------------------------------------------------------------------------
1 | defmodule TestVideoroomWeb.UserSocket do
2 | use Phoenix.Socket
3 |
4 | channel "room", TestVideoroomWeb.RoomChannel
5 |
6 | @impl true
7 | def connect(_params, socket, _connect_info) do
8 | {:ok, socket}
9 | end
10 |
11 | @impl true
12 | def id(_socket), do: nil
13 | end
14 |
--------------------------------------------------------------------------------
/webrtc/integration_test/test_videoroom/lib/test_videoroom_web/controllers/page_controller.ex:
--------------------------------------------------------------------------------
1 | defmodule TestVideoroomWeb.PageController do
2 | use TestVideoroomWeb, :controller
3 |
4 | def index(conn, _params) do
5 | render(conn, "index.html")
6 | end
7 | end
8 |
--------------------------------------------------------------------------------
/webrtc/integration_test/test_videoroom/lib/test_videoroom_web/endpoint.ex:
--------------------------------------------------------------------------------
1 | defmodule TestVideoroomWeb.Endpoint do
2 | use Phoenix.Endpoint, otp_app: :test_videoroom
3 |
4 | @session_options [
5 | store: :cookie,
6 | key: "_test_videoroom_key",
7 | signing_salt: "ptQFHLMN"
8 | ]
9 |
10 | socket "/socket", TestVideoroomWeb.UserSocket,
11 | websocket: true,
12 | longpoll: false
13 |
14 | plug Plug.Static,
15 | at: "/",
16 | from: :test_videoroom,
17 | gzip: false,
18 | only: ~w(assets fonts images favicon.ico robots.txt)
19 |
20 | plug Plug.RequestId
21 |
22 | plug Plug.Parsers,
23 | parsers: [:urlencoded, :multipart, :json],
24 | pass: ["*/*"],
25 | json_decoder: Phoenix.json_library()
26 |
27 | plug Plug.MethodOverride
28 | plug Plug.Head
29 | plug Plug.Session, @session_options
30 | plug TestVideoroomWeb.Router
31 | end
32 |
--------------------------------------------------------------------------------
/webrtc/integration_test/test_videoroom/lib/test_videoroom_web/router.ex:
--------------------------------------------------------------------------------
1 | defmodule TestVideoroomWeb.Router do
2 | use TestVideoroomWeb, :router
3 |
4 | pipeline :browser do
5 | plug :accepts, ["html"]
6 | plug :fetch_session
7 | plug :fetch_live_flash
8 | plug :put_root_layout, {TestVideoroomWeb.LayoutView, :root}
9 | plug :protect_from_forgery
10 | plug :put_secure_browser_headers
11 | end
12 |
13 | pipeline :api do
14 | plug :accepts, ["json"]
15 | end
16 |
17 | scope "/", TestVideoroomWeb do
18 | pipe_through :browser
19 |
20 | get "/", PageController, :index
21 | end
22 | end
23 |
--------------------------------------------------------------------------------
/webrtc/integration_test/test_videoroom/lib/test_videoroom_web/templates/layout/app.html.heex:
--------------------------------------------------------------------------------
1 |
6 |
7 |
9 |
7 | Membrane WebRTC video room demo
8 |Room: <%= @room_id %>
10 | 11 |
14 |
15 |
25 |
26 |
16 |
17 |
18 |
20 |
21 | Placeholder
19 |
22 |
23 |
24 |
28 |
29 |
30 | <%= get_flash(@conn, :info) %>
3 |<%= get_flash(@conn, :error) %>
4 | <%= @inner_content %> 5 |
17 |
53 |
--------------------------------------------------------------------------------
/webrtc/integration_test/test_videoroom/lib/test_videoroom_web/views/error_view.ex:
--------------------------------------------------------------------------------
1 | defmodule TestVideoroomWeb.ErrorView do
2 | use TestVideoroomWeb, :view
3 | # If you want to customize a particular status code
4 | # for a certain format, you may uncomment below.
5 | # def render("500.html", _assigns) do
6 | # "Internal Server Error"
7 | # end
8 |
9 | # By default, Phoenix returns the status message from
10 | # the template name. For example, "404.html" becomes
11 | # "Not Found".
12 | def template_not_found(template, _assigns) do
13 | Phoenix.Controller.status_message_from_template(template)
14 | end
15 | end
16 |
--------------------------------------------------------------------------------
/webrtc/integration_test/test_videoroom/lib/test_videoroom_web/views/layout_view.ex:
--------------------------------------------------------------------------------
1 | defmodule TestVideoroomWeb.LayoutView do
2 | use TestVideoroomWeb, :view
3 | end
4 |
--------------------------------------------------------------------------------
/webrtc/integration_test/test_videoroom/lib/test_videoroom_web/views/page_view.ex:
--------------------------------------------------------------------------------
1 | defmodule TestVideoroomWeb.PageView do
2 | use TestVideoroomWeb, :view
3 | end
4 |
--------------------------------------------------------------------------------
/webrtc/integration_test/test_videoroom/mix.exs:
--------------------------------------------------------------------------------
1 | defmodule TestVideoroom.MixProject do
2 | use Mix.Project
3 |
4 | def project do
5 | [
6 | app: :test_videoroom,
7 | version: "0.1.0",
8 | elixir: "~> 1.12",
9 | elixirc_paths: elixirc_paths(Mix.env()),
10 | compilers: Mix.compilers(),
11 | start_permanent: Mix.env() == :prod,
12 | deps: deps(),
13 | aliases: aliases()
14 | ]
15 | end
16 |
17 | def application do
18 | [
19 | mod: {TestVideoroom.Application, []},
20 | extra_applications: [:logger]
21 | ]
22 | end
23 |
24 | # Specifies which paths to compile per environment.
25 | defp elixirc_paths(:test), do: ["lib", "test/support"]
26 | defp elixirc_paths(_env), do: ["lib"]
27 |
28 | defp deps do
29 | [
30 | {:phoenix, "~> 1.6.2"},
31 | {:phoenix_html, "~> 3.0"},
32 | {:phoenix_live_view, "~> 0.17"},
33 | {:esbuild, "~> 0.4", runtime: Mix.env() == :dev},
34 | {:telemetry, "~> 1.0", override: true},
35 | {:jason, "~> 1.2"},
36 | {:plug_cowboy, "~> 2.5"},
37 | {:cowlib, "~> 2.11", override: true},
38 | {:membrane_rtc_engine, path: rtc_engine_path(), override: true},
39 | {:membrane_rtc_engine_webrtc, path: Path.join(rtc_engine_path(), "../webrtc/")},
40 | {:stampede, github: "membraneframework-labs/stampede-elixir"}
41 | ]
42 | end
43 |
44 | defp rtc_engine_path(), do: System.get_env("RTC_ENGINE_PATH", "../../../engine/")
45 |
46 | defp aliases() do
47 | [
48 | test: ["assets.deploy", "test --exclude containerised"],
49 | "assets.deploy": ["esbuild default --minify", "phx.digest"],
50 | "test.containerised": ["test --only containerised"]
51 | ]
52 | end
53 | end
54 |
--------------------------------------------------------------------------------
/webrtc/integration_test/test_videoroom/test/support/conn_case.ex:
--------------------------------------------------------------------------------
1 | defmodule TestVideoroomWeb.ConnCase do
2 | @moduledoc """
3 | This module defines the test case to be used by
4 | tests that require setting up a connection.
5 |
6 | Such tests rely on `Phoenix.ConnTest` and also
7 | import other functionality to make it easier
8 | to build common data structures and query the data layer.
9 |
10 | Finally, if the test case interacts with the database,
11 | we enable the SQL sandbox, so changes done to the database
12 | are reverted at the end of every test. If you are using
13 | PostgreSQL, you can even run database tests asynchronously
14 | by setting `use TestVideoroomWeb.ConnCase, async: true`, although
15 | this option is not recommended for other databases.
16 | """
17 |
18 | use ExUnit.CaseTemplate
19 |
20 | using do
21 | quote do
22 | # Import conveniences for testing with connections
23 | import Plug.Conn
24 | import Phoenix.ConnTest
25 | import TestVideoroomWeb.ConnCase
26 |
27 | alias TestVideoroomWeb.Router.Helpers, as: Routes
28 |
29 | # The default endpoint for testing
30 | @endpoint TestVideoroomWeb.Endpoint
31 | end
32 | end
33 |
34 | setup _tags do
35 | {:ok, conn: Phoenix.ConnTest.build_conn()}
36 | end
37 | end
38 |
--------------------------------------------------------------------------------
/webrtc/integration_test/test_videoroom/test/support/test_result_receiver.ex:
--------------------------------------------------------------------------------
1 | defmodule TestVideoroom.Integration.ResultReceiver do
2 | @moduledoc false
3 |
4 | use GenServer
5 | require Logger
6 |
7 | def start_link(opts) do
8 | GenServer.start_link(__MODULE__, opts, name: __MODULE__)
9 | end
10 |
11 | @impl true
12 | def init(args) do
13 | state = %{
14 | browser_count: Keyword.fetch!(args, :browser_count),
15 | parent: Keyword.fetch!(args, :parent),
16 | results: %{},
17 | received: 0
18 | }
19 |
20 | {:ok, state}
21 | end
22 |
23 | @impl true
24 | def handle_info({:stats, name, stats}, %{results: results} = state) do
25 | Logger.info("Received stats from #{inspect(name)}")
26 |
27 | results = Map.put(results, name, stats)
28 | received = Map.keys(results) |> length()
29 |
30 | if received < state.browser_count do
31 | {:noreply, %{state | results: results, received: received}}
32 | else
33 | Logger.info("All #{inspect(state.browser_count)} stats received. Result receiver exiting")
34 | send(state.parent, {:results, results})
35 |
36 | {:stop, :normal, state}
37 | end
38 | end
39 |
40 | @impl true
41 | def handle_info(msg, state) do
42 | send(state.parent, msg)
43 |
44 | {:noreply, state}
45 | end
46 | end
47 |
--------------------------------------------------------------------------------
/webrtc/integration_test/test_videoroom/test/support/utils.ex:
--------------------------------------------------------------------------------
1 | defmodule TestVideoroom.Integration.Utils do
2 | @moduledoc false
3 |
4 | def receive_stats(mustangs_number, pid, acc \\ %{}) do
5 | if mustangs_number > 0 do
6 | receive do
7 | {_browser_id, :end} ->
8 | receive_stats(mustangs_number - 1, pid, acc)
9 |
10 | {browser_id, tag, data} ->
11 | acc
12 | |> then(fn acc ->
13 | default_map = %{browser_id => [data]}
14 |
15 | Map.update(
16 | acc,
17 | tag,
18 | default_map,
19 | fn tag_map -> Map.update(tag_map, browser_id, [data], &(&1 ++ [data])) end
20 | )
21 | end)
22 | |> then(&receive_stats(mustangs_number, pid, &1))
23 | end
24 | else
25 | send(pid, {:stats, acc})
26 | end
27 | end
28 | end
29 |
--------------------------------------------------------------------------------
/webrtc/integration_test/test_videoroom/test/test_helper.exs:
--------------------------------------------------------------------------------
1 | ExUnit.start(capture_log: true, exclude: [:skip])
2 |
--------------------------------------------------------------------------------
/webrtc/internal_docs/protocol.md:
--------------------------------------------------------------------------------
1 | # Signaling Protocol
2 |
3 | ### Joining the server
4 |
5 | ```mermaid
6 | sequenceDiagram
7 | actor client
8 | participant server
9 | actor other_client
10 | client->>server: connect
11 | server->>client: connected
12 | server->>other_client: endpointAdded
13 | ```
14 |
15 | ### Adding a track
16 |
17 | ```mermaid
18 | sequenceDiagram
19 | actor client
20 | participant server
21 | actor other_client
22 | client->>server: renegotiateTracks
23 | server->>client: custom(offerData)
24 | client->>server: custom(sdpOffer)
25 | par
26 | client->>server: custom(candidate)
27 | and
28 | server->>client: custom(sdpAnswer)
29 | server->>client: custom(candidate)
30 | server->>other_client: tracksAdded
31 | server->>client: tracksAdded
32 | rect rgb(135, 204, 232)
33 | note right of server: renegotiation
34 | server->>other_client: custom(offerData)
35 | other_client->>server: custom(sdpOffer)
36 | par
37 | other_client->>server: custom(candidate)
38 | and
39 | server->>other_client: custom(sdpAnswer)
40 | server->>other_client: custom(candidate)
41 | end
42 | end
43 | end
44 | ```
45 |
46 | ### Leaving the server
47 |
48 | ```mermaid
49 | sequenceDiagram
50 | actor client
51 | participant server
52 | actor other_client
53 | client->>server: disconnect
54 | rect rgb(135, 204, 232)
55 | note right of server: renegotiation
56 | server->>other_client: custom(offerData)
57 | other_client->>server: custom(sdpOffer)
58 | par
59 | other_client->>server: custom(candidate)
60 | and
61 | server->>other_client: custom(sdpAnswer)
62 | server->>other_client: custom(candidate)
63 | end
64 | end
65 | ```
66 |
--------------------------------------------------------------------------------
/webrtc/internal_docs/webrtc_endpoint.md:
--------------------------------------------------------------------------------
1 | # WebRTC Endpoint
2 |
3 | The WebRTC Endpoint is responsible for sending/receiving media tracks to/from a web borwser.
4 |
5 |
6 | ## Architecture
7 |
8 | 
9 |
10 |
11 | ## TrackSender
12 |
13 | `TrackSender` is responsible for observing track activity and publishing track data to the engine.
14 | In particular, it is responsible for sending `Membrane.RTC.Engine.Event.TrackVariantResumed`
15 | and `Membrane.RTC.Engine.Event.TrackVariantPaused` events, and replying to `Membrane.KeyframeRequestEvent`.
16 |
17 | #### VariantTracker
18 |
19 | A browser can pause sending some encoding when e.g. it doesn't have enough bandwidth.
20 | This fact is not communicated to the server.
21 | `VariantTracker` is responsible for tracking variant activity i.e. whether it is still active.
22 |
23 | ## TrackReceiver
24 |
25 | `TrackReceiver` is responsible for receiving a track from the engine.
26 | In particular, it is responsible for sending the `Membrane.RTC.Engine.Event.RequestTrackVariant` event,
27 | forwarding keyframe requests from the browser to the `TrackSender` and repairing RTP packets after
28 | switching track variants.
29 |
30 | ## ConnectionAllocator
31 | `ConnectionAllocator` is responsible for probing the connection and negotiating bandwidth with `TrackReceiver`.
32 | The RTC Engine ships with two implementations of `ConnectionAllocator`:
33 | * `Membrane.RTC.Engine.Endpoint.WebRTC.NoOpConnectionAllocator` - always grants bandwidth requested by `TrackReceiver`
34 | * `Membrane.RTC.Engine.Endpoint.WebRTC.RTPConnectionAllocator` - probes the connection with RTP padding packets and grants bandwidth basing on GCC estimates
35 |
36 | You can read more in `Membrane.RTC.Engine.Endpoint.WebRTC.ConnectionAllocator` module docs.
37 |
--------------------------------------------------------------------------------
/webrtc/lib/endpoint_bin/extension/mid.ex:
--------------------------------------------------------------------------------
1 | defmodule Membrane.WebRTC.Extension.Mid do
2 | @moduledoc """
3 | Module implementing `Membrane.WebRTC.Extension` behaviour for Media Identification RTP Header extension.
4 |
5 | This extension is described at https://tools.ietf.org/pdf/draft-ietf-mmusic-rfc8843bis-09.pdf.
6 | """
7 | @behaviour Membrane.WebRTC.Extension
8 | alias ExSDP.Attribute.Extmap
9 | alias Membrane.WebRTC.Extension
10 |
11 | @name :mid
12 | @uri "urn:ietf:params:rtp-hdrext:sdes:mid"
13 |
14 | @impl true
15 | def new(opts \\ Keyword.new()),
16 | do: %Extension{
17 | module: __MODULE__,
18 | rtp_opts: opts,
19 | uri: @uri,
20 | name: @name
21 | }
22 |
23 | @impl true
24 | def compatible?(_encoding), do: true
25 |
26 | # there is no module parsing RTP headers against this extension as
27 | # for the whole session mid for same buffer will be the same.
28 | # It is used only in handler for `:new_rtp_stream` notification.
29 | @impl true
30 | def get_rtp_module(_mid_id, _opts, _track_type), do: :no_rtp_module
31 |
32 | @impl true
33 | def add_to_media(media, id, _direction, _payload_types),
34 | do: ExSDP.add_attribute(media, %Extmap{id: id, uri: @uri})
35 |
36 | @impl true
37 | def uri, do: @uri
38 | end
39 |
--------------------------------------------------------------------------------
/webrtc/lib/endpoint_bin/extension/repaired_rid.ex:
--------------------------------------------------------------------------------
1 | defmodule Membrane.WebRTC.Extension.RepairedRid do
2 | @moduledoc """
3 | Module implementing `Membrane.WebRTC.Extension` behaviour for Repaired RTP Stream Identifier RTP Header extension.
4 |
5 | This extension is described in RFC 8852.
6 | """
7 | @behaviour Membrane.WebRTC.Extension
8 |
9 | alias ExSDP.Attribute.Extmap
10 | alias Membrane.WebRTC.Extension
11 |
12 | @name :repaired_rid
13 | @uri "urn:ietf:params:rtp-hdrext:sdes:repaired-rtp-stream-id"
14 |
15 | @impl true
16 | def new(opts \\ Keyword.new()),
17 | do: %Extension{module: __MODULE__, rtp_opts: opts, uri: @uri, name: @name}
18 |
19 | @impl true
20 | def compatible?(_encoding), do: true
21 |
22 | @impl true
23 | def get_rtp_module(_rid_id, _opts, _track_type), do: :no_rtp_module
24 |
25 | @impl true
26 | def add_to_media(media, id, _direction, _payload_types),
27 | do: ExSDP.add_attribute(media, %Extmap{id: id, uri: @uri})
28 |
29 | @impl true
30 | def uri, do: @uri
31 | end
32 |
--------------------------------------------------------------------------------
/webrtc/lib/endpoint_bin/extension/rid.ex:
--------------------------------------------------------------------------------
1 | defmodule Membrane.WebRTC.Extension.Rid do
2 | @moduledoc """
3 | Module implementing `Membrane.WebRTC.Extension` behaviour for RTP Stream Identifier RTP Header extension.
4 |
5 | This extension is described in RFC 8852.
6 | """
7 | @behaviour Membrane.WebRTC.Extension
8 |
9 | alias ExSDP.Attribute.Extmap
10 | alias Membrane.WebRTC.Extension
11 |
12 | @name :rid
13 | @uri "urn:ietf:params:rtp-hdrext:sdes:rtp-stream-id"
14 |
15 | @impl true
16 | def new(opts \\ Keyword.new()),
17 | do: %Extension{module: __MODULE__, rtp_opts: opts, uri: @uri, name: @name}
18 |
19 | @impl true
20 | def compatible?(_encoding), do: true
21 |
22 | @impl true
23 | def get_rtp_module(_rid_id, _opts, _track_type), do: :no_rtp_module
24 |
25 | @impl true
26 | def add_to_media(media, id, _direction, _payload_types),
27 | do: ExSDP.add_attribute(media, %Extmap{id: id, uri: @uri})
28 |
29 | @impl true
30 | def uri, do: @uri
31 | end
32 |
--------------------------------------------------------------------------------
/webrtc/lib/endpoint_bin/extension/twcc.ex:
--------------------------------------------------------------------------------
1 | defmodule Membrane.WebRTC.Extension.TWCC do
2 | @moduledoc """
3 | Module implementing `Membrane.WebRTC.Extension` behaviour for Transport-wide Congestion Control RTP Header extension.
4 |
5 | This extension is described at https://datatracker.ietf.org/doc/html/draft-holmer-rmcat-transport-wide-cc-extensions-01.
6 | """
7 | @behaviour Membrane.WebRTC.Extension
8 |
9 | alias ExSDP.Attribute.{Extmap, RTCPFeedback}
10 | alias Membrane.WebRTC.Extension
11 |
12 | @name :twcc
13 | @uri "http://www.ietf.org/id/draft-holmer-rmcat-transport-wide-cc-extensions-01"
14 | @twcc_recv_rtp_module Membrane.RTP.TWCCReceiver
15 | @twcc_send_rtp_module Membrane.RTP.TWCCSender
16 |
17 | @impl true
18 | def new(opts \\ Keyword.new()),
19 | do: %Extension{module: __MODULE__, rtp_opts: opts, uri: @uri, name: @name}
20 |
21 | @impl true
22 | def compatible?(_encoding), do: true
23 |
24 | @impl true
25 | def get_rtp_module(twcc_id, _rtp_opts, :inbound), do: %@twcc_recv_rtp_module{twcc_id: twcc_id}
26 | def get_rtp_module(_twcc_id, _rtp_opts, :outbound), do: @twcc_send_rtp_module
27 |
28 | @impl true
29 | def add_to_media(media, id, _direction, payload_types) do
30 | media
31 | |> ExSDP.add_attribute(%Extmap{id: id, uri: @uri})
32 | |> ExSDP.add_attributes(Enum.map(payload_types, &%RTCPFeedback{pt: &1, feedback_type: :twcc}))
33 | end
34 |
35 | @impl true
36 | def uri, do: @uri
37 | end
38 |
--------------------------------------------------------------------------------
/webrtc/lib/endpoint_bin/extension/vad.ex:
--------------------------------------------------------------------------------
1 | defmodule Membrane.WebRTC.Extension.VAD do
2 | @moduledoc """
3 | Module implementing `Membrane.WebRTC.Extension` behaviour for Client-to-Mixer Audio Level Indication RTP Header extension.
4 |
5 | This extension is described in RFC 6464.
6 | """
7 | @behaviour Membrane.WebRTC.Extension
8 |
9 | alias ExSDP.Attribute.Extmap
10 | alias Membrane.WebRTC.Extension
11 |
12 | @name :vad
13 | @uri "urn:ietf:params:rtp-hdrext:ssrc-audio-level"
14 | @attributes ["vad=on"]
15 | @rtp_module Membrane.RTP.VAD
16 |
17 | @impl true
18 | def new(opts \\ Keyword.new()),
19 | do: %Extension{module: __MODULE__, rtp_opts: opts, uri: @uri, name: @name}
20 |
21 | @impl true
22 | def compatible?(encoding), do: encoding == :OPUS
23 |
24 | @impl true
25 | def get_rtp_module(vad_id, rtp_opts, _track_type) do
26 | struct!(@rtp_module, [{:vad_id, vad_id} | rtp_opts])
27 | end
28 |
29 | @impl true
30 | def add_to_media(media, id, _direction, _pt),
31 | do:
32 | ExSDP.add_attribute(media, %Extmap{
33 | id: id,
34 | uri: @uri,
35 | attributes: @attributes
36 | })
37 |
38 | @impl true
39 | def uri, do: @uri
40 | end
41 |
--------------------------------------------------------------------------------
/webrtc/lib/endpoint_bin/metrics.ex:
--------------------------------------------------------------------------------
1 | defmodule Membrane.WebRTC.Metrics do
2 | @moduledoc """
3 | Defines a list of metrics that can be aggregated based on events from `membrane_webrtc_plugin`.
4 | """
5 |
6 | alias Telemetry.Metrics
7 |
8 | @spec metrics() :: [Metrics.t()]
9 | def metrics(),
10 | do: [
11 | Metrics.last_value(
12 | "sdp.offer",
13 | event_name: [Membrane.WebRTC, :sdp, :offer],
14 | measurement: :sdp
15 | ),
16 | Metrics.last_value(
17 | "sdp.answer",
18 | event_name: [Membrane.WebRTC, :sdp, :answer],
19 | measurement: :sdp
20 | )
21 | ]
22 | end
23 |
--------------------------------------------------------------------------------
/webrtc/lib/endpoint_bin/track/constraints.ex:
--------------------------------------------------------------------------------
1 | defmodule Membrane.WebRTC.Track.Constraints do
2 | @moduledoc false
3 |
4 | alias ExSDP.Attribute.{FMTP, RTPMapping}
5 | alias Membrane.WebRTC.{EndpointBin, Extension}
6 |
7 | @type t :: %__MODULE__{
8 | codecs_filter: ({RTPMapping.t(), FMTP.t() | nil} -> boolean()),
9 | enabled_extensions: [Extension.t()],
10 | simulcast?: boolean(),
11 | endpoint_direction: EndpointBin.direction()
12 | }
13 |
14 | @enforce_keys [:codecs_filter, :enabled_extensions, :endpoint_direction, :simulcast?]
15 | defstruct @enforce_keys
16 | end
17 |
--------------------------------------------------------------------------------
/webrtc/lib/endpoint_bin/track/encoding.ex:
--------------------------------------------------------------------------------
1 | defmodule Membrane.WebRTC.Track.Encoding do
2 | @moduledoc """
3 | A struct holding data passed via SDP about a possible encoding of a track
4 | """
5 |
6 | alias ExSDP.Attribute.{FMTP, RTCPFeedback}
7 |
8 | @type t :: %__MODULE__{
9 | payload_type: non_neg_integer(),
10 | name: String.t(),
11 | clock_rate: pos_integer(),
12 | rtx: %{payload_type: non_neg_integer(), rtx_time: non_neg_integer() | nil} | nil,
13 | red_payload_type: non_neg_integer() | nil,
14 | audio_channels: pos_integer() | nil,
15 | rtcp_feedback: MapSet.t(RTCPFeedback.t()),
16 | format_params: FMTP.t() | nil
17 | }
18 |
19 | @enforce_keys [:payload_type, :name, :clock_rate]
20 | defstruct @enforce_keys ++
21 | [
22 | rtx: nil,
23 | red_payload_type: nil,
24 | audio_channels: nil,
25 | rtcp_feedback: MapSet.new(),
26 | format_params: nil
27 | ]
28 | end
29 |
--------------------------------------------------------------------------------
/webrtc/lib/endpoint_bin/utils.ex:
--------------------------------------------------------------------------------
1 | defmodule Membrane.WebRTC.Utils do
2 | @moduledoc false
3 |
4 | @doc """
5 | Converts encoding name to its SDP string representation.
6 | """
7 | @spec encoding_name_to_string(atom()) :: String.t()
8 | def encoding_name_to_string(encoding_name) do
9 | case encoding_name do
10 | :VP8 -> "VP8"
11 | :H264 -> "H264"
12 | :OPUS -> "opus"
13 | nil -> raise "Empty encoding name!"
14 | x -> to_string(x)
15 | end
16 | end
17 |
18 | @spec anonymize_sdp(String.t()) :: String.t()
19 | def anonymize_sdp(sdp) do
20 | Regex.replace(~r/(ice-ufrag|fingerprint|ice-pwd):.*\n/, sdp, "\\1:****\n")
21 | end
22 | end
23 |
--------------------------------------------------------------------------------
/webrtc/lib/webrtc/connection_allocator/allocation_granted_notification.ex:
--------------------------------------------------------------------------------
1 | defmodule Membrane.RTC.Engine.Endpoint.WebRTC.ConnectionAllocator.AllocationGrantedNotification do
2 | @moduledoc """
3 | Message sent by ConnectionProber to TrackReceiver whenever new allocation is granted
4 | """
5 |
6 | @enforce_keys [:allocation]
7 | defstruct @enforce_keys
8 |
9 | @type t() :: %__MODULE__{allocation: non_neg_integer()}
10 | end
11 |
--------------------------------------------------------------------------------
/webrtc/lib/webrtc/noop_connection_allocator.ex:
--------------------------------------------------------------------------------
1 | defmodule Membrane.RTC.Engine.Endpoint.WebRTC.NoOpConnectionAllocator do
2 | @moduledoc """
3 | Implementation of `Membrane.RTC.Engine.Endpoint.WebRTC.ConnectionAllocator` that grants all allocations immediately.
4 |
5 | It might be useful for non-WebRTC Endpoints
6 | """
7 | @behaviour Membrane.RTC.Engine.Endpoint.WebRTC.ConnectionAllocator
8 |
9 | alias Membrane.RTC.Engine.Endpoint.WebRTC.ConnectionAllocator.AllocationGrantedNotification
10 |
11 | @impl true
12 | def create(), do: {:ok, nil}
13 |
14 | @impl true
15 | def destroy(nil), do: :ok
16 |
17 | @impl true
18 | def register_track_receiver(_manager, _bandwidth, _track, _options \\ []), do: :ok
19 |
20 | @impl true
21 | def update_bandwidth_estimation(_manager, _estimation), do: :ok
22 |
23 | @impl true
24 | def buffer_sent(_manager, _buffer), do: :ok
25 |
26 | @impl true
27 | def request_allocation(_manager, requested_allocation) do
28 | send(self(), %AllocationGrantedNotification{allocation: requested_allocation})
29 | :ok
30 | end
31 |
32 | @impl true
33 | def set_negotiability_status(_manager, _value), do: :ok
34 | end
35 |
--------------------------------------------------------------------------------
/webrtc/lib/webrtc/simulcast_config.ex:
--------------------------------------------------------------------------------
1 | defmodule Membrane.RTC.Engine.Endpoint.WebRTC.SimulcastConfig do
2 | @moduledoc """
3 | Module representing simulcast configuration for WebRTC endpoint.
4 | """
5 |
6 | alias Membrane.RTC.Engine.Track
7 |
8 | @typedoc """
9 | Simulcast configuration.
10 |
11 | * `enabled` - whether to accept simulcast tracks or not.
12 | Setting this to false will result in rejecting all incoming
13 | simulcast tracks i.e. client will not send them.
14 | * `initial_target_variant` - function used to determine initial
15 | target variant this endpoint is willing to receive for given track.
16 | It is called for each track this endpoint subscribes for.
17 | If not provided, the highest possible variant will be used.
18 | """
19 | @type t() :: %__MODULE__{
20 | enabled: boolean(),
21 | initial_target_variant: (Track.t() -> Track.variant())
22 | }
23 | defstruct enabled: false,
24 | initial_target_variant: &__MODULE__.initial_target_variant/1
25 |
26 | @doc """
27 | Default implementation of `initial_target_variant` function in `t:t/0`.
28 |
29 | Returns :high, which will result in choosing the highest possible encoding.
30 | """
31 | @spec initial_target_variant(Track.t()) :: :high
32 | def initial_target_variant(_track), do: :high
33 | end
34 |
--------------------------------------------------------------------------------
/webrtc/test/fixtures/2_incoming_tracks_sdp.txt:
--------------------------------------------------------------------------------
1 | v=0
2 | o=- 7097343221192843169 3 IN IP4 127.0.0.1
3 | s=-
4 | t=0 0
5 | a=group:BUNDLE 0 1
6 | a=extmap-allow-mixed
7 | a=msid-semantic: WMS
8 | m=audio 9 UDP/TLS/RTP/SAVPF 111
9 | c=IN IP4 0.0.0.0
10 | a=rtcp:9 IN IP4 0.0.0.0
11 | a=ice-ufrag:RxBw
12 | a=ice-pwd:fy2QR48Q60jSkViidvOVg6Oa
13 | a=ice-options:trickle
14 | a=fingerprint:sha-256 7B:65:24:37:0B:A4:6B:90:56:E7:61:40:14:24:06:32:F2:D2:45:E7:77:DD:D9:5B:BF:CA:6A:27:5D:1F:12:6D
15 | a=setup:actpass
16 | a=mid:0
17 | a=extmap:1 urn:ietf:params:rtp-hdrext:ssrc-audio-level
18 | a=extmap:3 http://www.ietf.org/id/draft-holmer-rmcat-transport-wide-cc-extensions-01
19 | a=extmap:4 urn:ietf:params:rtp-hdrext:sdes:mid
20 | a=sendonly
21 | a=msid:- 37b798cc-aa83-427f-8add-55d6cb88d447
22 | a=rtcp-mux
23 | a=rtpmap:111 opus/48000/2
24 | a=rtcp-fb:111 transport-cc
25 | a=fmtp:111 minptime=10;useinbandfec=1
26 | a=ssrc:182703199 cname:nje6WnGPirP+JG+s
27 | a=ssrc:182703199 msid:- 37b798cc-aa83-427f-8add-55d6cb88d447
28 | a=ssrc:182703199 mslabel:-
29 | a=ssrc:182703199 label:37b798cc-aa83-427f-8add-55d6cb88d447
30 | m=video 9 UDP/TLS/RTP/SAVPF 96
31 | c=IN IP4 0.0.0.0
32 | a=rtcp:9 IN IP4 0.0.0.0
33 | a=ice-ufrag:RxBw
34 | a=ice-pwd:fy2QR48Q60jSkViidvOVg6Oa
35 | a=ice-options:trickle
36 | a=fingerprint:sha-256 7B:65:24:37:0B:A4:6B:90:56:E7:61:40:14:24:06:32:F2:D2:45:E7:77:DD:D9:5B:BF:CA:6A:27:5D:1F:12:6D
37 | a=setup:actpass
38 | a=mid:1
39 | a=extmap:3 http://www.ietf.org/id/draft-holmer-rmcat-transport-wide-cc-extensions-01
40 | a=extmap:4 urn:ietf:params:rtp-hdrext:sdes:mid
41 | a=extmap:10 urn:ietf:params:rtp-hdrext:sdes:rtp-stream-id
42 | a=sendonly
43 | a=msid:- 4441187a-e2e9-43b9-95d9-62205f52a73e
44 | a=rtcp-mux
45 | a=rtcp-rsize
46 | a=rtpmap:96 VP8/90000
47 | a=rtcp-fb:96 goog-remb
48 | a=rtcp-fb:96 transport-cc
49 | a=rtcp-fb:96 ccm fir
50 | a=rtcp-fb:96 nack
51 | a=rtcp-fb:96 nack pli
52 | a=rid:l send
53 | a=rid:m send
54 | a=rid:h send
55 | a=simulcast:send l;m;~h
56 |
--------------------------------------------------------------------------------
/webrtc/test/fixtures/2_outgoing_tracks_sdp.txt:
--------------------------------------------------------------------------------
1 | v=0
2 | o=- 2466309757551448993 2 IN IP4 127.0.0.1
3 | s=-
4 | t=0 0
5 | a=group:BUNDLE 0 1 2 3
6 | a=extmap-allow-mixed
7 | a=msid-semantic: WMS
8 | m=audio 9 UDP/TLS/RTP/SAVPF 111
9 | c=IN IP4 0.0.0.0
10 | a=rtcp:9 IN IP4 0.0.0.0
11 | a=ice-ufrag:ZCxs
12 | a=ice-pwd:dGx5puvwZ0uiI20ScIPz2xuC
13 | a=ice-options:trickle
14 | a=fingerprint:sha-256 98:DD:1C:34:B4:52:ED:6D:E1:DA:51:22:F6:26:8B:1A:34:39:00:64:C2:FE:B6:55:FB:7E:63:0B:B5:B9:49:3F
15 | a=setup:actpass
16 | a=mid:2
17 | a=extmap:1 urn:ietf:params:rtp-hdrext:ssrc-audio-level
18 | a=extmap:3 http://www.ietf.org/id/draft-holmer-rmcat-transport-wide-cc-extensions-01
19 | a=extmap:4 urn:ietf:params:rtp-hdrext:sdes:mid
20 | a=recvonly
21 | a=rtcp-mux
22 | a=rtpmap:111 opus/48000/2
23 | a=rtcp-fb:111 transport-cc
24 | a=fmtp:111 minptime=10;useinbandfec=1
25 | m=video 9 UDP/TLS/RTP/SAVPF 96
26 | c=IN IP4 0.0.0.0
27 | a=rtcp:9 IN IP4 0.0.0.0
28 | a=ice-ufrag:ZCxs
29 | a=ice-pwd:dGx5puvwZ0uiI20ScIPz2xuC
30 | a=ice-options:trickle
31 | a=fingerprint:sha-256 98:DD:1C:34:B4:52:ED:6D:E1:DA:51:22:F6:26:8B:1A:34:39:00:64:C2:FE:B6:55:FB:7E:63:0B:B5:B9:49:3F
32 | a=setup:actpass
33 | a=mid:3
34 | a=extmap:2 http://www.webrtc.org/experiments/rtp-hdrext/abs-send-time
35 | a=extmap:3 http://www.ietf.org/id/draft-holmer-rmcat-transport-wide-cc-extensions-01
36 | a=extmap:4 urn:ietf:params:rtp-hdrext:sdes:mid
37 | a=extmap:10 urn:ietf:params:rtp-hdrext:sdes:rtp-stream-id
38 | a=recvonly
39 | a=rtcp-mux
40 | a=rtcp-rsize
41 | a=rtpmap:96 VP8/90000
42 | a=rtcp-fb:96 goog-remb
43 | a=rtcp-fb:96 transport-cc
44 | a=rtcp-fb:96 ccm fir
45 | a=rtcp-fb:96 nack
46 | a=rtcp-fb:96 nack pli
47 |
--------------------------------------------------------------------------------
/webrtc/test/fixtures/README.md:
--------------------------------------------------------------------------------
1 | # Membrane WebRTC Plugin Test Fixtures
2 |
3 | List of fixtures used in tests.
4 |
5 | SDP offers/answers where generated using [`membrane_videoroom`](https://github.com/membraneframework/membrane_videoroom).
6 |
7 | * 2_incoming_tracks_sdp.txt - SDP offer containing two incoming (i.e. sent by the offerer to the peer) tracks:
8 | 1 audio and 1 video. It was simplified to contain only one codec for m-line.
9 | * 2_outgoing_tracks_sdp.txt - SDP offer containing two outgoing (i.e. received by the offerer) tracks:
10 | 1 audio and 1 video. It was simplified to contain only one codec for m-line.
--------------------------------------------------------------------------------
/webrtc/test/support/test_connection_allocator.ex:
--------------------------------------------------------------------------------
1 | defmodule Membrane.RTC.Engine.Endpoint.WebRTC.TestConnectionAllocator do
2 | @moduledoc false
3 | @behaviour Membrane.RTC.Engine.Endpoint.WebRTC.ConnectionAllocator
4 |
5 | @impl true
6 | def create(), do: {:ok, self()}
7 |
8 | @impl true
9 | def destroy(_pid), do: :ok
10 |
11 | @impl true
12 | def register_track_receiver(allocator, bandwidth, track, _options \\ []) do
13 | send(allocator, {:register_tr, self(), bandwidth, track})
14 | :ok
15 | end
16 |
17 | @impl true
18 | def request_allocation(allocator, allocation) do
19 | send(allocator, {:request_allocation, self(), allocation})
20 | :ok
21 | end
22 |
23 | @impl true
24 | def update_bandwidth_estimation(_allocator, _estimation) do
25 | raise "Unimplemented!"
26 | end
27 |
28 | @impl true
29 | def buffer_sent(_allocator, _buffer) do
30 | :ok
31 | end
32 |
33 | @impl true
34 | def set_negotiability_status(_allocator, _value) do
35 | raise "unimplemented!"
36 | end
37 | end
38 |
--------------------------------------------------------------------------------
/webrtc/test/support/utils.ex:
--------------------------------------------------------------------------------
1 | defmodule Membrane.RTC.Engine.Support.Utils do
2 | @moduledoc false
3 |
4 | alias Membrane.Buffer
5 | alias Membrane.WebRTC.Track
6 |
7 | @spec generate_random_payload(non_neg_integer) :: binary()
8 | def generate_random_payload(size) when size >= 0 do
9 | for _i <- 1..size, into: <<>>, do: <
18 |
19 |
20 |
21 |
30 |
42 |
48 |
49 |
50 | Stats
51 | uninitialized
52 |