Resolving Hex dependencies... Resolution completed in 0.135s Unchanged: bimap 1.3.0 bunch 1.6.1 circular_buffer 1.0.0 coerce 1.0.2 elixir_make 0.9.0 elixir_uuid 1.2.1 ex_rtcp 0.4.1 ex_rtp 0.4.0 ex_sdp 1.1.3 heap 2.0.2 interactive_cmd 0.1.4 jason 1.4.4 membrane_aac_format 0.8.0 membrane_aac_plugin 0.19.1 membrane_core 1.2.7 membrane_funnel_plugin 0.9.2 membrane_h264_format 0.6.1 membrane_h265_format 0.2.0 membrane_h26x_plugin 0.10.7 membrane_opus_format 0.3.0 membrane_rtp_aac_plugin 0.9.5 membrane_rtp_format 0.11.0 membrane_rtp_h264_plugin 0.20.4 membrane_rtp_h265_plugin 0.5.3 membrane_rtp_opus_plugin 0.10.1 membrane_rtp_plugin 0.31.1 membrane_rtsp 0.10.1 membrane_rtsp_plugin 0.7.2 membrane_tcp_plugin 0.6.0 membrane_telemetry_metrics 0.1.1 membrane_udp_plugin 0.14.1 mockery 2.3.4 nerves 1.14.0 nerves_discovery 0.1.2 nerves_logging 0.2.4 nerves_runtime 0.13.12 nerves_system_bbb 2.29.3 nerves_system_br 1.33.5 nerves_system_grisp2 0.17.3 nerves_system_mangopi_mq_pro 0.15.3 nerves_system_osd32mp1 0.24.3 nerves_system_qemu_aarch64 0.3.3 nerves_system_rpi 2.0.2 nerves_system_rpi0 2.0.2 nerves_system_rpi0_2 2.0.2 nerves_system_rpi2 2.0.2 nerves_system_rpi3 2.0.2 nerves_system_rpi4 2.0.2 nerves_system_rpi5 2.0.2 nerves_system_x86_64 1.33.3 nerves_toolchain_aarch64_nerves_linux_gnu 13.2.0 nerves_toolchain_armv6_nerves_linux_gnueabihf 13.2.0 nerves_toolchain_armv7_nerves_linux_gnueabihf 13.2.0 nerves_toolchain_ctng 1.10.0 nerves_toolchain_riscv64_nerves_linux_gnu 13.2.0 nerves_toolchain_x86_64_nerves_linux_musl 13.2.0 nerves_uevent 0.1.4 nimble_parsec 1.4.2 numbers 5.2.4 property_table 0.3.3 qex 0.5.2 ratio 4.0.1 ring_logger 0.11.5 shoehorn 0.9.3 tablet 0.3.2 telemetry 1.4.1 telemetry_metrics 1.1.0 toolshed 0.4.2 uboot_env 1.0.2 All dependencies have been fetched ==> jason Compiling 10 files (.ex) Generated jason app ==> tablet Compiling 2 files (.ex) Generated tablet app ==> elixir_make Compiling 8 files (.ex) Generated elixir_make app ==> nerves_discovery Compiling 5 files (.ex) Generated nerves_discovery app ==> interactive_cmd Compiling 1 file (.ex) Generated interactive_cmd app ==> nerves HOST_CC port.o HOST_LD port Compiling 51 files (.ex) Generated nerves app ==> nerves_compatibility_test Nerves environment MIX_TARGET: x86_64 MIX_ENV: prod Checking for prebuilt Nerves artifacts... Found nerves_system_x86_64 in cache /home/nerves/.nerves/artifacts/nerves_system_x86_64-portable-1.33.3 Found nerves_toolchain_x86_64_nerves_linux_musl in cache /home/nerves/.nerves/artifacts/nerves_toolchain_x86_64_nerves_linux_musl-linux_aarch64-13.2.0 ==> nerves ==> nerves_system_br Generated nerves_system_br app ==> nerves_toolchain_ctng Compiling 1 file (.ex) Generated nerves_toolchain_ctng app ==> nerves_toolchain_x86_64_nerves_linux_musl Generated nerves_toolchain_x86_64_nerves_linux_musl app ==> nerves_system_x86_64 Generated nerves_system_x86_64 app ==> nerves_compatibility_test Nerves environment MIX_TARGET: x86_64 MIX_ENV: prod ==> circular_buffer Compiling 1 file (.ex) Generated circular_buffer app ==> coerce Compiling 3 files (.ex) Generated coerce app ==> bunch Compiling 19 files (.ex) Generated bunch app ==> ex_rtcp Compiling 14 files (.ex) Generated ex_rtcp app ==> numbers Compiling 7 files (.ex) Generated numbers app ==> nerves_logging CC kmsg_tailer.o LD kmsg_tailer Compiling 5 files (.ex) Generated nerves_logging app ==> mockery Compiling 8 files (.ex) Generated mockery app ==> ratio Compiling 5 files (.ex) Generated ratio app ==> elixir_uuid Compiling 1 file (.ex) warning: use Bitwise is deprecated. import Bitwise instead │ 2 │ use Bitwise, only_operators: true │ ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ │ └─ lib/uuid.ex:2: UUID (module) Generated elixir_uuid app ==> ring_logger Compiling 7 files (.ex) Generated ring_logger app ==> shoehorn Compiling 8 files (.ex) Generated shoehorn app ==> nimble_parsec Compiling 4 files (.ex) Generated nimble_parsec app ==> nerves_compatibility_test ===> Analyzing applications... ===> Compiling telemetry ==> telemetry_metrics Compiling 7 files (.ex) Generated telemetry_metrics app ==> membrane_telemetry_metrics Compiling 7 files (.ex) Generated membrane_telemetry_metrics app ==> membrane_h265_format Compiling 1 file (.ex) Generated membrane_h265_format app ==> membrane_h264_format Compiling 1 file (.ex) Generated membrane_h264_format app ==> bimap Compiling 2 files (.ex) Generated bimap app ==> membrane_aac_format Compiling 1 file (.ex) Generated membrane_aac_format app ==> heap Compiling 4 files (.ex) Generated heap app ==> membrane_opus_format Compiling 1 file (.ex) Generated membrane_opus_format app ==> ex_sdp Compiling 26 files (.ex) Generated ex_sdp app ==> membrane_rtsp Compiling 11 files (.ex) warning: a struct for Membrane.RTSP.State is expected on struct update: %Membrane.RTSP.State{state | cseq: state.cseq + 1} but got type: dynamic() where "state" was given the type: # type: dynamic() # from: lib/membrane_rtsp/rtsp.ex:270:23 {:ok, state} <- detect_authentication_type(parsed_response, state) when defining the variable "state", you must also pattern match on "%Membrane.RTSP.State{}". hint: given pattern matching is enough to catch typing errors, you may optionally convert the struct update into a map update. For example, instead of: user = some_function() %User{user | name: "John Doe"} it is enough to write: %User{} = user = some_function() %{user | name: "John Doe"} typing violation found at: │ 271 │ state = %State{state | cseq: state.cseq + 1} │ ~ │ └─ lib/membrane_rtsp/rtsp.ex:271:15: Membrane.RTSP.parse_response/2 warning: a struct for Membrane.RTSP.State is expected on struct update: %Membrane.RTSP.State{state | session_id: session_id} but got type: dynamic() where "state" was given the type: # type: dynamic() # from: lib/membrane_rtsp/rtsp.ex:341:50 state when defining the variable "state", you must also pattern match on "%Membrane.RTSP.State{}". hint: given pattern matching is enough to catch typing errors, you may optionally convert the struct update into a map update. For example, instead of: user = some_function() %User{user | name: "John Doe"} it is enough to write: %User{} = user = some_function() %{user | name: "John Doe"} typing violation found at: │ 346 │ %State{session_id: nil} -> {:ok, %State{state | session_id: session_id}} │ ~ │ └─ lib/membrane_rtsp/rtsp.ex:346:42: Membrane.RTSP.handle_session_id/2 warning: a struct for Membrane.RTSP.Response is expected on struct update: %Membrane.RTSP.Response{response | headers: headers, body: body} but got type: dynamic() where "response" was given the type: # type: dynamic() # from: lib/membrane_rtsp/response.ex:63:37 {:ok, {response, headers}} <- parse_start_line(headers) when defining the variable "response", you must also pattern match on "%Membrane.RTSP.Response{}". hint: given pattern matching is enough to catch typing errors, you may optionally convert the struct update into a map update. For example, instead of: user = some_function() %User{user | name: "John Doe"} it is enough to write: %User{} = user = some_function() %{user | name: "John Doe"} typing violation found at: │ 66 │ {:ok, %__MODULE__{response | headers: headers, body: body}} │ ~ │ └─ lib/membrane_rtsp/response.ex:66:13: Membrane.RTSP.Response.parse/1 warning: a struct for URI is expected on struct update: %URI{uri | userinfo: nil} but got type: dynamic() where "uri" was given the type: # type: dynamic() # from: lib/membrane_rtsp/request.ex:163:28 uri when defining the variable "uri", you must also pattern match on "%URI{}". hint: given pattern matching is enough to catch typing errors, you may optionally convert the struct update into a map update. For example, instead of: user = some_function() %User{user | name: "John Doe"} it is enough to write: %User{} = user = some_function() %{user | name: "John Doe"} typing violation found at: │ 164 │ %URI{uri | userinfo: nil} │ ~ │ └─ lib/membrane_rtsp/request.ex:164:5: Membrane.RTSP.Request.process_uri/2 warning: a struct for Membrane.RTSP.Response is expected on struct update: %Membrane.RTSP.Response{response | headers: headers} but got type: dynamic() where "response" was given the type: # type: dynamic() # from: lib/membrane_rtsp/response.ex:114:37 {:ok, {response, headers}} <- parse_start_line(headers) when defining the variable "response", you must also pattern match on "%Membrane.RTSP.Response{}". hint: given pattern matching is enough to catch typing errors, you may optionally convert the struct update into a map update. For example, instead of: user = some_function() %User{user | name: "John Doe"} it is enough to write: %User{} = user = some_function() %{user | name: "John Doe"} typing violation found at: │ 119 │ get_header(%__MODULE__{response | headers: headers}, "Content-Length") do │ ~ │ └─ lib/membrane_rtsp/response.ex:119:23: Membrane.RTSP.Response.verify_content_length/1 Generated membrane_rtsp app ==> ex_rtp Compiling 5 files (.ex) warning: a struct for ExRTP.Packet is expected on struct update: %ExRTP.Packet{packet | extension: false, extension_profile: nil, extensions: nil} but got type: dynamic() where "packet" was given the type: # type: dynamic() # from: lib/ex_rtp/packet.ex:205:24 packet when defining the variable "packet", you must also pattern match on "%ExRTP.Packet{}". hint: given pattern matching is enough to catch typing errors, you may optionally convert the struct update into a map update. For example, instead of: user = some_function() %User{user | name: "John Doe"} it is enough to write: %User{} = user = some_function() %{user | name: "John Doe"} typing violation found at: │ 207 │ [] -> %__MODULE__{packet | extension: false, extension_profile: nil, extensions: nil} │ ~ │ └─ lib/ex_rtp/packet.ex:207:13: ExRTP.Packet.remove_extension/2 warning: a struct for ExRTP.Packet is expected on struct update: %ExRTP.Packet{packet | extensions: extensions} but got type: dynamic() where "packet" was given the type: # type: dynamic() # from: lib/ex_rtp/packet.ex:205:24 packet when defining the variable "packet", you must also pattern match on "%ExRTP.Packet{}". hint: given pattern matching is enough to catch typing errors, you may optionally convert the struct update into a map update. For example, instead of: user = some_function() %User{user | name: "John Doe"} it is enough to write: %User{} = user = some_function() %{user | name: "John Doe"} typing violation found at: │ 208 │ extensions -> %__MODULE__{packet | extensions: extensions} │ ~ │ └─ lib/ex_rtp/packet.ex:208:21: ExRTP.Packet.remove_extension/2 Generated ex_rtp app ==> uboot_env Compiling 5 files (.ex) Generated uboot_env app ==> qex Compiling 4 files (.ex) warning: x..y inside match is deprecated, you must always match on the step: x..y//var or x..y//_ if you want to ignore it lib/qex.ex:45: Qex.new/1 Generated qex app ==> membrane_core Compiling 139 files (.ex) Generated membrane_core app ==> membrane_aac_plugin Compiling 6 files (.ex) warning: a struct for Membrane.Buffer is expected on struct update: %Membrane.Buffer{ buffer | payload: Membrane.AAC.Parser.ADTS.payload_to_adts(buffer.payload, ctx.pads.output.stream_format) } but got type: dynamic(%{..., pts: integer()}) where "buffer" was given the type: # type: dynamic(%{..., pts: integer()}) # from: lib/membrane/aac/parser.ex:185:12 buffer = %{buffer | pts: round(Ratio.to_float(timestamp))} when defining the variable "buffer", you must also pattern match on "%Membrane.Buffer{}". hint: given pattern matching is enough to catch typing errors, you may optionally convert the struct update into a map update. For example, instead of: user = some_function() %User{user | name: "John Doe"} it is enough to write: %User{} = user = some_function() %{user | name: "John Doe"} typing violation found at: │ 190 │ %Buffer{ │ ~ │ └─ lib/membrane/aac/parser.ex:190:11: Membrane.AAC.Parser.handle_buffer/4 warning: a struct for Membrane.AAC.Filler.State is expected on struct update: %Membrane.AAC.Filler.State{state | frame_duration: new_duration, channels: stream_format.channels} but got type: dynamic() where "state" was given the type: # type: dynamic() # from: lib/membrane/aac/filler.ex:71:57 state when defining the variable "state", you must also pattern match on "%Membrane.AAC.Filler.State{}". hint: given pattern matching is enough to catch typing errors, you may optionally convert the struct update into a map update. For example, instead of: user = some_function() %User{user | name: "John Doe"} it is enough to write: %User{} = user = some_function() %{user | name: "John Doe"} typing violation found at: │ 75 │ state = %State{state | frame_duration: new_duration, channels: stream_format.channels} │ ~ │ └─ lib/membrane/aac/filler.ex:75:13: Membrane.AAC.Filler.handle_stream_format/4 warning: a struct for Membrane.Buffer is expected on struct update: %Membrane.Buffer{ buffer | payload: silent_frame_payload, pts: round(timestamp), dts: round(timestamp) } but got type: dynamic() where "buffer" was given the type: # type: dynamic() # from: lib/membrane/aac/filler.ex:81:29 buffer when defining the variable "buffer", you must also pattern match on "%Membrane.Buffer{}". hint: given pattern matching is enough to catch typing errors, you may optionally convert the struct update into a map update. For example, instead of: user = some_function() %User{user | name: "John Doe"} it is enough to write: %User{} = user = some_function() %{user | name: "John Doe"} typing violation found at: │ 96 │ %Buffer{ │ ~ │ └─ lib/membrane/aac/filler.ex:96:9: Membrane.AAC.Filler.handle_buffer/4 Generated membrane_aac_plugin app ==> membrane_h26x_plugin Compiling 31 files (.ex) Generated membrane_h26x_plugin app ==> membrane_tcp_plugin Compiling 4 files (.ex) Generated membrane_tcp_plugin app ==> membrane_udp_plugin Compiling 5 files (.ex) Generated membrane_udp_plugin app ==> membrane_funnel_plugin Compiling 2 files (.ex) Generated membrane_funnel_plugin app ==> membrane_rtp_format Compiling 5 files (.ex) Generated membrane_rtp_format app ==> membrane_rtp_aac_plugin Compiling 4 files (.ex) warning: a struct for Membrane.Buffer is expected on struct update: %Membrane.Buffer{buffer | payload: &1} but got type: dynamic() where "buffer" was given the type: # type: dynamic() # from: lib/membrane_element_rtp_aac/depayloader.ex:36:29 buffer when defining the variable "buffer", you must also pattern match on "%Membrane.Buffer{}". hint: given pattern matching is enough to catch typing errors, you may optionally convert the struct update into a map update. For example, instead of: user = some_function() %User{user | name: "John Doe"} it is enough to write: %User{} = user = some_function() %{user | name: "John Doe"} typing violation found at: │ 38 │ buffers = Enum.map(payloads, &%Buffer{buffer | payload: &1}) │ ~ │ └─ lib/membrane_element_rtp_aac/depayloader.ex:38:37: Membrane.RTP.AAC.Depayloader.handle_buffer/4 warning: a struct for Membrane.Buffer is expected on struct update: %Membrane.Buffer{buffer | payload: wrap_aac(acc, state)} but got type: dynamic() where "buffer" was given the type: # type: dynamic() # from: lib/membrane_element_rtp_aac/payloader.ex:46:29 buffer when defining the variable "buffer", you must also pattern match on "%Membrane.Buffer{}". hint: given pattern matching is enough to catch typing errors, you may optionally convert the struct update into a map update. For example, instead of: user = some_function() %User{user | name: "John Doe"} it is enough to write: %User{} = user = some_function() %{user | name: "John Doe"} typing violation found at: │ 52 │ new_buffer = %Buffer{buffer | payload: wrap_aac(acc, state)} │ ~ │ └─ lib/membrane_element_rtp_aac/payloader.ex:52:20: Membrane.RTP.AAC.Payloader.handle_buffer/4 Generated membrane_rtp_aac_plugin app ==> membrane_rtp_h264_plugin Compiling 8 files (.ex) warning: a struct for Membrane.Buffer is expected on struct update: %Membrane.Buffer{buffer | payload: &1} but got type: dynamic() where "buffer" was given the type: # type: dynamic() # from: lib/rtp_h264/payloader.ex:185:17 buffer when defining the variable "buffer", you must also pattern match on "%Membrane.Buffer{}". hint: given pattern matching is enough to catch typing errors, you may optionally convert the struct update into a map update. For example, instead of: user = some_function() %User{user | name: "John Doe"} it is enough to write: %User{} = user = some_function() %{user | name: "John Doe"} typing violation found at: │ 188 │ |> Enum.map(&%Buffer{buffer | payload: &1}) │ ~ │ └─ lib/rtp_h264/payloader.ex:188:18: Membrane.RTP.H264.Payloader.use_fu_a/2 warning: a struct for Membrane.RTP.H264.Depayloader.State is expected on struct update: %Membrane.RTP.H264.Depayloader.State{state | parser_acc: nil} but got type: dynamic() where "state" was given the type: # type: dynamic() # from: lib/rtp_h264/depayloader.ex:42:43 state when defining the variable "state", you must also pattern match on "%Membrane.RTP.H264.Depayloader.State{}". hint: given pattern matching is enough to catch typing errors, you may optionally convert the struct update into a map update. For example, instead of: user = some_function() %User{user | name: "John Doe"} it is enough to write: %User{} = user = some_function() %{user | name: "John Doe"} typing violation found at: │ 50 │ {[], %State{state | parser_acc: nil}} │ ~ │ └─ lib/rtp_h264/depayloader.ex:50:14: Membrane.RTP.H264.Depayloader.handle_buffer/4 warning: a struct for Membrane.RTP.H264.Depayloader.State is expected on struct update: %Membrane.RTP.H264.Depayloader.State{state | parser_acc: nil} but got type: dynamic() where "state" was given the type: # type: dynamic() # from: lib/rtp_h264/depayloader.ex:66:56 state when defining the variable "state", you must also pattern match on "%Membrane.RTP.H264.Depayloader.State{}". hint: given pattern matching is enough to catch typing errors, you may optionally convert the struct update into a map update. For example, instead of: user = some_function() %User{user | name: "John Doe"} it is enough to write: %User{} = user = some_function() %{user | name: "John Doe"} typing violation found at: │ 70 │ result = buffer_output(data, buffer, %State{state | parser_acc: nil}) │ ~ │ └─ lib/rtp_h264/depayloader.ex:70:46: Membrane.RTP.H264.Depayloader.handle_unit_type/4 warning: a struct for Membrane.RTP.H264.FU is expected on struct update: %Membrane.RTP.H264.FU{acc | data: [packet]} but got type: dynamic() where "acc" was given the type: # type: dynamic() # from: lib/rtp_h264/nal_formats/fu.ex:73:54 acc when defining the variable "acc", you must also pattern match on "%Membrane.RTP.H264.FU{}". hint: given pattern matching is enough to catch typing errors, you may optionally convert the struct update into a map update. For example, instead of: user = some_function() %User{user | name: "John Doe"} it is enough to write: %User{} = user = some_function() %{user | name: "John Doe"} typing violation found at: │ 74 │ do: {:incomplete, %__MODULE__{acc | data: [packet]}} │ ~ │ └─ lib/rtp_h264/nal_formats/fu.ex:74:23: Membrane.RTP.H264.FU.do_parse/3 warning: a struct for Membrane.RTP.H264.Depayloader.State is expected on struct update: %Membrane.RTP.H264.Depayloader.State{state | parser_acc: fu} but got type: dynamic() where "state" was given the type: # type: dynamic() # from: lib/rtp_h264/depayloader.ex:66:56 state when defining the variable "state", you must also pattern match on "%Membrane.RTP.H264.Depayloader.State{}". hint: given pattern matching is enough to catch typing errors, you may optionally convert the struct update into a map update. For example, instead of: user = some_function() %User{user | name: "John Doe"} it is enough to write: %User{} = user = some_function() %{user | name: "John Doe"} typing violation found at: │ 74 │ result = {[], %State{state | parser_acc: fu}} │ ~ │ └─ lib/rtp_h264/depayloader.ex:74:23: Membrane.RTP.H264.Depayloader.handle_unit_type/4 warning: a struct for Membrane.Buffer is expected on struct update: %Membrane.Buffer{buffer | payload: add_prefix(&1)} but got type: dynamic() where "buffer" was given the type: # type: dynamic() # from: lib/rtp_h264/depayloader.ex:82:51 buffer when defining the variable "buffer", you must also pattern match on "%Membrane.Buffer{}". hint: given pattern matching is enough to catch typing errors, you may optionally convert the struct update into a map update. For example, instead of: user = some_function() %User{user | name: "John Doe"} it is enough to write: %User{} = user = some_function() %{user | name: "John Doe"} typing violation found at: │ 84 │ buffers = Enum.map(result, &%Buffer{buffer | payload: add_prefix(&1)}) │ ~ │ └─ lib/rtp_h264/depayloader.ex:84:35: Membrane.RTP.H264.Depayloader.handle_unit_type/4 warning: a struct for Membrane.Buffer is expected on struct update: %Membrane.Buffer{buffer | payload: add_prefix(data)} but got type: dynamic() where "buffer" was given the type: # type: dynamic() # from: lib/rtp_h264/depayloader.ex:94:31 buffer when defining the variable "buffer", you must also pattern match on "%Membrane.Buffer{}". hint: given pattern matching is enough to catch typing errors, you may optionally convert the struct update into a map update. For example, instead of: user = some_function() %User{user | name: "John Doe"} it is enough to write: %User{} = user = some_function() %{user | name: "John Doe"} typing violation found at: │ 95 │ [buffer: {:output, %Buffer{buffer | payload: add_prefix(data)}}] │ ~ │ └─ lib/rtp_h264/depayloader.ex:95:24: Membrane.RTP.H264.Depayloader.action_from_data/2 Generated membrane_rtp_h264_plugin app ==> membrane_rtp_h265_plugin Compiling 6 files (.ex) warning: a struct for Membrane.Buffer is expected on struct update: %Membrane.Buffer{buffer | payload: &1} but got type: dynamic() where "buffer" was given the type: # type: dynamic() # from: lib/payloader.ex:181:15 buffer when defining the variable "buffer", you must also pattern match on "%Membrane.Buffer{}". hint: given pattern matching is enough to catch typing errors, you may optionally convert the struct update into a map update. For example, instead of: user = some_function() %User{user | name: "John Doe"} it is enough to write: %User{} = user = some_function() %{user | name: "John Doe"} typing violation found at: │ 184 │ |> Enum.map(&%Buffer{buffer | payload: &1}) │ ~ │ └─ lib/payloader.ex:184:18: Membrane.RTP.H265.Payloader.use_fu/2 warning: a struct for Membrane.RTP.H265.Depayloader.State is expected on struct update: %Membrane.RTP.H265.Depayloader.State{state | parser_acc: nil} but got type: dynamic() where "state" was given the type: # type: dynamic() # from: lib/depayloader.ex:63:43 state when defining the variable "state", you must also pattern match on "%Membrane.RTP.H265.Depayloader.State{}". hint: given pattern matching is enough to catch typing errors, you may optionally convert the struct update into a map update. For example, instead of: user = some_function() %User{user | name: "John Doe"} it is enough to write: %User{} = user = some_function() %{user | name: "John Doe"} typing violation found at: │ 71 │ {[], %State{state | parser_acc: nil}} │ ~ │ └─ lib/depayloader.ex:71:14: Membrane.RTP.H265.Depayloader.handle_buffer/4 warning: a struct for Membrane.Buffer is expected on struct update: %Membrane.Buffer{buffer | payload: payload} but got type: dynamic() where "buffer" was given the type: # type: dynamic() # from: lib/depayloader.ex:82:46 buffer when defining the variable "buffer", you must also pattern match on "%Membrane.Buffer{}". hint: given pattern matching is enough to catch typing errors, you may optionally convert the struct update into a map update. For example, instead of: user = some_function() %User{user | name: "John Doe"} it is enough to write: %User{} = user = some_function() %{user | name: "John Doe"} typing violation found at: │ 86 │ {don, %Buffer{buffer | payload: payload}} │ ~ │ └─ lib/depayloader.ex:86:15: Membrane.RTP.H265.Depayloader.handle_unit_type/4 warning: a struct for Membrane.RTP.H265.Depayloader.State is expected on struct update: %Membrane.RTP.H265.Depayloader.State{state | parser_acc: nil} but got type: dynamic() where "state" was given the type: # type: dynamic() # from: lib/depayloader.ex:95:54 state when defining the variable "state", you must also pattern match on "%Membrane.RTP.H265.Depayloader.State{}". hint: given pattern matching is enough to catch typing errors, you may optionally convert the struct update into a map update. For example, instead of: user = some_function() %User{user | name: "John Doe"} it is enough to write: %User{} = user = some_function() %{user | name: "John Doe"} typing violation found at: │ 103 │ result = buffer_output(data, buffer, don, %State{state | parser_acc: nil}) │ ~ │ └─ lib/depayloader.ex:103:51: Membrane.RTP.H265.Depayloader.handle_unit_type/4 warning: a struct for Membrane.RTP.H265.FU is expected on struct update: %Membrane.RTP.H265.FU{acc | data: [data], last_seq_num: seq_num, type: type} but got type: dynamic(%{..., donl?: false}) where "acc" was given the type: # type: dynamic(%{..., donl?: false}) # from: lib/nal_formats/fu.ex:87:89 %{donl?: false} = acc when defining the variable "acc", you must also pattern match on "%Membrane.RTP.H265.FU{}". hint: given pattern matching is enough to catch typing errors, you may optionally convert the struct update into a map update. For example, instead of: user = some_function() %User{user | name: "John Doe"} it is enough to write: %User{} = user = some_function() %{user | name: "John Doe"} typing violation found at: │ 88 │ do: {:incomplete, %__MODULE__{acc | data: [data], last_seq_num: seq_num, type: type}} │ ~ │ └─ lib/nal_formats/fu.ex:88:23: Membrane.RTP.H265.FU.do_parse/4 warning: a struct for Membrane.RTP.H265.Depayloader.State is expected on struct update: %Membrane.RTP.H265.Depayloader.State{state | parser_acc: fu} but got type: dynamic() where "state" was given the type: # type: dynamic() # from: lib/depayloader.ex:95:54 state when defining the variable "state", you must also pattern match on "%Membrane.RTP.H265.Depayloader.State{}". hint: given pattern matching is enough to catch typing errors, you may optionally convert the struct update into a map update. For example, instead of: user = some_function() %User{user | name: "John Doe"} it is enough to write: %User{} = user = some_function() %{user | name: "John Doe"} typing violation found at: │ 107 │ result = {[], %State{state | parser_acc: fu}} │ ~ │ └─ lib/depayloader.ex:107:23: Membrane.RTP.H265.Depayloader.handle_unit_type/4 warning: a struct for Membrane.RTP.H265.FU is expected on struct update: %Membrane.RTP.H265.FU{acc | data: [data], last_seq_num: seq_num, type: type, don: don} but got type: dynamic() where "acc" was given the type: # type: dynamic() # from: lib/nal_formats/fu.ex:90:94 acc when defining the variable "acc", you must also pattern match on "%Membrane.RTP.H265.FU{}". hint: given pattern matching is enough to catch typing errors, you may optionally convert the struct update into a map update. For example, instead of: user = some_function() %User{user | name: "John Doe"} it is enough to write: %User{} = user = some_function() %{user | name: "John Doe"} typing violation found at: │ 91 │ {:incomplete, %__MODULE__{acc | data: [data], last_seq_num: seq_num, type: type, don: don}} │ ~ │ └─ lib/nal_formats/fu.ex:91:19: Membrane.RTP.H265.FU.do_parse/4 warning: a struct for Membrane.Buffer is expected on struct update: %Membrane.Buffer{buffer | payload: add_prefix(nalu), metadata: metadata} but got type: dynamic() where "buffer" was given the type: # type: dynamic() # from: lib/depayloader.ex:115:47 buffer when defining the variable "buffer", you must also pattern match on "%Membrane.Buffer{}". hint: given pattern matching is enough to catch typing errors, you may optionally convert the struct update into a map update. For example, instead of: user = some_function() %User{user | name: "John Doe"} it is enough to write: %User{} = user = some_function() %{user | name: "John Doe"} typing violation found at: │ 120 │ %Buffer{buffer | payload: add_prefix(nalu), metadata: metadata} │ ~ │ └─ lib/depayloader.ex:120:11: Membrane.RTP.H265.Depayloader.handle_unit_type/4 warning: a struct for Membrane.Buffer is expected on struct update: %Membrane.Buffer{buffer | payload: add_prefix(data)} but got type: dynamic() where "buffer" was given the type: # type: dynamic() # from: lib/depayloader.ex:132:31 buffer when defining the variable "buffer", you must also pattern match on "%Membrane.Buffer{}". hint: given pattern matching is enough to catch typing errors, you may optionally convert the struct update into a map update. For example, instead of: user = some_function() %User{user | name: "John Doe"} it is enough to write: %User{} = user = some_function() %{user | name: "John Doe"} typing violation found at: │ 133 │ [buffer: {:output, %Buffer{buffer | payload: add_prefix(data)}}] │ ~ │ └─ lib/depayloader.ex:133:24: Membrane.RTP.H265.Depayloader.action_from_data/3 warning: a struct for Membrane.Buffer is expected on struct update: %Membrane.Buffer{buffer | payload: add_prefix(data), metadata: metadata} but got type: dynamic() where "buffer" was given the type: # type: dynamic() # from: lib/depayloader.ex:136:31 buffer when defining the variable "buffer", you must also pattern match on "%Membrane.Buffer{}". hint: given pattern matching is enough to catch typing errors, you may optionally convert the struct update into a map update. For example, instead of: user = some_function() %User{user | name: "John Doe"} it is enough to write: %User{} = user = some_function() %{user | name: "John Doe"} typing violation found at: │ 138 │ [buffer: {:output, %Buffer{buffer | payload: add_prefix(data), metadata: metadata}}] │ ~ │ └─ lib/depayloader.ex:138:24: Membrane.RTP.H265.Depayloader.action_from_data/3 Generated membrane_rtp_h265_plugin app ==> membrane_rtp_opus_plugin Compiling 3 files (.ex) Generated membrane_rtp_opus_plugin app ==> membrane_rtp_plugin Compiling 69 files (.ex) warning: a struct for Membrane.RTP.TWCCSender.ReceiverRate is expected on struct update: %Membrane.RTP.TWCCSender.ReceiverRate{rr | value: value, packets_received: packets_received} but got type: dynamic() where "rr" was given the type: # type: dynamic() # from: lib/membrane/rtp/twcc_sender/receiver_rate.ex:45:18 rr when defining the variable "rr", you must also pattern match on "%Membrane.RTP.TWCCSender.ReceiverRate{}". hint: given pattern matching is enough to catch typing errors, you may optionally convert the struct update into a map update. For example, instead of: user = some_function() %User{user | name: "John Doe"} it is enough to write: %User{} = user = some_function() %{user | name: "John Doe"} typing violation found at: │ 60 │ %__MODULE__{rr | value: value, packets_received: packets_received} │ ~ │ └─ lib/membrane/rtp/twcc_sender/receiver_rate.ex:60:5: Membrane.RTP.TWCCSender.ReceiverRate.do_update/2 warning: a struct for Membrane.RTP.TWCCSender.CongestionControl is expected on struct update: %Membrane.RTP.TWCCSender.CongestionControl{ cc | m_hat: m_hat, var_v_hat: var_v_hat, e: e, last_receive_rates: Enum.take(last_receive_rates, 25), del_var_th: del_var_th } but got type: dynamic() where "cc" was given the type: # type: dynamic() # from: lib/membrane/rtp/twcc_sender/congestion_control.ex:125:23 cc when defining the variable "cc", you must also pattern match on "%Membrane.RTP.TWCCSender.CongestionControl{}". hint: given pattern matching is enough to catch typing errors, you may optionally convert the struct update into a map update. For example, instead of: user = some_function() %User{user | name: "John Doe"} it is enough to write: %User{} = user = some_function() %{user | name: "John Doe"} typing violation found at: │ 167 │ cc = %__MODULE__{ │ ~ │ └─ lib/membrane/rtp/twcc_sender/congestion_control.ex:167:10: Membrane.RTP.TWCCSender.CongestionControl.update_metrics/3 warning: a struct for Membrane.RTP.TWCCSender.CongestionControl is expected on struct update: %Membrane.RTP.TWCCSender.CongestionControl{cc | underuse_start_ts: nil, overuse_start_ts: nil} but got type: dynamic() where "cc" was given the type: # type: dynamic() # from: lib/membrane/rtp/twcc_sender/congestion_control.ex:213:20 cc when defining the variable "cc", you must also pattern match on "%Membrane.RTP.TWCCSender.CongestionControl{}". hint: given pattern matching is enough to catch typing errors, you may optionally convert the struct update into a map update. For example, instead of: user = some_function() %User{user | name: "John Doe"} it is enough to write: %User{} = user = some_function() %{user | name: "John Doe"} typing violation found at: │ 214 │ do: {:normal, %__MODULE__{cc | underuse_start_ts: nil, overuse_start_ts: nil}} │ ~ │ └─ lib/membrane/rtp/twcc_sender/congestion_control.ex:214:19: Membrane.RTP.TWCCSender.CongestionControl.make_signal/2 warning: a struct for Membrane.RTP.TWCCSender.CongestionControl is expected on struct update: %Membrane.RTP.TWCCSender.CongestionControl{cc | a_hat: a_hat, last_bandwidth_increase_ts: now} but got type: dynamic() where "cc" was given the type: # type: dynamic() # from: lib/membrane/rtp/twcc_sender/congestion_control.ex:272:36 cc when defining the variable "cc", you must also pattern match on "%Membrane.RTP.TWCCSender.CongestionControl{}". hint: given pattern matching is enough to catch typing errors, you may optionally convert the struct update into a map update. For example, instead of: user = some_function() %User{user | name: "John Doe"} it is enough to write: %User{} = user = some_function() %{user | name: "John Doe"} typing violation found at: │ 297 │ %__MODULE__{cc | a_hat: a_hat, last_bandwidth_increase_ts: now} │ ~ │ └─ lib/membrane/rtp/twcc_sender/congestion_control.ex:297:5: Membrane.RTP.TWCCSender.CongestionControl.increase_receiver_bandwidth/3 warning: a struct for Membrane.RTP.TWCCSender.CongestionControl is expected on struct update: %Membrane.RTP.TWCCSender.CongestionControl{ cc | a_hat: 0.85 * cc.r_hat.value, decrease_r_hats: Enum.take([cc.r_hat | cc.decrease_r_hats], 25) } but got type: dynamic() where "cc" was given the type: # type: dynamic() # from: lib/membrane/rtp/twcc_sender/congestion_control.ex:300:36 cc when defining the variable "cc", you must also pattern match on "%Membrane.RTP.TWCCSender.CongestionControl{}". hint: given pattern matching is enough to catch typing errors, you may optionally convert the struct update into a map update. For example, instead of: user = some_function() %User{user | name: "John Doe"} it is enough to write: %User{} = user = some_function() %{user | name: "John Doe"} typing violation found at: │ 301 │ %__MODULE__{ │ ~ │ └─ lib/membrane/rtp/twcc_sender/congestion_control.ex:301:5: Membrane.RTP.TWCCSender.CongestionControl.decrease_receiver_bandwidth/1 warning: a struct for Membrane.RTP.TWCCReceiver.State is expected on struct update: %Membrane.RTP.TWCCReceiver.State{ state | buffered_actions: Map.update(state.buffered_actions, pad, actions, &Qex.join(&1, actions)) } but got type: dynamic() where "state" was given the type: # type: dynamic() # from: lib/membrane/rtp/twcc_receiver.ex:182:37 state when defining the variable "state", you must also pattern match on "%Membrane.RTP.TWCCReceiver.State{}". hint: given pattern matching is enough to catch typing errors, you may optionally convert the struct update into a map update. For example, instead of: user = some_function() %User{user | name: "John Doe"} it is enough to write: %User{} = user = some_function() %{user | name: "John Doe"} typing violation found at: │ 185 │ %State{ │ ~ │ └─ lib/membrane/rtp/twcc_receiver.ex:185:5: Membrane.RTP.TWCCReceiver.buffer_actions/3 warning: a struct for Membrane.RTP.SessionBin.State is expected on struct update: %Membrane.RTP.SessionBin.State{state | awaiting_rtx_links: awaiting_rtx_links} but got type: dynamic() where "state" was given the type: # type: dynamic() # from: lib/membrane/rtp/session_bin.ex:453:28 {twcc_children, state} = maybe_spawn_twcc_receiver(maybe_twcc, ctx, state) when defining the variable "state", you must also pattern match on "%Membrane.RTP.SessionBin.State{}". hint: given pattern matching is enough to catch typing errors, you may optionally convert the struct update into a map update. For example, instead of: user = some_function() %User{user | name: "John Doe"} it is enough to write: %User{} = user = some_function() %{user | name: "John Doe"} typing violation found at: │ 479 │ state = %State{state | awaiting_rtx_links: awaiting_rtx_links} │ ~ │ └─ lib/membrane/rtp/session_bin.ex:479:13: Membrane.RTP.SessionBin.handle_pad_added/3 warning: a struct for Membrane.RTP.SSRCRouter.State is expected on struct update: %Membrane.RTP.SSRCRouter.State{state | input_pads: new_pads} but got type: dynamic() where "state" was given the type: # type: dynamic() # from: lib/membrane/rtp/ssrc_router.ex:131:60 state when defining the variable "state", you must also pattern match on "%Membrane.RTP.SSRCRouter.State{}". hint: given pattern matching is enough to catch typing errors, you may optionally convert the struct update into a map update. For example, instead of: user = some_function() %User{user | name: "John Doe"} it is enough to write: %User{} = user = some_function() %{user | name: "John Doe"} typing violation found at: │ 137 │ {[], %State{state | input_pads: new_pads}} │ ~ │ └─ lib/membrane/rtp/ssrc_router.ex:137:10: Membrane.RTP.SSRCRouter.handle_pad_removed/3 warning: a struct for Membrane.RTP.InboundPacketTracker.State is expected on struct update: %Membrane.RTP.InboundPacketTracker.State{ state | expected_prior: expected, received_prior: received, lost: total_lost, fraction_lost: fraction_lost } but got type: dynamic() where "state" was given the type: # type: dynamic() # from: lib/membrane/rtp/inbound_packet_tracker.ex:110:71 state when defining the variable "state", you must also pattern match on "%Membrane.RTP.InboundPacketTracker.State{}". hint: given pattern matching is enough to catch typing errors, you may optionally convert the struct update into a map update. For example, instead of: user = some_function() %User{user | name: "John Doe"} it is enough to write: %User{} = user = some_function() %{user | name: "John Doe"} typing violation found at: │ 142 │ state = %State{ │ ~ │ └─ lib/membrane/rtp/inbound_packet_tracker.ex:142:13: Membrane.RTP.InboundPacketTracker.handle_event/4 warning: a struct for Membrane.RTP.InboundPacketTracker.State is expected on struct update: %Membrane.RTP.InboundPacketTracker.State{state | jitter: jitter, transit: transit} but got type: dynamic() where "state" was given the type: # type: dynamic() # from: lib/membrane/rtp/inbound_packet_tracker.ex:184:22 state when defining the variable "state", you must also pattern match on "%Membrane.RTP.InboundPacketTracker.State{}". hint: given pattern matching is enough to catch typing errors, you may optionally convert the struct update into a map update. For example, instead of: user = some_function() %User{user | name: "John Doe"} it is enough to write: %User{} = user = some_function() %{user | name: "John Doe"} typing violation found at: │ 203 │ %State{state | jitter: jitter, transit: transit} │ ~ │ └─ lib/membrane/rtp/inbound_packet_tracker.ex:203:5: Membrane.RTP.InboundPacketTracker.update_jitter/2 warning: a struct for Membrane.Buffer is expected on struct update: %Membrane.Buffer{ buffer | payload: raw_packet, metadata: Map.put(buffer.metadata, :rtp, %{packet | payload: <<>>}) } but got type: dynamic() where "buffer" was given the type: # type: dynamic() # from: lib/membrane/rtp/muxer.ex:180:54 buffer when defining the variable "buffer", you must also pattern match on "%Membrane.Buffer{}". hint: given pattern matching is enough to catch typing errors, you may optionally convert the struct update into a map update. For example, instead of: user = some_function() %User{user | name: "John Doe"} it is enough to write: %User{} = user = some_function() %{user | name: "John Doe"} typing violation found at: │ 214 │ buffer = %Membrane.Buffer{ │ ~ │ └─ lib/membrane/rtp/muxer.ex:214:20: Membrane.RTP.Muxer.handle_buffer/4 warning: a struct for Membrane.RTP.JitterBuffer.BufferStore is expected on struct update: %Membrane.RTP.JitterBuffer.BufferStore{store | flush_index: 65536 - 1} but got type: dynamic() where "store" was given the type: # type: dynamic() # from: lib/membrane/rtp/jitter_buffer/buffer_store.ex:144:11 store = add_record(store, Membrane.RTP.JitterBuffer.Record.new(buffer, 65536), :next) when defining the variable "store", you must also pattern match on "%Membrane.RTP.JitterBuffer.BufferStore{}". hint: given pattern matching is enough to catch typing errors, you may optionally convert the struct update into a map update. For example, instead of: user = some_function() %User{user | name: "John Doe"} it is enough to write: %User{} = user = some_function() %{user | name: "John Doe"} typing violation found at: │ 145 │ {:ok, %__MODULE__{store | flush_index: @seq_number_limit - 1}} │ ~ │ └─ lib/membrane/rtp/jitter_buffer/buffer_store.ex:145:11: Membrane.RTP.JitterBuffer.BufferStore.do_insert_buffer/3 warning: a struct for Membrane.RTP.JitterBuffer.BufferStore is expected on struct update: %Membrane.RTP.JitterBuffer.BufferStore{store | flush_index: seq_num - 1} but got type: dynamic() where "store" was given the type: # type: dynamic() # from: lib/membrane/rtp/jitter_buffer/buffer_store.ex:149:11 store = add_record(store, Membrane.RTP.JitterBuffer.Record.new(buffer, seq_num), :current) when defining the variable "store", you must also pattern match on "%Membrane.RTP.JitterBuffer.BufferStore{}". hint: given pattern matching is enough to catch typing errors, you may optionally convert the struct update into a map update. For example, instead of: user = some_function() %User{user | name: "John Doe"} it is enough to write: %User{} = user = some_function() %{user | name: "John Doe"} typing violation found at: │ 150 │ {:ok, %__MODULE__{store | flush_index: seq_num - 1}} │ ~ │ └─ lib/membrane/rtp/jitter_buffer/buffer_store.ex:150:11: Membrane.RTP.JitterBuffer.BufferStore.do_insert_buffer/3 warning: a struct for Membrane.RTP.JitterBuffer.BufferStore is expected on struct update: %Membrane.RTP.JitterBuffer.BufferStore{store | rollover_count: roc + 1} but got type: dynamic(%{..., rollover_count: term()}) where "store" was given the type: # type: dynamic(%{..., rollover_count: term()}) # from: lib/membrane/rtp/jitter_buffer/buffer_store.ex:224:42 %{rollover_count: roc} = store when defining the variable "store", you must also pattern match on "%Membrane.RTP.JitterBuffer.BufferStore{}". hint: given pattern matching is enough to catch typing errors, you may optionally convert the struct update into a map update. For example, instead of: user = some_function() %User{user | name: "John Doe"} it is enough to write: %User{} = user = some_function() %{user | name: "John Doe"} typing violation found at: │ 225 │ do: %__MODULE__{store | rollover_count: roc + 1} │ ~ │ └─ lib/membrane/rtp/jitter_buffer/buffer_store.ex:225:9: Membrane.RTP.JitterBuffer.BufferStore.update_roc/2 warning: a struct for Membrane.RTP.Demuxer.JitterBuffer.State is expected on struct update: %Membrane.RTP.Demuxer.JitterBuffer.State{ jitter_buffer_state | pad: pad, clock_rate: clock_rate, latency: pad_options.jitter_buffer_latency, initial_latency_waiting: initial_latency_left > 0 } but got type: dynamic() where "jitter_buffer_state" was given the type: # type: dynamic() # from: lib/membrane/rtp/demuxer/jitter_buffer.ex:66:18 jitter_buffer_state when defining the variable "jitter_buffer_state", you must also pattern match on "%Membrane.RTP.Demuxer.JitterBuffer.State{}". hint: given pattern matching is enough to catch typing errors, you may optionally convert the struct update into a map update. For example, instead of: user = some_function() %User{user | name: "John Doe"} it is enough to write: %User{} = user = some_function() %{user | name: "John Doe"} typing violation found at: │ 87 │ %State{ │ ~ │ └─ lib/membrane/rtp/demuxer/jitter_buffer.ex:87:5: Membrane.RTP.Demuxer.JitterBuffer.initialize/4 warning: a struct for Membrane.RTP.Demuxer.JitterBuffer.State is expected on struct update: %Membrane.RTP.Demuxer.JitterBuffer.State{jitter_buffer_state | max_latency_timer: nil} but got type: dynamic() where "jitter_buffer_state" was given the type: # type: dynamic() # from: lib/membrane/rtp/demuxer/jitter_buffer.ex:97:29 jitter_buffer_state when defining the variable "jitter_buffer_state", you must also pattern match on "%Membrane.RTP.Demuxer.JitterBuffer.State{}". hint: given pattern matching is enough to catch typing errors, you may optionally convert the struct update into a map update. For example, instead of: user = some_function() %User{user | name: "John Doe"} it is enough to write: %User{} = user = some_function() %{user | name: "John Doe"} typing violation found at: │ 98 │ %State{jitter_buffer_state | max_latency_timer: nil} │ ~ │ └─ lib/membrane/rtp/demuxer/jitter_buffer.ex:98:5: Membrane.RTP.Demuxer.JitterBuffer.latency_timer_expired/1 warning: a struct for Membrane.RTP.Demuxer.JitterBuffer.State is expected on struct update: %Membrane.RTP.Demuxer.JitterBuffer.State{jitter_buffer_state | initial_latency_waiting: false} but got type: dynamic() where "jitter_buffer_state" was given the type: # type: dynamic() # from: lib/membrane/rtp/demuxer/jitter_buffer.ex:102:30 jitter_buffer_state when defining the variable "jitter_buffer_state", you must also pattern match on "%Membrane.RTP.Demuxer.JitterBuffer.State{}". hint: given pattern matching is enough to catch typing errors, you may optionally convert the struct update into a map update. For example, instead of: user = some_function() %User{user | name: "John Doe"} it is enough to write: %User{} = user = some_function() %{user | name: "John Doe"} typing violation found at: │ 103 │ %State{jitter_buffer_state | initial_latency_waiting: false} │ ~ │ └─ lib/membrane/rtp/demuxer/jitter_buffer.ex:103:5: Membrane.RTP.Demuxer.JitterBuffer.initial_latency_passed/1 warning: a struct for Membrane.RTP.Demuxer.JitterBuffer.State is expected on struct update: %Membrane.RTP.Demuxer.JitterBuffer.State{jitter_buffer_state | buffer_store: buffer_store} but got type: dynamic() where "jitter_buffer_state" was given the type: # type: dynamic() # from: lib/membrane/rtp/demuxer/jitter_buffer.ex:107:21 jitter_buffer_state when defining the variable "jitter_buffer_state", you must also pattern match on "%Membrane.RTP.Demuxer.JitterBuffer.State{}". hint: given pattern matching is enough to catch typing errors, you may optionally convert the struct update into a map update. For example, instead of: user = some_function() %User{user | name: "John Doe"} it is enough to write: %User{} = user = some_function() %{user | name: "John Doe"} typing violation found at: │ 110 │ %State{jitter_buffer_state | buffer_store: buffer_store} │ ~ │ └─ lib/membrane/rtp/demuxer/jitter_buffer.ex:110:9: Membrane.RTP.Demuxer.JitterBuffer.insert_buffer/2 warning: a struct for Membrane.RTP.JitterBuffer.State is expected on struct update: %Membrane.RTP.JitterBuffer.State{ state | store: %Membrane.RTP.JitterBuffer.BufferStore{ flush_index: nil, heap: %{ __struct__: Heap, comparator: &Membrane.RTP.JitterBuffer.Record.rtp_comparator/2, data: nil, size: 0 }, highest_incoming_index: nil, rollover_count: 0, set: %{__struct__: MapSet, map: %{}} } } but got type: dynamic() where "state" was given the type: # type: dynamic() # from: lib/membrane/rtp/jitter_buffer.ex:77:22 {actions, state} = Enum.flat_map_reduce( Membrane.RTP.JitterBuffer.BufferStore.dump(store), state, &record_to_actions/2 ) when defining the variable "state", you must also pattern match on "%Membrane.RTP.JitterBuffer.State{}". hint: given pattern matching is enough to catch typing errors, you may optionally convert the struct update into a map update. For example, instead of: user = some_function() %User{user | name: "John Doe"} it is enough to write: %User{} = user = some_function() %{user | name: "John Doe"} typing violation found at: │ 82 │ {actions ++ [end_of_stream: :output], %State{state | store: %BufferStore{}}} │ ~ │ └─ lib/membrane/rtp/jitter_buffer.ex:82:43: Membrane.RTP.JitterBuffer.handle_end_of_stream/3 warning: a struct for Membrane.RTP.Demuxer.JitterBuffer.State is expected on struct update: %Membrane.RTP.Demuxer.JitterBuffer.State{jitter_buffer_state | buffer_store: buffer_store} but got type: dynamic() where "jitter_buffer_state" was given the type: # type: dynamic() # from: lib/membrane/rtp/demuxer/jitter_buffer.ex:119:26 jitter_buffer_state when defining the variable "jitter_buffer_state", you must also pattern match on "%Membrane.RTP.Demuxer.JitterBuffer.State{}". hint: given pattern matching is enough to catch typing errors, you may optionally convert the struct update into a map update. For example, instead of: user = some_function() %User{user | name: "John Doe"} it is enough to write: %User{} = user = some_function() %{user | name: "John Doe"} typing violation found at: │ 130 │ jitter_buffer_state = %State{jitter_buffer_state | buffer_store: buffer_store} │ ~ │ └─ lib/membrane/rtp/demuxer/jitter_buffer.ex:130:29: Membrane.RTP.Demuxer.JitterBuffer.get_output_actions/1 warning: a struct for Membrane.RTP.JitterBuffer.State is expected on struct update: %Membrane.RTP.JitterBuffer.State{state | waiting?: false} but got type: dynamic() where "state" was given the type: # type: dynamic() # from: lib/membrane/rtp/jitter_buffer.ex:117:54 state when defining the variable "state", you must also pattern match on "%Membrane.RTP.JitterBuffer.State{}". hint: given pattern matching is enough to catch typing errors, you may optionally convert the struct update into a map update. For example, instead of: user = some_function() %User{user | name: "John Doe"} it is enough to write: %User{} = user = some_function() %{user | name: "John Doe"} typing violation found at: │ 118 │ state = %State{state | waiting?: false} │ ~ │ └─ lib/membrane/rtp/jitter_buffer.ex:118:13: Membrane.RTP.JitterBuffer.handle_info/3 warning: a struct for Membrane.RTP.JitterBuffer.State is expected on struct update: %Membrane.RTP.JitterBuffer.State{state | max_latency_timer: nil} but got type: dynamic() where "state" was given the type: # type: dynamic() # from: lib/membrane/rtp/jitter_buffer.ex:123:44 state when defining the variable "state", you must also pattern match on "%Membrane.RTP.JitterBuffer.State{}". hint: given pattern matching is enough to catch typing errors, you may optionally convert the struct update into a map update. For example, instead of: user = some_function() %User{user | name: "John Doe"} it is enough to write: %User{} = user = some_function() %{user | name: "John Doe"} typing violation found at: │ 124 │ state = %State{state | max_latency_timer: nil} │ ~ │ └─ lib/membrane/rtp/jitter_buffer.ex:124:13: Membrane.RTP.JitterBuffer.handle_info/3 warning: a struct for Membrane.Buffer is expected on struct update: %Membrane.Buffer{record.buffer | pts: timestamp} but got type: dynamic() where "record" was given the type: # type: dynamic() # from: lib/membrane/rtp/demuxer/jitter_buffer.ex:192:25 record you must assign "record.buffer" to variable and pattern match on "%Membrane.Buffer{}". hint: given pattern matching is enough to catch typing errors, you may optionally convert the struct update into a map update. For example, instead of: user = some_function() %User{user | name: "John Doe"} it is enough to write: %User{} = user = some_function() %{user | name: "John Doe"} typing violation found at: │ 212 │ buffer = %Membrane.Buffer{record.buffer | pts: timestamp} │ ~ │ └─ lib/membrane/rtp/demuxer/jitter_buffer.ex:212:14: Membrane.RTP.Demuxer.JitterBuffer.record_to_action/2 warning: a struct for Membrane.Buffer is expected on struct update: %Membrane.Buffer{buffer | pts: timestamp} but got type: dynamic() where "buffer" was given the type: # type: dynamic() # from: lib/membrane/rtp/jitter_buffer.ex:165:26 %Membrane.RTP.JitterBuffer.Record{buffer: buffer} when defining the variable "buffer", you must also pattern match on "%Membrane.Buffer{}". hint: given pattern matching is enough to catch typing errors, you may optionally convert the struct update into a map update. For example, instead of: user = some_function() %User{user | name: "John Doe"} it is enough to write: %User{} = user = some_function() %{user | name: "John Doe"} typing violation found at: │ 183 │ buffer = %Membrane.Buffer{buffer | pts: timestamp} │ ~ │ └─ lib/membrane/rtp/jitter_buffer.ex:183:14: Membrane.RTP.JitterBuffer.record_to_actions/2 warning: a struct for Membrane.Buffer is expected on struct update: %Membrane.Buffer{buffer | metadata: Map.put(metadata, :rtp, header), payload: buffer.payload} but got type: dynamic() where "buffer" was given the type: # type: dynamic() # from: lib/membrane/rtp/header_generator.ex:66:29 buffer when defining the variable "buffer", you must also pattern match on "%Membrane.Buffer{}". hint: given pattern matching is enough to catch typing errors, you may optionally convert the struct update into a map update. For example, instead of: user = some_function() %User{user | name: "John Doe"} it is enough to write: %User{} = user = some_function() %{user | name: "John Doe"} typing violation found at: │ 88 │ buffer = %Membrane.Buffer{ │ ~ │ └─ lib/membrane/rtp/header_generator.ex:88:14: Membrane.RTP.HeaderGenerator.handle_buffer/4 warning: a struct for Membrane.RTP.Demuxer.State.StreamState is expected on struct update: %Membrane.RTP.Demuxer.State.StreamState{stream_state | jitter_buffer_state: jitter_buffer_state} but got type: dynamic(%{ ..., jitter_buffer_state: %{ ..., clock_rate: term(), initial_latency_waiting: boolean(), latency: term(), pad: term() }, pad: term(), pad_match_timer: nil, phase: :bound_with_pad }) where "stream_state" was given the type: # type: dynamic(%{ ..., jitter_buffer_state: %{ ..., clock_rate: term(), initial_latency_waiting: boolean(), latency: term(), pad: term() }, pad: term(), pad_match_timer: nil, phase: :bound_with_pad }) # from: lib/membrane/rtp/demuxer.ex:218:46 {stream_format_action, stream_state} = bind_pad_with_stream(pad, ctx.pad_options, stream_state, state.payload_type_mapping) when defining the variable "stream_state", you must also pattern match on "%Membrane.RTP.Demuxer.State.StreamState{}". hint: given pattern matching is enough to catch typing errors, you may optionally convert the struct update into a map update. For example, instead of: user = some_function() %User{user | name: "John Doe"} it is enough to write: %User{} = user = some_function() %{user | name: "John Doe"} typing violation found at: │ 231 │ stream_state = %State.StreamState{stream_state | jitter_buffer_state: jitter_buffer_state} │ ~ │ └─ lib/membrane/rtp/demuxer.ex:231:24: Membrane.RTP.Demuxer.handle_pad_added/3 warning: a struct for Membrane.RTP.Demuxer.State.StreamState is expected on struct update: %Membrane.RTP.Demuxer.State.StreamState{ stream_state | phase: :bound_with_pad, pad: pad, pad_match_timer: nil, jitter_buffer_state: jitter_buffer_state } but got type: dynamic() where "stream_state" was given the type: # type: dynamic() # from: lib/membrane/rtp/demuxer.ex:453:47 stream_state when defining the variable "stream_state", you must also pattern match on "%Membrane.RTP.Demuxer.State.StreamState{}". hint: given pattern matching is enough to catch typing errors, you may optionally convert the struct update into a map update. For example, instead of: user = some_function() %User{user | name: "John Doe"} it is enough to write: %User{} = user = some_function() %{user | name: "John Doe"} typing violation found at: │ 465 │ %State.StreamState{ │ ~ │ └─ lib/membrane/rtp/demuxer.ex:465:7: Membrane.RTP.Demuxer.bind_pad_with_stream/4 Generated membrane_rtp_plugin app ==> membrane_rtsp_plugin Compiling 3 files (.ex) Generated membrane_rtsp_plugin app ==> property_table Compiling 8 files (.ex) Generated property_table app ==> nerves_uevent CC uevent.o LD uevent Compiling 5 files (.ex) Generated nerves_uevent app ==> nerves_runtime Compiling 14 files (.ex) Generated nerves_runtime app ==> toolshed Compiling 5 files (.ex) Generated toolshed app ==> nerves_compatibility_test Compiling 2 files (.ex) Generated nerves_compatibility_test app |nerves| Building OTP Release... * [Nerves] validating vm.args * skipping runtime configuration (config/runtime.exs not found) * creating _build/x86_64/rel/nerves_compatibility_test/releases/0.1.0/vm.args Updating base firmware image with Erlang release... Copying rootfs_overlay: /work/proj/_build/x86_64/nerves/rootfs_overlay Copying rootfs_overlay: /work/proj/rootfs_overlay Building /work/proj/_build/x86_64/nerves/images/nerves_compatibility_test.fw... Firmware UUID: bronze-drip (21337880-069f-547b-e8ae-d17607741525) Firmware built successfully! 🎉 Now you may install it to a MicroSD card using `mix burn` or upload it to a device with `mix upload` or `mix firmware.gen.script`+`./upload.sh`. * Cleaning membrane_rtsp_plugin ==> nerves ==> nerves_compatibility_test Nerves environment MIX_TARGET: x86_64 MIX_ENV: prod ==> membrane_rtsp_plugin Compiling 3 files (.ex) Generated membrane_rtsp_plugin app ==> nerves_compatibility_test Generated nerves_compatibility_test app |nerves| Building OTP Release... * [Nerves] validating vm.args * skipping runtime configuration (config/runtime.exs not found) * creating _build/x86_64/rel/nerves_compatibility_test/releases/0.1.0/vm.args Updating base firmware image with Erlang release... Copying rootfs_overlay: /work/proj/_build/x86_64/nerves/rootfs_overlay Copying rootfs_overlay: /work/proj/rootfs_overlay Building /work/proj/_build/x86_64/nerves/images/nerves_compatibility_test.fw... Firmware UUID: supreme-raw (e0bef1dd-9593-5135-5c6e-9ec11b802673) Firmware built successfully! 🎉 Now you may install it to a MicroSD card using `mix burn` or upload it to a device with `mix upload` or `mix firmware.gen.script`+`./upload.sh`.