Repository: bluenviron/mediamtx
Branch: main
Commit: a82e0c7a9d52
Files: 473
Total size: 1.9 MB
Directory structure:
gitextract__vy29lq8/
├── .dockerignore
├── .github/
│ ├── DISCUSSION_TEMPLATE/
│ │ └── questions.yml
│ ├── ISSUE_TEMPLATE/
│ │ ├── bug.yml
│ │ ├── config.yml
│ │ └── feature.yml
│ ├── dependabot.yml
│ └── workflows/
│ ├── lint.yml
│ ├── nightly_binaries.yml
│ ├── release.yml
│ └── test.yml
├── .gitignore
├── .golangci.yml
├── LICENSE
├── Makefile
├── README.md
├── SECURITY.md
├── api/
│ ├── .redocly.yaml
│ └── openapi.yaml
├── docker/
│ ├── ffmpeg-rpi.Dockerfile
│ ├── ffmpeg.Dockerfile
│ ├── rpi.Dockerfile
│ └── standard.Dockerfile
├── docs/
│ ├── 1-kickoff/
│ │ ├── 1-introduction.md
│ │ ├── 2-install.md
│ │ ├── 3-upgrade.md
│ │ ├── 4-basic-usage.md
│ │ └── index.md
│ ├── 2-publish/
│ │ ├── 01-overview.md
│ │ ├── 02-srt-clients.md
│ │ ├── 03-srt-cameras-and-servers.md
│ │ ├── 04-webrtc-clients.md
│ │ ├── 05-webrtc-servers.md
│ │ ├── 06-rtsp-clients.md
│ │ ├── 07-rtsp-cameras-and-servers.md
│ │ ├── 08-rtmp-clients.md
│ │ ├── 09-rtmp-cameras-and-servers.md
│ │ ├── 10-hls-cameras-and-servers.md
│ │ ├── 11-mpeg-ts.md
│ │ ├── 12-rtp.md
│ │ ├── 13-raspberry-pi-cameras.md
│ │ ├── 14-generic-webcams.md
│ │ ├── 15-ffmpeg.md
│ │ ├── 16-gstreamer.md
│ │ ├── 17-obs-studio.md
│ │ ├── 18-python-opencv.md
│ │ ├── 19-golang.md
│ │ ├── 20-unity.md
│ │ ├── 21-web-browsers.md
│ │ └── index.md
│ ├── 3-read/
│ │ ├── 01-overview.md
│ │ ├── 02-srt.md
│ │ ├── 03-webrtc.md
│ │ ├── 04-rtsp.md
│ │ ├── 05-rtmp.md
│ │ ├── 06-hls.md
│ │ ├── 07-ffmpeg.md
│ │ ├── 08-gstreamer.md
│ │ ├── 09-vlc.md
│ │ ├── 10-obs-studio.md
│ │ ├── 11-python-opencv.md
│ │ ├── 12-golang.md
│ │ ├── 13-unity.md
│ │ ├── 14-web-browsers.md
│ │ └── index.md
│ ├── 4-other/
│ │ ├── 02-configuration.md
│ │ ├── 03-authentication.md
│ │ ├── 04-remuxing-reencoding-compression.md
│ │ ├── 05-always-available.md
│ │ ├── 06-record.md
│ │ ├── 07-playback.md
│ │ ├── 08-forward.md
│ │ ├── 09-proxy.md
│ │ ├── 10-extract-snapshots.md
│ │ ├── 11-on-demand-publishing.md
│ │ ├── 12-absolute-timestamps.md
│ │ ├── 13-expose-the-server-in-a-subfolder.md
│ │ ├── 14-embed-streams-in-a-website.md
│ │ ├── 15-start-on-boot.md
│ │ ├── 16-logging.md
│ │ ├── 17-hooks.md
│ │ ├── 18-control-api.md
│ │ ├── 19-metrics.md
│ │ ├── 20-performance.md
│ │ ├── 21-srt-specific-features.md
│ │ ├── 22-webrtc-specific-features.md
│ │ ├── 23-rtsp-specific-features.md
│ │ ├── 24-rtmp-specific-features.md
│ │ ├── 25-decrease-packet-loss.md
│ │ └── index.md
│ ├── 5-references/
│ │ ├── 1-configuration-file.md
│ │ ├── 2-control-api.md
│ │ └── index.md
│ ├── 6-misc/
│ │ ├── 1-compile.md
│ │ ├── 2-license.md
│ │ ├── 3-security.md
│ │ ├── 4-specifications.md
│ │ ├── 5-related-projects.md
│ │ └── index.md
│ └── redirects.yaml
├── go.mod
├── go.sum
├── internal/
│ ├── api/
│ │ ├── api.go
│ │ ├── api_config_global.go
│ │ ├── api_config_global_test.go
│ │ ├── api_config_pathdefaults.go
│ │ ├── api_config_pathdefaults_test.go
│ │ ├── api_config_paths.go
│ │ ├── api_config_paths_test.go
│ │ ├── api_hls.go
│ │ ├── api_hls_test.go
│ │ ├── api_paths.go
│ │ ├── api_paths_test.go
│ │ ├── api_recordings.go
│ │ ├── api_recordings_test.go
│ │ ├── api_rtmp.go
│ │ ├── api_rtmp_test.go
│ │ ├── api_rtsp.go
│ │ ├── api_rtsp_test.go
│ │ ├── api_srt.go
│ │ ├── api_srt_test.go
│ │ ├── api_test.go
│ │ ├── api_webrtc.go
│ │ ├── api_webrtc_test.go
│ │ ├── paginate.go
│ │ ├── paginate_test.go
│ │ └── testdata/
│ │ └── fuzz/
│ │ └── FuzzPaginate/
│ │ ├── 23731da0f18d31d0
│ │ ├── 34523a772174e26e
│ │ └── 85649d45641911d0
│ ├── auth/
│ │ ├── credentials.go
│ │ ├── error.go
│ │ ├── jwt_claims.go
│ │ ├── manager.go
│ │ ├── manager_test.go
│ │ └── request.go
│ ├── certloader/
│ │ ├── certloader.go
│ │ └── certloader_test.go
│ ├── conf/
│ │ ├── always_available_track.go
│ │ ├── always_available_track_codec.go
│ │ ├── auth_action.go
│ │ ├── auth_internal_user.go
│ │ ├── auth_internal_user_permission.go
│ │ ├── auth_method.go
│ │ ├── conf.go
│ │ ├── conf_test.go
│ │ ├── credential.go
│ │ ├── credential_test.go
│ │ ├── decrypt/
│ │ │ └── decrypt.go
│ │ ├── duration.go
│ │ ├── duration_test.go
│ │ ├── encryption.go
│ │ ├── env/
│ │ │ ├── env.go
│ │ │ └── env_test.go
│ │ ├── global.go
│ │ ├── hls_variant.go
│ │ ├── ip_network.go
│ │ ├── ip_networks.go
│ │ ├── jsonwrapper/
│ │ │ ├── testdata/
│ │ │ │ └── fuzz/
│ │ │ │ └── FuzzUnmarshal/
│ │ │ │ ├── 297c43aee5d30530
│ │ │ │ └── 7f71a2d116d5afde
│ │ │ ├── unmarshal.go
│ │ │ └── unmarshal_test.go
│ │ ├── log_destination.go
│ │ ├── log_destinations.go
│ │ ├── log_level.go
│ │ ├── optional_global.go
│ │ ├── optional_path.go
│ │ ├── path.go
│ │ ├── path_test.go
│ │ ├── record_format.go
│ │ ├── rtsp_auth_method.go
│ │ ├── rtsp_auth_methods.go
│ │ ├── rtsp_range_type.go
│ │ ├── rtsp_transport.go
│ │ ├── rtsp_transports.go
│ │ ├── string_size.go
│ │ ├── webrtc_ice_server.go
│ │ └── yamlwrapper/
│ │ ├── testdata/
│ │ │ └── fuzz/
│ │ │ └── FuzzUnmarshal/
│ │ │ ├── 90b5d1b18dd9f8ac
│ │ │ └── dc806ec658c460fc
│ │ ├── unmarshal.go
│ │ └── unmarshal_test.go
│ ├── confwatcher/
│ │ ├── confwatcher.go
│ │ └── confwatcher_test.go
│ ├── core/
│ │ ├── api_test.go
│ │ ├── core.go
│ │ ├── core_test.go
│ │ ├── metrics_test.go
│ │ ├── path.go
│ │ ├── path_manager.go
│ │ ├── path_manager_test.go
│ │ ├── path_test.go
│ │ ├── source_redirect.go
│ │ ├── test_on_demand/
│ │ │ └── main.go
│ │ ├── upgrade.go
│ │ ├── upgrade_disabled.go
│ │ └── versiongetter/
│ │ └── main.go
│ ├── counterdumper/
│ │ ├── dumper.go
│ │ └── dumper_test.go
│ ├── defs/
│ │ ├── api.go
│ │ ├── api_hls.go
│ │ ├── api_path.go
│ │ ├── api_path_track.go
│ │ ├── api_path_track_codec.go
│ │ ├── api_path_track_codec_props.go
│ │ ├── api_path_track_codec_test.go
│ │ ├── api_recording.go
│ │ ├── api_rtmp.go
│ │ ├── api_rtsp.go
│ │ ├── api_srt.go
│ │ ├── api_webrtc.go
│ │ ├── defs.go
│ │ ├── path.go
│ │ ├── path_access_request.go
│ │ ├── publisher.go
│ │ ├── reader.go
│ │ ├── source.go
│ │ └── static_source.go
│ ├── errordumper/
│ │ ├── dumper.go
│ │ └── dumper_test.go
│ ├── externalcmd/
│ │ ├── cmd.go
│ │ ├── cmd_unix.go
│ │ ├── cmd_win.go
│ │ └── pool.go
│ ├── hooks/
│ │ ├── hooks.go
│ │ ├── on_connect.go
│ │ ├── on_demand.go
│ │ ├── on_init.go
│ │ ├── on_read.go
│ │ └── on_ready.go
│ ├── linters/
│ │ ├── conf/
│ │ │ └── conf_test.go
│ │ └── go2api/
│ │ └── go2api_test.go
│ ├── logger/
│ │ ├── destination.go
│ │ ├── destination_file.go
│ │ ├── destination_stdout.go
│ │ ├── destination_syslog.go
│ │ ├── destination_syslog_disabled.go
│ │ ├── level.go
│ │ ├── logger.go
│ │ ├── logger_test.go
│ │ └── writer.go
│ ├── metrics/
│ │ ├── metrics.go
│ │ └── metrics_test.go
│ ├── ntpestimator/
│ │ ├── estimator.go
│ │ └── estimator_test.go
│ ├── packetdumper/
│ │ ├── conn.go
│ │ ├── conn_test.go
│ │ ├── dial_context.go
│ │ ├── listen.go
│ │ ├── listen_packet.go
│ │ ├── listener.go
│ │ ├── packet_conn.go
│ │ └── packet_conn_test.go
│ ├── playback/
│ │ ├── muxer.go
│ │ ├── muxer_fmp4.go
│ │ ├── muxer_mp4.go
│ │ ├── muxer_mp4_test.go
│ │ ├── on_get.go
│ │ ├── on_get_test.go
│ │ ├── on_list.go
│ │ ├── on_list_test.go
│ │ ├── segment_fmp4.go
│ │ ├── segment_fmp4_test.go
│ │ ├── server.go
│ │ └── server_test.go
│ ├── pprof/
│ │ ├── pprof.go
│ │ └── pprof_test.go
│ ├── protocols/
│ │ ├── hls/
│ │ │ ├── from_stream.go
│ │ │ ├── from_stream_test.go
│ │ │ ├── to_stream.go
│ │ │ └── to_stream_test.go
│ │ ├── httpp/
│ │ │ ├── content_type.go
│ │ │ ├── credentials.go
│ │ │ ├── credentials_test.go
│ │ │ ├── handler_exit_on_panic.go
│ │ │ ├── handler_filter_requests.go
│ │ │ ├── handler_filter_requests_test.go
│ │ │ ├── handler_logger.go
│ │ │ ├── handler_origin.go
│ │ │ ├── handler_origin_test.go
│ │ │ ├── handler_server_header.go
│ │ │ ├── handler_tracker.go
│ │ │ ├── handler_tracker_test.go
│ │ │ ├── handler_write_timeout.go
│ │ │ ├── remote_addr.go
│ │ │ ├── server.go
│ │ │ └── server_test.go
│ │ ├── mpegts/
│ │ │ ├── enhanced_reader.go
│ │ │ ├── from_stream.go
│ │ │ ├── from_stream_test.go
│ │ │ ├── to_stream.go
│ │ │ └── to_stream_test.go
│ │ ├── rtmp/
│ │ │ ├── from_stream.go
│ │ │ ├── from_stream_test.go
│ │ │ ├── to_stream.go
│ │ │ └── to_stream_test.go
│ │ ├── rtsp/
│ │ │ ├── credentials.go
│ │ │ ├── credentials_test.go
│ │ │ └── to_stream.go
│ │ ├── tls/
│ │ │ ├── make_config.go
│ │ │ └── make_config_test.go
│ │ ├── udp/
│ │ │ ├── listener.go
│ │ │ ├── listener_test.go
│ │ │ └── params.go
│ │ ├── unix/
│ │ │ ├── listener.go
│ │ │ ├── listener_test.go
│ │ │ └── params.go
│ │ ├── webrtc/
│ │ │ ├── from_stream.go
│ │ │ ├── from_stream_test.go
│ │ │ ├── incoming_track.go
│ │ │ ├── net.go
│ │ │ ├── outgoing_data_channel.go
│ │ │ ├── outgoing_track.go
│ │ │ ├── peer_connection.go
│ │ │ ├── peer_connection_test.go
│ │ │ ├── stats.go
│ │ │ ├── stats_interceptor.go
│ │ │ ├── tcp_mux_wrapper.go
│ │ │ ├── to_stream.go
│ │ │ └── to_stream_test.go
│ │ ├── websocket/
│ │ │ ├── serverconn.go
│ │ │ └── serverconn_test.go
│ │ └── whip/
│ │ ├── client.go
│ │ ├── client_test.go
│ │ ├── ice_fragment.go
│ │ ├── ice_fragment_test.go
│ │ ├── link_header.go
│ │ └── link_header_test.go
│ ├── recordcleaner/
│ │ ├── cleaner.go
│ │ └── cleaner_test.go
│ ├── recorder/
│ │ ├── format.go
│ │ ├── format_fmp4.go
│ │ ├── format_fmp4_part.go
│ │ ├── format_fmp4_segment.go
│ │ ├── format_fmp4_track.go
│ │ ├── format_mpegts.go
│ │ ├── format_mpegts_segment.go
│ │ ├── format_mpegts_track.go
│ │ ├── recorder.go
│ │ ├── recorder_instance.go
│ │ └── recorder_test.go
│ ├── recordstore/
│ │ ├── mp4_boxes.go
│ │ ├── path.go
│ │ ├── path_test.go
│ │ ├── recordstore.go
│ │ ├── segment.go
│ │ └── segment_test.go
│ ├── restrictnetwork/
│ │ └── restrict_network.go
│ ├── rlimit/
│ │ ├── rlimit_unix.go
│ │ └── rlimit_win.go
│ ├── servers/
│ │ ├── hls/
│ │ │ ├── hlsjsdownloader/
│ │ │ │ ├── HASH
│ │ │ │ ├── VERSION
│ │ │ │ └── main.go
│ │ │ ├── http_server.go
│ │ │ ├── index.html
│ │ │ ├── muxer.go
│ │ │ ├── muxer_instance.go
│ │ │ ├── server.go
│ │ │ └── server_test.go
│ │ ├── rtmp/
│ │ │ ├── conn.go
│ │ │ ├── listener.go
│ │ │ ├── server.go
│ │ │ └── server_test.go
│ │ ├── rtsp/
│ │ │ ├── conn.go
│ │ │ ├── mpegts_demuxer.go
│ │ │ ├── server.go
│ │ │ ├── server_test.go
│ │ │ └── session.go
│ │ ├── srt/
│ │ │ ├── conn.go
│ │ │ ├── listener.go
│ │ │ ├── server.go
│ │ │ ├── server_test.go
│ │ │ ├── streamid.go
│ │ │ └── streamid_test.go
│ │ └── webrtc/
│ │ ├── http_server.go
│ │ ├── publish_index.html
│ │ ├── publisher.js
│ │ ├── read_index.html
│ │ ├── reader.js
│ │ ├── server.go
│ │ ├── server_test.go
│ │ └── session.go
│ ├── staticsources/
│ │ ├── handler.go
│ │ ├── hls/
│ │ │ ├── source.go
│ │ │ └── source_test.go
│ │ ├── mpegts/
│ │ │ ├── source.go
│ │ │ └── source_test.go
│ │ ├── rpicamera/
│ │ │ ├── camera_arm32_.go
│ │ │ ├── camera_arm64_.go
│ │ │ ├── camera_arm_.go
│ │ │ ├── camera_other.go
│ │ │ ├── downloader.go
│ │ │ ├── mtxrpicamdownloader/
│ │ │ │ ├── HASH_MTXRPICAM_32_TAR_GZ
│ │ │ │ ├── HASH_MTXRPICAM_64_TAR_GZ
│ │ │ │ ├── VERSION
│ │ │ │ └── main.go
│ │ │ ├── params.go
│ │ │ ├── params_serialize.go
│ │ │ ├── pipe.go
│ │ │ └── source.go
│ │ ├── rtmp/
│ │ │ ├── source.go
│ │ │ └── source_test.go
│ │ ├── rtp/
│ │ │ ├── format.go
│ │ │ ├── media.go
│ │ │ ├── source.go
│ │ │ └── source_test.go
│ │ ├── rtsp/
│ │ │ ├── source.go
│ │ │ └── source_test.go
│ │ ├── srt/
│ │ │ ├── source.go
│ │ │ └── source_test.go
│ │ └── webrtc/
│ │ ├── source.go
│ │ └── source_test.go
│ ├── stream/
│ │ ├── format_updater.go
│ │ ├── offline_sub_stream.go
│ │ ├── offline_sub_stream_track.go
│ │ ├── reader.go
│ │ ├── rtp_decoder.go
│ │ ├── rtp_encoder.go
│ │ ├── stream.go
│ │ ├── stream_alwaysavailable_test.go
│ │ ├── stream_format.go
│ │ ├── stream_media.go
│ │ ├── stream_standard_test.go
│ │ ├── sub_stream.go
│ │ ├── sub_stream_format.go
│ │ ├── sub_stream_media.go
│ │ └── unit_remuxer.go
│ ├── test/
│ │ ├── auth_manager.go
│ │ ├── formats.go
│ │ ├── logger.go
│ │ ├── medias.go
│ │ ├── path_manager.go
│ │ ├── static_source_parent.go
│ │ ├── temp_file.go
│ │ └── tls_cert.go
│ ├── teste2e/
│ │ ├── build_images_test.go
│ │ ├── hls_manager_test.go
│ │ ├── images/
│ │ │ ├── ffmpeg/
│ │ │ │ ├── Dockerfile
│ │ │ │ ├── emptyvideo.mkv
│ │ │ │ ├── emptyvideoaudio.mkv
│ │ │ │ └── start.sh
│ │ │ ├── gstreamer/
│ │ │ │ ├── Dockerfile
│ │ │ │ ├── emptyvideo.mkv
│ │ │ │ ├── exitafterframe.c
│ │ │ │ └── start.sh
│ │ │ └── vlc/
│ │ │ ├── Dockerfile
│ │ │ └── start.sh
│ │ ├── rtsp_server_test.go
│ │ └── tests_test.go
│ └── unit/
│ ├── payload.go
│ ├── payload_ac3.go
│ ├── payload_av1.go
│ ├── payload_g711.go
│ ├── payload_h264.go
│ ├── payload_h265.go
│ ├── payload_klv.go
│ ├── payload_lpcm.go
│ ├── payload_mjpeg.go
│ ├── payload_mpeg1_audio.go
│ ├── payload_mpeg1_video.go
│ ├── payload_mpeg4_audio.go
│ ├── payload_mpeg4_audio_latm.go
│ ├── payload_mpeg4_video.go
│ ├── payload_opus.go
│ ├── payload_vp8.go
│ ├── payload_vp9.go
│ └── unit.go
├── main.go
├── mediamtx.yml
└── scripts/
├── binaries.mk
├── dockerhub.mk
├── format.mk
├── lint.mk
├── test-e2e.mk
├── test.mk
└── winres.json
================================================
FILE CONTENTS
================================================
================================================
FILE: .dockerignore
================================================
# do not add .git, since it is needed to extract the tag
# do not add /binaries, since it is needed by Docker images
/tmp
/coverage*.txt
/api/*.html
/internal/core/VERSION
/internal/servers/hls/hls.min.js
/internal/staticsources/rpicamera/mtxrpicam_*/
================================================
FILE: .github/DISCUSSION_TEMPLATE/questions.yml
================================================
body:
- type: markdown
attributes:
value: |
* Please create a discussion FOR EACH question. Do not ask for multiple questions all at once, otherwise they'll probably never get all answered.
* If you are asking for help because you're having trouble doing something, provide enough informations to replicate the problem. In particular, include in the question:
* MediaMTX version
* precise instructions on how to replicate the problem
* MediaMTX configuration
* MediaMTX logs with setting `logLevel` set to `debug`
* If you are asking for help and you think MediaMTX is misbehaving, open a bug report, NOT a discussion.
- type: textarea
attributes:
label: Question
validations:
required: true
================================================
FILE: .github/ISSUE_TEMPLATE/bug.yml
================================================
name: Bug report
description: Report a bug
body:
- type: markdown
attributes:
value: |
To increase the chance of your bug getting fixed, open an issue FOR EACH bug. Do not report multiple problems in a single issue, otherwise they'll probably never get all fixed.
- type: input
id: version
attributes:
label: Which version are you using?
description: MediaMTX version or commit
validations:
required: true
- type: dropdown
id: os
attributes:
label: Which operating system are you using?
multiple: true
options:
- Linux amd64 standard
- Linux amd64 Docker
- Linux arm64 standard
- Linux arm64 Docker
- Linux arm7 standard
- Linux arm7 Docker
- Linux arm6 standard
- Linux arm6 Docker
- Windows amd64 standard
- Windows amd64 Docker (WSL backend)
- macOS amd64 standard
- macOS amd64 Docker
- Other (please describe)
validations:
required: true
- type: textarea
id: description
attributes:
label: Describe the issue
validations:
required: true
- type: textarea
id: replica
attributes:
label: Describe how to replicate the issue
description: |
The maintainers must be able to REPLICATE your issue to solve it - therefore, describe in a very detailed way how to replicate it.
value: |
1. start the MediaMTX
2. publish with ...
3. read with ...
validations:
required: true
- type: textarea
id: conf
attributes:
label: MediaMTX configuration
description: |
MediaMTX configuration is often required to replicate the issue.
placeholder: Paste the configuration file here
render: yaml
- type: textarea
id: logs
attributes:
label: MediaMTX logs
description: |
MediaMTX logs are often useful to identify the issue. If you think this is the case, set 'logLevel' to 'debug' and attach logs.
placeholder: Paste or drag the log file here
- type: textarea
id: network
attributes:
label: Packet dump
description: |
If the bug arises when using MediaMTX with external hardware or software, the most helpful information you can provide is a packet dump, that can be generated in this way:
1. In mediamtx.yml, set 'dumpPackets' to 'true'
2. Start the server and replicate the issue
3. Stop the server, find the generated .pcapng files in the current directory
4. Attach the pcapng files by dragging them here
placeholder: Attach the pcapng files by dragging them here
================================================
FILE: .github/ISSUE_TEMPLATE/config.yml
================================================
blank_issues_enabled: false
contact_links:
- name: Question
url: https://github.com/bluenviron/mediamtx/discussions/new?category=questions
about: Ask the community for help
================================================
FILE: .github/ISSUE_TEMPLATE/feature.yml
================================================
name: Feature request
description: Share ideas for new features
body:
- type: markdown
attributes:
value: |
Please create a request FOR EACH feature. Do not report multiple features in a single request, otherwise they'll probably never get all implemented.
- type: textarea
id: description
attributes:
label: Describe the feature
validations:
required: true
================================================
FILE: .github/dependabot.yml
================================================
version: 2
updates:
- package-ecosystem: "gomod"
directory: "/"
schedule:
interval: "daily"
- package-ecosystem: "github-actions"
directory: "/"
schedule:
interval: "daily"
================================================
FILE: .github/workflows/lint.yml
================================================
name: lint
on:
push:
branches: [ main ]
pull_request:
branches: [ main ]
jobs:
go:
runs-on: ubuntu-22.04
steps:
- uses: actions/checkout@v6
with:
fetch-depth: 0
- uses: actions/setup-go@v6
with:
go-version: "1.25"
- run: go generate ./...
- uses: golangci/golangci-lint-action@v9
with:
version: v2.11.3
go_mod:
runs-on: ubuntu-22.04
steps:
- uses: actions/checkout@v6
- uses: actions/setup-go@v6
with:
go-version: "1.25"
- run: make lint-go-mod
conf:
runs-on: ubuntu-22.04
steps:
- uses: actions/checkout@v6
- uses: actions/setup-go@v6
with:
go-version: "1.25"
- run: make lint-conf
go2api:
runs-on: ubuntu-22.04
steps:
- uses: actions/checkout@v6
- uses: actions/setup-go@v6
with:
go-version: "1.25"
- run: make lint-go2api
docs:
runs-on: ubuntu-22.04
steps:
- uses: actions/checkout@v6
- run: make lint-docs
api_docs:
runs-on: ubuntu-22.04
steps:
- uses: actions/checkout@v6
- run: make lint-api-docs
================================================
FILE: .github/workflows/nightly_binaries.yml
================================================
name: nightly_binaries
on:
workflow_dispatch:
jobs:
nightly_binaries:
runs-on: ubuntu-22.04
steps:
- uses: actions/checkout@v6
with:
fetch-depth: 0
- run: make binaries
- uses: actions/upload-artifact@v7
with:
name: binaries
path: binaries
================================================
FILE: .github/workflows/release.yml
================================================
name: release
on:
push:
tags:
- 'v*'
permissions:
id-token: write
attestations: write
artifact-metadata: write
contents: write
issues: write
jobs:
binaries:
runs-on: ubuntu-22.04
steps:
- uses: actions/checkout@v6
- run: make binaries
- run: cd binaries && sha256sum -b * > checksums.sha256
- uses: actions/attest@v4
with:
subject-path: '${{ github.workspace }}/binaries/*'
- uses: actions/upload-artifact@v7
with:
name: binaries
path: binaries
github_release:
needs: binaries
runs-on: ubuntu-22.04
steps:
- uses: actions/download-artifact@v8
with:
name: binaries
path: binaries
- uses: actions/github-script@v8
with:
github-token: ${{ secrets.GITHUB_TOKEN }}
script: |
const fs = require('fs').promises;
const { repo: { owner, repo } } = context;
const currentRelease = context.ref.split('/')[2];
let body = `## New major features\n`
+ `\n`
+ `TODO\n`
+ `\n`
+ `## Fixes and improvements\n`
+ `\n`
+ `TODO\n`
+ `\n`
+ `## Security\n`
+ `\n`
+ `Binaries are compiled from source code by the [Release workflow](https://github.com/${owner}/${repo}/actions/workflows/release.yml), which is a fully-visible process that prevents any change or external interference in produced artifacts.\n`
+ `\n`
+ 'Checksums of binaries are also published in a public blockchain by using [GitHub Attestations](https://docs.github.com/en/actions/concepts/security/artifact-attestations), and they can be verified by running:\n'
+ `\n`
+ '```\n'
+ `ls mediamtx_* | xargs -L1 gh attestation verify --repo bluenviron/mediamtx\n`
+ '```\n'
+ `\n`
+ 'You can verify checksums of binaries by downloading `checksums.sha256` and running:\n'
+ `\n`
+ '```\n'
+ `cat checksums.sha256 | grep "$(ls mediamtx_*)" | sha256sum --check\n`
+ '```\n'
+ `\n`;
const res = await github.rest.repos.createRelease({
owner,
repo,
tag_name: currentRelease,
name: currentRelease,
body,
});
const release_id = res.data.id;
for (const name of await fs.readdir('./binaries/')) {
await github.rest.repos.uploadReleaseAsset({
owner,
repo,
release_id,
name,
data: await fs.readFile(`./binaries/${name}`),
});
}
github_notify_issues:
needs: github_release
runs-on: ubuntu-22.04
steps:
- uses: actions/github-script@v8
with:
github-token: ${{ secrets.GITHUB_TOKEN }}
script: |
const { repo: { owner, repo } } = context;
const tags = await github.rest.repos.listTags({
owner,
repo,
});
const curTag = tags.data[0];
const prevTag = tags.data[1];
const diff = await github.rest.repos.compareCommitsWithBasehead({
owner,
repo,
basehead: `${prevTag.commit.sha}...${curTag.commit.sha}`,
});
const issues = {};
for (const commit of diff.data.commits) {
for (const match of commit.commit.message.matchAll(/(^| |\()#([0-9]+)( |\)|$)/g)) {
issues[match[2]] = 1;
}
}
for (const issue in issues) {
try {
await github.rest.issues.createComment({
owner,
repo,
issue_number: parseInt(issue),
body: `This issue is mentioned in release ${curTag.name} 🚀\n`
+ `Check out the entire changelog by [clicking here](https://github.com/${owner}/${repo}/releases/tag/${curTag.name})`,
});
} catch (exc) {
console.error(exc.toString());
}
}
dockerhub:
needs: binaries
runs-on: ubuntu-22.04
steps:
- uses: actions/checkout@v6
- uses: actions/download-artifact@v8
with:
name: binaries
path: binaries
- run: make dockerhub
env:
DOCKER_USER: ${{ secrets.DOCKER_USER }}
DOCKER_PASSWORD: ${{ secrets.DOCKER_PASSWORD }}
================================================
FILE: .github/workflows/test.yml
================================================
name: test
on:
push:
branches: [ main ]
pull_request:
branches: [ main ]
jobs:
test_64:
runs-on: ubuntu-22.04
steps:
- uses: actions/checkout@v6
with:
fetch-depth: 0
- run: make test
- uses: codecov/codecov-action@v5
with:
token: ${{ secrets.CODECOV_TOKEN }}
test_32:
runs-on: ubuntu-22.04
steps:
- uses: actions/checkout@v6
with:
fetch-depth: 0
- run: make test-32
test_e2e:
runs-on: ubuntu-22.04
steps:
- uses: actions/checkout@v6
with:
fetch-depth: 0
- uses: actions/setup-go@v6
with:
go-version: "1.25"
- run: make test-e2e-nodocker
================================================
FILE: .gitignore
================================================
/tmp
/binaries
/coverage*.txt
/api/*.html
/internal/core/VERSION
/internal/servers/hls/hls.min.js
/internal/staticsources/rpicamera/mtxrpicam_*/
================================================
FILE: .golangci.yml
================================================
version: "2"
linters:
enable:
- asciicheck
- bidichk
- bodyclose
- copyloopvar
- dupl
- errorlint
- gochecknoinits
- gocritic
- lll
- misspell
- modernize
- nilerr
- prealloc
- predeclared
- reassign
- revive
- usestdlibvars
- unconvert
- tparallel
- wastedassign
- whitespace
settings:
errcheck:
exclude-functions:
- io.Copy
- (io.Closer).Close
- (io.Writer).Write
- (hash.Hash).Write
- (net.Conn).Close
- (net.Conn).SetReadDeadline
- (net.Conn).SetWriteDeadline
- (*net.TCPConn).SetKeepAlive
- (*net.TCPConn).SetKeepAlivePeriod
- (*net.TCPConn).SetNoDelay
- (net.Listener).Close
- (net.PacketConn).Close
- (net.PacketConn).SetReadDeadline
- (net.PacketConn).SetWriteDeadline
- (net/http.ResponseWriter).Write
- (*net/http.Server).Serve
- (*net/http.Server).ServeTLS
- (*net/http.Server).Shutdown
- os.Chdir
- os.Mkdir
- os.MkdirAll
- os.Remove
- os.RemoveAll
- os.Setenv
- os.Unsetenv
- (*os.File).WriteString
- (*os.File).Close
- (github.com/datarhei/gosrt.Conn).Close
- (github.com/datarhei/gosrt.Conn).SetReadDeadline
- (github.com/datarhei/gosrt.Conn).SetWriteDeadline
- (*github.com/bluenviron/gortsplib/v5.Client).Close
- (*github.com/bluenviron/gortsplib/v5.Server).Close
- (*github.com/bluenviron/gortsplib/v5.ServerSession).Close
- (*github.com/bluenviron/gortsplib/v5.ServerStream).Close
- (*github.com/bluenviron/gortsplib/v5.ServerConn).Close
govet:
enable-all: true
disable:
- fieldalignment
- reflectvaluecompare
settings:
shadow:
strict: true
modernize:
disable:
- reflecttypefor
- stringsbuilder
- testingcontext
formatters:
enable:
- gofmt
- gofumpt
- goimports
================================================
FILE: LICENSE
================================================
MIT License
Copyright (c) 2019 aler9
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.
================================================
FILE: Makefile
================================================
BASE_IMAGE = golang:1.25-alpine3.22
GOLANGCI_LINT_IMAGE = golangci/golangci-lint:v2.11.3
NODE_IMAGE = node:20-alpine3.22
.PHONY: $(shell ls)
help:
@echo "usage: make [action]"
@echo ""
@echo "available actions:"
@echo ""
@echo " format format code"
@echo " test run tests"
@echo " test-32 run tests on a 32-bit system"
@echo " test-e2e run end-to-end tests"
@echo " lint run linters"
@echo " binaries build binaries for all supported platforms"
@echo " dockerhub build and push images to Docker Hub"
@echo ""
blank :=
define NL
$(blank)
endef
include scripts/*.mk
================================================
FILE: README.md
================================================
|[Install](https://mediamtx.org/docs/kickoff/install)|[Documentation](https://mediamtx.org/docs/kickoff/introduction)|
|-|-|
Features
- [Publish](https://mediamtx.org/docs/usage/publish) live streams to the server with SRT, WebRTC, RTSP, RTMP, HLS, MPEG-TS, RTP, using FFmpeg, GStreamer, OBS Studio, Python , Golang, Unity, web browsers, Raspberry Pi Cameras and more.
- [Read](https://mediamtx.org/docs/usage/read) live streams from the server with SRT, WebRTC, RTSP, RTMP, HLS, using FFmpeg, GStreamer, VLC, OBS Studio, Python , Golang, Unity, web browsers and more.
- Streams are automatically converted from a protocol to another
- Serve several streams at once in separate paths
- Reload the configuration without disconnecting existing clients (hot reloading)
- [Serve always-available streams](https://mediamtx.org/docs/usage/always-available) even when the publisher is offline
- [Record](https://mediamtx.org/docs/usage/record) streams to disk in fMP4 or MPEG-TS format
- [Playback](https://mediamtx.org/docs/usage/playback) recorded streams
- [Authenticate](https://mediamtx.org/docs/usage/authentication) users with internal, HTTP or JWT authentication
- [Forward](https://mediamtx.org/docs/usage/forward) streams to other servers
- [Proxy](https://mediamtx.org/docs/usage/proxy) requests to other servers
- [Control](https://mediamtx.org/docs/usage/control-api) the server through the Control API
- [Extract metrics](https://mediamtx.org/docs/usage/metrics) from the server in a Prometheus-compatible format
- [Monitor performance](https://mediamtx.org/docs/usage/performance) to investigate CPU and RAM consumption
- [Run hooks](https://mediamtx.org/docs/usage/hooks) (external commands) when clients connect, disconnect, read or publish streams
- Compatible with Linux, Windows and macOS, does not require any dependency or interpreter, it's a single executable
- ...and many [others](https://mediamtx.org/docs/kickoff/introduction).
================================================
FILE: SECURITY.md
================================================
# Security
Check the [Security page](https://mediamtx.org/docs/other/security) on the website.
================================================
FILE: api/.redocly.yaml
================================================
extends:
- recommended
rules:
operation-4xx-response: off
================================================
FILE: api/openapi.yaml
================================================
openapi: 3.0.0
info:
version: 1.0.0
title: MediaMTX API
description: API of MediaMTX, a server and proxy that supports various protocols.
license:
name: MIT
url: https://opensource.org/licenses/MIT
servers:
- url: http://localhost:9997
security: []
components:
schemas:
OKStatus:
type: string
enum: [ok]
ErrorStatus:
type: string
enum: [error]
PathSourceType:
type: string
enum:
- hlsSource
- redirect
- rpiCameraSource
- rtmpConn
- rtmpsConn
- rtmpSource
- rtspSession
- rtspSource
- rtspsSession
- srtConn
- srtSource
- mpegtsSource
- rtpSource
- webRTCSession
- webRTCSource
PathReaderType:
type: string
enum:
- hlsMuxer
- rpiCameraSecondary
- rtmpConn
- rtmpsConn
- rtspConn
- rtspSession
- rtspsConn
- rtspsSession
- srtConn
- webRTCSession
PathTrackCodec:
type: string
enum:
- AV1
- VP9
- VP8
- H265
- H264
- MPEG-4 Video
- MPEG-1 Video
- MJPEG
- Opus
- Vorbis
- MPEG-4 Audio
- MPEG-4 Audio LATM
- MPEG-1 Audio
- AC3
- Speex
- G726
- G722
- G711
- LPCM
- MPEG-TS
- KLV
- Generic
AlwaysAvailableTrackCodec:
type: string
enum:
- AV1
- VP9
- H265
- H264
- MPEG4Audio
- Opus
- G711
- LPCM
AuthAction:
type: string
enum:
- publish
- read
- playback
- api
- metrics
- pprof
AuthMethod:
type: string
enum: [internal, http, jwt]
Encryption:
type: string
enum: [no, optional, strict]
HLSVariant:
type: string
enum: [mpegts, fmp4, lowLatency]
LogDestination:
type: string
enum: [stdout, file, syslog]
LogLevel:
type: string
enum: [error, warn, info, debug]
RecordFormat:
type: string
enum: [fmp4, mpegts]
RTSPAuthMethod:
type: string
enum: [basic, digest]
RTSPRangeType:
type: string
enum: ['', clock, npt, smpte]
RTSPTransport:
type: string
enum: [udp, multicast, tcp, automatic]
RTMPConnState:
type: string
enum: [idle, read, publish]
RTSPSessionState:
type: string
enum: [idle, read, publish]
SRTConnState:
type: string
enum: [idle, read, publish]
WebRTCSessionState:
type: string
enum: [read, publish]
OK:
type: object
properties:
status:
$ref: '#/components/schemas/OKStatus'
Error:
type: object
properties:
status:
$ref: '#/components/schemas/ErrorStatus'
error:
type: string
Info:
type: object
properties:
version:
type: string
started:
type: string
AuthInternalUser:
type: object
properties:
user:
type: string
pass:
type: string
ips:
type: array
items:
type: string
permissions:
type: array
items:
$ref: '#/components/schemas/AuthInternalUserPermission'
AuthInternalUserPermission:
type: object
properties:
action:
$ref: '#/components/schemas/AuthAction'
path:
type: string
GlobalConf:
type: object
properties:
# General
logLevel:
$ref: '#/components/schemas/LogLevel'
logDestinations:
type: array
items:
$ref: '#/components/schemas/LogDestination'
logStructured:
type: boolean
logFile:
type: string
sysLogPrefix:
type: string
dumpPackets:
type: boolean
readTimeout:
type: string
writeTimeout:
type: string
readBufferCount:
type: integer
format: int64
nullable: true
deprecated: true
writeQueueSize:
type: integer
format: int64
udpMaxPayloadSize:
type: integer
format: int64
udpReadBufferSize:
type: integer
format: uint64
runOnConnect:
type: string
runOnConnectRestart:
type: boolean
runOnDisconnect:
type: string
# Authentication
authMethod:
$ref: '#/components/schemas/AuthMethod'
authInternalUsers:
type: array
items:
$ref: '#/components/schemas/AuthInternalUser'
authHTTPAddress:
type: string
externalAuthenticationURL:
type: string
nullable: true
deprecated: true
authHTTPFingerprint:
type: string
authHTTPExclude:
type: array
items:
$ref: '#/components/schemas/AuthInternalUserPermission'
authJWTJWKS:
type: string
authJWTJWKSFingerprint:
type: string
authJWTClaimKey:
type: string
authJWTIssuer:
type: string
authJWTAudience:
type: string
authJWTExclude:
type: array
items:
$ref: '#/components/schemas/AuthInternalUserPermission'
authJWTInHTTPQuery:
type: boolean
# Control API
api:
type: boolean
apiAddress:
type: string
apiEncryption:
type: boolean
apiServerKey:
type: string
apiServerCert:
type: string
apiAllowOrigin:
type: string
nullable: true
deprecated: true
apiAllowOrigins:
type: array
items:
type: string
apiTrustedProxies:
type: array
items:
type: string
# Metrics
metrics:
type: boolean
metricsAddress:
type: string
metricsEncryption:
type: boolean
metricsServerKey:
type: string
metricsServerCert:
type: string
metricsAllowOrigin:
type: string
nullable: true
deprecated: true
metricsAllowOrigins:
type: array
items:
type: string
metricsTrustedProxies:
type: array
items:
type: string
# PPROF
pprof:
type: boolean
pprofAddress:
type: string
pprofEncryption:
type: boolean
pprofServerKey:
type: string
pprofServerCert:
type: string
pprofAllowOrigin:
type: string
nullable: true
deprecated: true
pprofAllowOrigins:
type: array
items:
type: string
pprofTrustedProxies:
type: array
items:
type: string
# Playback server
playback:
type: boolean
playbackAddress:
type: string
playbackEncryption:
type: boolean
playbackServerKey:
type: string
playbackServerCert:
type: string
playbackAllowOrigin:
type: string
nullable: true
deprecated: true
playbackAllowOrigins:
type: array
items:
type: string
playbackTrustedProxies:
type: array
items:
type: string
# RTSP server
rtsp:
type: boolean
rtspDisable:
type: boolean
nullable: true
deprecated: true
protocols:
type: array
nullable: true
items:
type: string
enum: [udp, multicast, tcp]
deprecated: true
rtspTransports:
type: array
items:
type: string
enum: [udp, multicast, tcp]
encryption:
type: string
nullable: true
deprecated: true
allOf:
- $ref: '#/components/schemas/Encryption'
rtspEncryption:
$ref: '#/components/schemas/Encryption'
rtspAddress:
type: string
rtspsAddress:
type: string
rtpAddress:
type: string
rtcpAddress:
type: string
multicastIPRange:
type: string
multicastRTPPort:
type: integer
format: int64
multicastRTCPPort:
type: integer
format: int64
srtpAddress:
type: string
srtcpAddress:
type: string
multicastSRTPPort:
type: integer
format: int64
multicastSRTCPPort:
type: integer
format: int64
rtspServerKey:
type: string
rtspServerCert:
type: string
authMethods:
type: array
nullable: true
items:
$ref: '#/components/schemas/RTSPAuthMethod'
deprecated: true
rtspAuthMethods:
type: array
items:
$ref: '#/components/schemas/RTSPAuthMethod'
rtspUDPReadBufferSize:
type: integer
format: uint64
nullable: true
deprecated: true
# RTMP server
rtmp:
type: boolean
rtmpDisable:
type: boolean
nullable: true
deprecated: true
rtmpEncryption:
$ref: '#/components/schemas/Encryption'
rtmpAddress:
type: string
rtmpsAddress:
type: string
rtmpServerKey:
type: string
rtmpServerCert:
type: string
# HLS server
hls:
type: boolean
hlsDisable:
type: boolean
nullable: true
deprecated: true
hlsAddress:
type: string
hlsEncryption:
type: boolean
hlsServerKey:
type: string
hlsServerCert:
type: string
hlsAllowOrigin:
type: string
nullable: true
deprecated: true
hlsAllowOrigins:
type: array
items:
type: string
hlsTrustedProxies:
type: array
items:
type: string
hlsAlwaysRemux:
type: boolean
hlsVariant:
$ref: '#/components/schemas/HLSVariant'
hlsSegmentCount:
type: integer
format: int64
hlsSegmentDuration:
type: string
hlsPartDuration:
type: string
hlsSegmentMaxSize:
type: string
hlsDirectory:
type: string
hlsMuxerCloseAfter:
type: string
# WebRTC server
webrtc:
type: boolean
webrtcDisable:
type: boolean
nullable: true
deprecated: true
webrtcAddress:
type: string
webrtcEncryption:
type: boolean
webrtcServerKey:
type: string
webrtcServerCert:
type: string
webrtcAllowOrigin:
type: string
nullable: true
deprecated: true
webrtcAllowOrigins:
type: array
items:
type: string
webrtcTrustedProxies:
type: array
items:
type: string
webrtcLocalUDPAddress:
type: string
webrtcLocalTCPAddress:
type: string
webrtcIPsFromInterfaces:
type: boolean
webrtcIPsFromInterfacesList:
type: array
items:
type: string
webrtcAdditionalHosts:
type: array
items:
type: string
webrtcICEServers2:
type: array
items:
$ref: '#/components/schemas/WebRTCICEServer'
webrtcSTUNGatherTimeout:
type: string
webrtcHandshakeTimeout:
type: string
webrtcTrackGatherTimeout:
type: string
webrtcICEUDPMuxAddress:
type: string
nullable: true
deprecated: true
webrtcICETCPMuxAddress:
type: string
nullable: true
deprecated: true
webrtcICEHostNAT1To1IPs:
type: array
nullable: true
items:
type: string
deprecated: true
webrtcICEServers:
type: array
nullable: true
items:
type: string
deprecated: true
# SRT server
srt:
type: boolean
srtAddress:
type: string
# Record (deprecated)
record:
type: boolean
nullable: true
deprecated: true
recordPath:
type: string
nullable: true
deprecated: true
recordFormat:
type: string
nullable: true
deprecated: true
allOf:
- $ref: '#/components/schemas/RecordFormat'
recordPartDuration:
type: string
nullable: true
deprecated: true
recordSegmentDuration:
type: string
nullable: true
deprecated: true
recordDeleteAfter:
type: string
nullable: true
deprecated: true
PathConf:
type: object
properties:
name:
type: string
# General
source:
type: string
sourceFingerprint:
type: string
sourceOnDemand:
type: boolean
sourceOnDemandStartTimeout:
type: string
sourceOnDemandCloseAfter:
type: string
maxReaders:
type: integer
format: int64
srtReadPassphrase:
type: string
fallback:
type: string
nullable: true
deprecated: true
useAbsoluteTimestamp:
type: boolean
# Always available
alwaysAvailable:
type: boolean
alwaysAvailableTracks:
type: array
items:
$ref: '#/components/schemas/AlwaysAvailableTrack'
alwaysAvailableFile:
type: string
# Record
record:
type: boolean
playback:
type: boolean
nullable: true
deprecated: true
recordPath:
type: string
recordFormat:
$ref: '#/components/schemas/RecordFormat'
recordPartDuration:
type: string
recordMaxPartSize:
type: string
recordSegmentDuration:
type: string
recordDeleteAfter:
type: string
# Authentication (deprecated)
publishUser:
type: string
nullable: true
deprecated: true
publishPass:
type: string
nullable: true
deprecated: true
publishIPs:
type: array
nullable: true
items:
type: string
deprecated: true
readUser:
type: string
nullable: true
deprecated: true
readPass:
type: string
nullable: true
deprecated: true
readIPs:
type: array
nullable: true
items:
type: string
deprecated: true
# Publisher source
overridePublisher:
type: boolean
disablePublisherOverride:
type: boolean
nullable: true
deprecated: true
srtPublishPassphrase:
type: string
rtspDemuxMpegts:
type: boolean
# RTSP source
rtspTransport:
$ref: '#/components/schemas/RTSPTransport'
rtspAnyPort:
type: boolean
sourceProtocol:
type: string
nullable: true
deprecated: true
allOf:
- $ref: '#/components/schemas/RTSPTransport'
sourceAnyPortEnable:
type: boolean
nullable: true
deprecated: true
rtspRangeType:
$ref: '#/components/schemas/RTSPRangeType'
rtspRangeStart:
type: string
rtspUDPReadBufferSize:
type: integer
format: uint64
nullable: true
deprecated: true
rtspUDPSourcePortRange:
type: array
minItems: 2
maxItems: 2
items:
type: integer
format: uint64
# MPEG-TS source
mpegtsUDPReadBufferSize:
type: integer
format: uint64
nullable: true
deprecated: true
# RTP source
rtpSDP:
type: string
rtpUDPReadBufferSize:
type: integer
format: uint64
nullable: true
deprecated: true
# WHEP source
whepBearerToken:
type: string
whepSTUNGatherTimeout:
type: string
whepHandshakeTimeout:
type: string
whepTrackGatherTimeout:
type: string
# Redirect source
sourceRedirect:
type: string
# Raspberry Pi Camera source
rpiCameraCamID:
type: integer
format: uint64
rpiCameraSecondary:
type: boolean
rpiCameraWidth:
type: integer
format: uint64
rpiCameraHeight:
type: integer
format: uint64
rpiCameraHFlip:
type: boolean
rpiCameraVFlip:
type: boolean
rpiCameraBrightness:
type: number
format: double
rpiCameraContrast:
type: number
format: double
rpiCameraSaturation:
type: number
format: double
rpiCameraSharpness:
type: number
format: double
rpiCameraExposure:
type: string
rpiCameraAWB:
type: string
rpiCameraAWBGains:
type: array
minItems: 2
maxItems: 2
items:
type: number
format: double
rpiCameraDenoise:
type: string
rpiCameraShutter:
type: integer
format: uint64
rpiCameraMetering:
type: string
rpiCameraGain:
type: number
format: double
rpiCameraEV:
type: number
format: double
rpiCameraROI:
type: string
rpiCameraHDR:
type: boolean
rpiCameraTuningFile:
type: string
rpiCameraMode:
type: string
rpiCameraFPS:
type: number
format: double
rpiCameraAfMode:
type: string
rpiCameraAfRange:
type: string
rpiCameraAfSpeed:
type: string
rpiCameraLensPosition:
type: number
format: double
rpiCameraAfWindow:
type: string
rpiCameraFlickerPeriod:
type: integer
format: uint64
rpiCameraTextOverlayEnable:
type: boolean
rpiCameraTextOverlay:
type: string
rpiCameraCodec:
type: string
rpiCameraIDRPeriod:
type: integer
format: uint64
rpiCameraBitrate:
type: integer
format: uint64
rpiCameraProfile:
type: string
nullable: true
deprecated: true
rpiCameraLevel:
type: string
nullable: true
deprecated: true
rpiCameraHardwareH264Profile:
type: string
rpiCameraHardwareH264Level:
type: string
rpiCameraSoftwareH264Profile:
type: string
rpiCameraSoftwareH264Level:
type: string
rpiCameraJPEGQuality:
type: integer
format: uint64
nullable: true
deprecated: true
rpiCameraMJPEGQuality:
type: integer
format: uint64
# Hooks
runOnInit:
type: string
runOnInitRestart:
type: boolean
runOnDemand:
type: string
runOnDemandRestart:
type: boolean
runOnDemandStartTimeout:
type: string
runOnDemandCloseAfter:
type: string
runOnUnDemand:
type: string
runOnReady:
type: string
runOnReadyRestart:
type: boolean
runOnNotReady:
type: string
runOnRead:
type: string
runOnReadRestart:
type: boolean
runOnUnread:
type: string
runOnRecordSegmentCreate:
type: string
runOnRecordSegmentComplete:
type: string
PathConfList:
type: object
properties:
pageCount:
type: integer
format: int64
itemCount:
type: integer
format: int64
items:
type: array
items:
$ref: '#/components/schemas/PathConf'
Path:
type: object
properties:
name:
type: string
confName:
type: string
source:
type: object
nullable: true
allOf:
- $ref: '#/components/schemas/PathSource'
ready:
type: boolean
deprecated: true
readyTime:
type: string
nullable: true
deprecated: true
available:
type: boolean
availableTime:
type: string
nullable: true
online:
type: boolean
onlineTime:
type: string
nullable: true
tracks:
type: array
deprecated: true
items:
$ref: '#/components/schemas/PathTrackCodec'
tracks2:
type: array
items:
$ref: '#/components/schemas/PathTrack'
inboundBytes:
type: integer
format: uint64
outboundBytes:
type: integer
format: uint64
inboundFramesInError:
type: integer
format: uint64
bytesReceived:
type: integer
format: uint64
deprecated: true
bytesSent:
type: integer
format: uint64
deprecated: true
readers:
type: array
items:
$ref: '#/components/schemas/PathReader'
PathList:
type: object
properties:
pageCount:
type: integer
format: int64
itemCount:
type: integer
format: int64
items:
type: array
items:
$ref: '#/components/schemas/Path'
PathSource:
type: object
properties:
type:
$ref: '#/components/schemas/PathSourceType'
id:
type: string
PathReader:
type: object
properties:
type:
$ref: '#/components/schemas/PathReaderType'
id:
type: string
PathTrack:
type: object
properties:
codec:
$ref: '#/components/schemas/PathTrackCodec'
codecProps:
type: object
nullable: true
allOf:
- $ref: '#/components/schemas/PathTrackCodecProps'
PathTrackCodecProps:
oneOf:
- $ref: '#/components/schemas/PathTrackCodecPropsAV1'
- $ref: '#/components/schemas/PathTrackCodecPropsVP9'
- $ref: '#/components/schemas/PathTrackCodecPropsH265'
- $ref: '#/components/schemas/PathTrackCodecPropsH264'
- $ref: '#/components/schemas/PathTrackCodecPropsOpus'
- $ref: '#/components/schemas/PathTrackCodecPropsMPEG4Audio'
- $ref: '#/components/schemas/PathTrackCodecPropsAC3'
- $ref: '#/components/schemas/PathTrackCodecPropsG711'
- $ref: '#/components/schemas/PathTrackCodecPropsLPCM'
PathTrackCodecPropsAV1:
type: object
properties:
width:
type: integer
format: int64
height:
type: integer
format: int64
profile:
type: integer
format: int64
level:
type: integer
format: int64
tier:
type: integer
format: int64
PathTrackCodecPropsVP9:
type: object
properties:
profile:
type: integer
format: int64
PathTrackCodecPropsH265:
type: object
properties:
width:
type: integer
format: int64
height:
type: integer
format: int64
profile:
type: string
level:
type: string
PathTrackCodecPropsH264:
type: object
properties:
width:
type: integer
format: int64
height:
type: integer
format: int64
profile:
type: string
level:
type: string
PathTrackCodecPropsOpus:
type: object
properties:
channelCount:
type: integer
format: int64
PathTrackCodecPropsMPEG4Audio:
type: object
properties:
sampleRate:
type: integer
format: int64
channelCount:
type: integer
format: int64
PathTrackCodecPropsAC3:
type: object
properties:
sampleRate:
type: integer
format: int64
channelCount:
type: integer
format: int64
PathTrackCodecPropsG711:
type: object
properties:
muLaw:
type: boolean
sampleRate:
type: integer
format: int64
channelCount:
type: integer
format: int64
PathTrackCodecPropsLPCM:
type: object
properties:
bitDepth:
type: integer
format: int64
sampleRate:
type: integer
format: int64
channelCount:
type: integer
format: int64
HLSMuxer:
type: object
properties:
path:
type: string
created:
type: string
lastRequest:
type: string
outboundBytes:
type: integer
format: uint64
outboundFramesDiscarded:
type: integer
format: uint64
bytesSent:
type: integer
format: uint64
deprecated: true
HLSMuxerList:
type: object
properties:
pageCount:
type: integer
format: int64
itemCount:
type: integer
format: int64
items:
type: array
items:
$ref: '#/components/schemas/HLSMuxer'
Recording:
type: object
properties:
name:
type: string
segments:
type: array
items:
$ref: '#/components/schemas/RecordingSegment'
RecordingList:
type: object
properties:
pageCount:
type: integer
format: int64
itemCount:
type: integer
format: int64
items:
type: array
items:
$ref: '#/components/schemas/Recording'
RecordingSegment:
type: object
properties:
start:
type: string
RTMPConn:
type: object
properties:
id:
type: string
format: uuid
created:
type: string
remoteAddr:
type: string
state:
$ref: '#/components/schemas/RTMPConnState'
path:
type: string
query:
type: string
user:
type: string
inboundBytes:
type: integer
format: uint64
outboundBytes:
type: integer
format: uint64
outboundFramesDiscarded:
type: integer
format: uint64
bytesReceived:
type: integer
format: uint64
deprecated: true
bytesSent:
type: integer
format: uint64
deprecated: true
RTMPConnList:
type: object
properties:
pageCount:
type: integer
format: int64
itemCount:
type: integer
format: int64
items:
type: array
items:
$ref: '#/components/schemas/RTMPConn'
RTSPConn:
type: object
properties:
id:
type: string
format: uuid
created:
type: string
remoteAddr:
type: string
session:
type: string
format: uuid
nullable: true
tunnel:
type: string
inboundBytes:
type: integer
format: uint64
outboundBytes:
type: integer
format: uint64
bytesReceived:
type: integer
format: uint64
deprecated: true
bytesSent:
type: integer
format: uint64
deprecated: true
RTSPConnList:
type: object
properties:
pageCount:
type: integer
format: int64
itemCount:
type: integer
format: int64
items:
type: array
items:
$ref: '#/components/schemas/RTSPConn'
RTSPSession:
type: object
properties:
id:
type: string
format: uuid
created:
type: string
remoteAddr:
type: string
state:
$ref: '#/components/schemas/RTSPSessionState'
path:
type: string
query:
type: string
user:
type: string
transport:
type: string
nullable: true
profile:
type: string
nullable: true
conns:
type: array
items:
type: string
format: uuid
inboundBytes:
type: integer
format: uint64
inboundRTPPackets:
type: integer
format: uint64
inboundRTPPacketsLost:
type: integer
format: uint64
inboundRTPPacketsInError:
type: integer
format: uint64
inboundRTPPacketsJitter:
type: number
format: double
inboundRTCPPackets:
type: integer
format: uint64
inboundRTCPPacketsInError:
type: integer
format: uint64
outboundBytes:
type: integer
format: uint64
outboundRTPPackets:
type: integer
format: uint64
outboundRTPPacketsReportedLost:
type: integer
format: uint64
outboundRTPPacketsDiscarded:
type: integer
format: uint64
outboundRTCPPackets:
type: integer
format: uint64
bytesReceived:
type: integer
format: uint64
deprecated: true
bytesSent:
type: integer
format: uint64
deprecated: true
rtpPacketsReceived:
type: integer
format: uint64
deprecated: true
rtpPacketsSent:
type: integer
format: uint64
deprecated: true
rtpPacketsLost:
type: integer
format: uint64
deprecated: true
rtpPacketsInError:
type: integer
format: uint64
deprecated: true
rtpPacketsJitter:
type: number
format: double
deprecated: true
rtcpPacketsReceived:
type: integer
format: uint64
deprecated: true
rtcpPacketsSent:
type: integer
format: uint64
deprecated: true
rtcpPacketsInError:
type: integer
format: uint64
deprecated: true
RTSPSessionList:
type: object
properties:
pageCount:
type: integer
format: int64
itemCount:
type: integer
format: int64
items:
type: array
items:
$ref: '#/components/schemas/RTSPSession'
SRTConn:
type: object
properties:
id:
type: string
format: uuid
created:
type: string
remoteAddr:
type: string
state:
$ref: '#/components/schemas/SRTConnState'
path:
type: string
query:
type: string
user:
type: string
packetsSent:
type: integer
format: uint64
description: The total number of sent DATA packets, including retransmitted packets
packetsReceived:
type: integer
format: uint64
description: The total number of received DATA packets, including retransmitted packets
packetsReceivedBelated:
type: integer
format: uint64
packetsSentUnique:
type: integer
format: uint64
description: The total number of unique DATA packets sent by the SRT sender
packetsReceivedUnique:
type: integer
format: uint64
description: The total number of unique original, retransmitted or recovered by the packet filter DATA packets received in time, decrypted without errors and, as a result, scheduled for delivery to the upstream application by the SRT receiver.
packetsSendLoss:
type: integer
format: uint64
description: The total number of data packets considered or reported as lost at the sender side. Does not correspond to the packets detected as lost at the receiver side.
packetsReceivedLoss:
type: integer
format: uint64
description: The total number of SRT DATA packets detected as presently missing (either reordered or lost) at the receiver side
packetsRetrans:
type: integer
format: uint64
description: The total number of retransmitted packets sent by the SRT sender
packetsReceivedRetrans:
type: integer
format: uint64
description: The total number of retransmitted packets registered at the receiver side
packetsSentACK:
type: integer
format: uint64
description: The total number of sent ACK (Acknowledgement) control packets
packetsReceivedACK:
type: integer
format: uint64
description: The total number of received ACK (Acknowledgement) control packets
packetsSentNAK:
type: integer
format: uint64
description: The total number of sent NAK (Negative Acknowledgement) control packets
packetsReceivedNAK:
type: integer
format: uint64
description: The total number of received NAK (Negative Acknowledgement) control packets
packetsSentKM:
type: integer
format: uint64
description: The total number of sent KM (Key Material) control packets
packetsReceivedKM:
type: integer
format: uint64
description: The total number of received KM (Key Material) control packets
usSndDuration:
type: integer
format: uint64
description: The total accumulated time in microseconds, during which the SRT sender has some data to transmit, including packets that have been sent, but not yet acknowledged
packetsSendDrop:
type: integer
format: uint64
description: The total number of dropped by the SRT sender DATA packets that have no chance to be delivered in time
packetsReceivedDrop:
type: integer
format: uint64
description: The total number of dropped by the SRT receiver and, as a result, not delivered to the upstream application DATA packets
packetsReceivedUndecrypt:
type: integer
format: uint64
description: The total number of packets that failed to be decrypted at the receiver side
bytesSent:
type: integer
format: uint64
description: Same as packetsSent, but expressed in bytes, including payload and all the headers (IP, TCP, SRT)
bytesReceived:
type: integer
format: uint64
description: Same as packetsReceived, but expressed in bytes, including payload and all the headers (IP, TCP, SRT)
bytesReceivedBelated:
type: integer
format: uint64
bytesSentUnique:
type: integer
format: uint64
description: Same as packetsSentUnique, but expressed in bytes, including payload and all the headers (IP, TCP, SRT)
bytesReceivedUnique:
type: integer
format: uint64
description: Same as packetsReceivedUnique, but expressed in bytes, including payload and all the headers (IP, TCP, SRT)
bytesReceivedLoss:
type: integer
format: uint64
description: Same as packetsReceivedLoss, but expressed in bytes, including payload and all the headers (IP, TCP, SRT), bytes for the presently missing (either reordered or lost) packets' payloads are estimated based on the average packet size
bytesRetrans:
type: integer
format: uint64
description: Same as packetsRetrans, but expressed in bytes, including payload and all the headers (IP, TCP, SRT)
bytesReceivedRetrans:
type: integer
format: uint64
description: Same as packetsReceivedRetrans, but expressed in bytes, including payload and all the headers (IP, TCP, SRT)
bytesSendDrop:
type: integer
format: uint64
description: Same as packetsSendDrop, but expressed in bytes, including payload and all the headers (IP, TCP, SRT)
bytesReceivedDrop:
type: integer
format: uint64
description: Same as packetsReceivedDrop, but expressed in bytes, including payload and all the headers (IP, TCP, SRT)
bytesReceivedUndecrypt:
type: integer
format: uint64
description: Same as packetsReceivedUndecrypt, but expressed in bytes, including payload and all the headers (IP, TCP, SRT)
usPacketsSendPeriod:
type: number
format: double
description: Current minimum time interval between which consecutive packets are sent, in microseconds
packetsFlowWindow:
type: integer
format: uint64
description: The maximum number of packets that can be "in flight"
packetsFlightSize:
type: integer
format: uint64
description: The number of packets in flight
msRTT:
type: number
format: double
description: Smoothed round-trip time (SRTT), an exponentially-weighted moving average (EWMA) of an endpoint's RTT samples, in milliseconds
mbpsSendRate:
type: number
format: double
description: Current transmission bandwidth, in Mbps
mbpsReceiveRate:
type: number
format: double
description: Current receiving bandwidth, in Mbps
mbpsLinkCapacity:
type: number
format: double
description: Estimated capacity of the network link, in Mbps
bytesAvailSendBuf:
type: integer
format: uint64
description: The available space in the sender's buffer, in bytes
bytesAvailReceiveBuf:
type: integer
format: uint64
description: The available space in the receiver's buffer, in bytes
mbpsMaxBW:
type: number
format: double
description: Transmission bandwidth limit, in Mbps
byteMSS:
type: integer
format: uint64
description: Maximum Segment Size (MSS), in bytes
packetsSendBuf:
type: integer
format: uint64
description: The number of packets in the sender's buffer that are already scheduled for sending or even possibly sent, but not yet acknowledged
bytesSendBuf:
type: integer
format: uint64
description: Instantaneous (current) value of packetsSndBuf, but expressed in bytes, including payload and all headers (IP, TCP, SRT)
msSendBuf:
type: integer
format: uint64
description: The timespan (msec) of packets in the sender's buffer (unacknowledged packets)
msSendTsbPdDelay:
type: integer
format: uint64
description: Timestamp-based Packet Delivery Delay value of the peer
packetsReceiveBuf:
type: integer
format: uint64
description: The number of acknowledged packets in receiver's buffer
bytesReceiveBuf:
type: integer
format: uint64
description: Instantaneous (current) value of packetsRcvBuf, expressed in bytes, including payload and all headers (IP, TCP, SRT)
msReceiveBuf:
type: integer
format: uint64
description: The timespan (msec) of acknowledged packets in the receiver's buffer
msReceiveTsbPdDelay:
type: integer
format: uint64
description: Timestamp-based Packet Delivery Delay value set on the socket via SRTO_RCVLATENCY or SRTO_LATENCY
packetsReorderTolerance:
type: integer
format: uint64
description: Instant value of the packet reorder tolerance
packetsReceivedAvgBelatedTime:
type: integer
format: uint64
description: Accumulated difference between the current time and the time-to-play of a packet that is received late
packetsSendLossRate:
type: number
format: double
description: Percentage of resent data vs. sent data
packetsReceivedLossRate:
type: number
format: double
description: Percentage of retransmitted data vs. received data
outboundFramesDiscarded:
type: integer
format: uint64
SRTConnList:
type: object
properties:
pageCount:
type: integer
format: int64
itemCount:
type: integer
format: int64
items:
type: array
items:
$ref: '#/components/schemas/SRTConn'
AlwaysAvailableTrack:
type: object
properties:
codec:
$ref: '#/components/schemas/AlwaysAvailableTrackCodec'
sampleRate:
type: integer
format: int64
channelCount:
type: integer
format: int64
muLaw:
type: boolean
WebRTCICEServer:
type: object
properties:
url:
type: string
username:
type: string
password:
type: string
clientOnly:
type: boolean
WebRTCSession:
type: object
properties:
id:
type: string
format: uuid
created:
type: string
remoteAddr:
type: string
peerConnectionEstablished:
type: boolean
localCandidate:
type: string
remoteCandidate:
type: string
state:
$ref: '#/components/schemas/WebRTCSessionState'
path:
type: string
query:
type: string
user:
type: string
inboundBytes:
type: integer
format: uint64
inboundRTPPackets:
type: integer
format: uint64
inboundRTPPacketsLost:
type: integer
format: uint64
inboundRTPPacketsJitter:
type: number
format: double
inboundRTCPPackets:
type: integer
format: uint64
outboundBytes:
type: integer
format: uint64
outboundRTPPackets:
type: integer
format: uint64
outboundRTCPPackets:
type: integer
format: uint64
outboundFramesDiscarded:
type: integer
format: uint64
bytesReceived:
type: integer
format: uint64
deprecated: true
bytesSent:
type: integer
format: uint64
deprecated: true
rtpPacketsReceived:
type: integer
format: uint64
deprecated: true
rtpPacketsSent:
type: integer
format: uint64
deprecated: true
rtpPacketsLost:
type: integer
format: uint64
deprecated: true
rtpPacketsJitter:
type: number
format: double
deprecated: true
rtcpPacketsReceived:
type: integer
format: uint64
deprecated: true
rtcpPacketsSent:
type: integer
format: uint64
deprecated: true
WebRTCSessionList:
type: object
properties:
pageCount:
type: integer
format: int64
itemCount:
type: integer
format: int64
items:
type: array
items:
$ref: '#/components/schemas/WebRTCSession'
paths:
/v3/info:
get:
operationId: info
tags: [General]
summary: returns informations about the instance.
responses:
'200':
description: the request was successful.
content:
application/json:
schema:
$ref: '#/components/schemas/Info'
'500':
description: server error.
content:
application/json:
schema:
$ref: '#/components/schemas/Error'
/v3/auth/jwks/refresh:
post:
operationId: authJwksRefresh
tags: [Authentication]
summary: Manually refreshes the JWT JWKS.
responses:
'200':
description: the request was successful.
content:
application/json:
schema:
$ref: '#/components/schemas/OK'
'500':
description: server error.
content:
application/json:
schema:
$ref: '#/components/schemas/Error'
/v3/config/global/get:
get:
operationId: configGlobalGet
tags: [Configuration]
summary: returns the global configuration.
description: ''
responses:
'200':
description: the request was successful.
content:
application/json:
schema:
$ref: '#/components/schemas/GlobalConf'
'400':
description: invalid request.
content:
application/json:
schema:
$ref: '#/components/schemas/Error'
'500':
description: server error.
content:
application/json:
schema:
$ref: '#/components/schemas/Error'
/v3/config/global/patch:
patch:
operationId: configGlobalSet
tags: [Configuration]
summary: patches the global configuration.
description: all fields are optional.
requestBody:
required: true
content:
application/json:
schema:
$ref: '#/components/schemas/GlobalConf'
responses:
'200':
description: the request was successful.
content:
application/json:
schema:
$ref: '#/components/schemas/OK'
'400':
description: invalid request.
content:
application/json:
schema:
$ref: '#/components/schemas/Error'
'500':
description: server error.
content:
application/json:
schema:
$ref: '#/components/schemas/Error'
/v3/config/pathdefaults/get:
get:
operationId: configPathDefaultsGet
tags: [Configuration]
summary: returns the default path configuration.
description: ''
responses:
'200':
description: the request was successful.
content:
application/json:
schema:
$ref: '#/components/schemas/PathConf'
'400':
description: invalid request.
content:
application/json:
schema:
$ref: '#/components/schemas/Error'
'500':
description: server error.
content:
application/json:
schema:
$ref: '#/components/schemas/Error'
/v3/config/pathdefaults/patch:
patch:
operationId: configPathDefaultsPatch
tags: [Configuration]
summary: patches the default path configuration.
description: all fields are optional.
requestBody:
required: true
content:
application/json:
schema:
$ref: '#/components/schemas/PathConf'
responses:
'200':
description: the request was successful.
content:
application/json:
schema:
$ref: '#/components/schemas/OK'
'400':
description: invalid request.
content:
application/json:
schema:
$ref: '#/components/schemas/Error'
'500':
description: server error.
content:
application/json:
schema:
$ref: '#/components/schemas/Error'
/v3/config/paths/list:
get:
operationId: configPathsList
tags: [Configuration]
summary: returns all path configurations.
description: ''
parameters:
- name: page
in: query
description: page number.
schema:
type: integer
default: 0
- name: itemsPerPage
in: query
description: items per page.
schema:
type: integer
default: 100
responses:
'200':
description: the request was successful.
content:
application/json:
schema:
$ref: '#/components/schemas/PathConfList'
'400':
description: invalid request.
content:
application/json:
schema:
$ref: '#/components/schemas/Error'
'500':
description: server error.
content:
application/json:
schema:
$ref: '#/components/schemas/Error'
/v3/config/paths/get/{name}:
get:
operationId: configPathsGet
tags: [Configuration]
summary: returns a path configuration.
description: ''
parameters:
- name: name
in: path
required: true
description: the name of the path.
schema:
type: string
responses:
'200':
description: the request was successful.
content:
application/json:
schema:
$ref: '#/components/schemas/PathConf'
'400':
description: invalid request.
content:
application/json:
schema:
$ref: '#/components/schemas/Error'
'404':
description: path not found.
content:
application/json:
schema:
$ref: '#/components/schemas/Error'
'500':
description: server error.
content:
application/json:
schema:
$ref: '#/components/schemas/Error'
/v3/config/paths/add/{name}:
post:
operationId: configPathsAdd
tags: [Configuration]
summary: adds a path configuration.
description: all fields are optional.
parameters:
- name: name
in: path
required: true
description: the name of the path.
schema:
type: string
requestBody:
required: true
content:
application/json:
schema:
$ref: '#/components/schemas/PathConf'
responses:
'200':
description: the request was successful.
content:
application/json:
schema:
$ref: '#/components/schemas/OK'
'400':
description: invalid request.
content:
application/json:
schema:
$ref: '#/components/schemas/Error'
'500':
description: server error.
content:
application/json:
schema:
$ref: '#/components/schemas/Error'
/v3/config/paths/patch/{name}:
patch:
operationId: configPathsPatch
tags: [Configuration]
summary: patches a path configuration.
description: all fields are optional.
parameters:
- name: name
in: path
required: true
description: the name of the path.
schema:
type: string
requestBody:
required: true
content:
application/json:
schema:
$ref: '#/components/schemas/PathConf'
responses:
'200':
description: the request was successful.
content:
application/json:
schema:
$ref: '#/components/schemas/OK'
'400':
description: invalid request.
content:
application/json:
schema:
$ref: '#/components/schemas/Error'
'404':
description: path not found.
content:
application/json:
schema:
$ref: '#/components/schemas/Error'
'500':
description: server error.
content:
application/json:
schema:
$ref: '#/components/schemas/Error'
/v3/config/paths/replace/{name}:
post:
operationId: configPathsReplace
tags: [Configuration]
summary: replaces all values of a path configuration.
description: all fields are optional.
parameters:
- name: name
in: path
required: true
description: the name of the path.
schema:
type: string
requestBody:
required: true
content:
application/json:
schema:
$ref: '#/components/schemas/PathConf'
responses:
'200':
description: the request was successful.
content:
application/json:
schema:
$ref: '#/components/schemas/OK'
'400':
description: invalid request.
content:
application/json:
schema:
$ref: '#/components/schemas/Error'
'404':
description: path not found.
content:
application/json:
schema:
$ref: '#/components/schemas/Error'
'500':
description: server error.
content:
application/json:
schema:
$ref: '#/components/schemas/Error'
/v3/config/paths/delete/{name}:
delete:
operationId: configPathsDelete
tags: [Configuration]
summary: removes a path configuration.
description: ''
parameters:
- name: name
in: path
required: true
description: the name of the path.
schema:
type: string
responses:
'200':
description: the request was successful.
content:
application/json:
schema:
$ref: '#/components/schemas/OK'
'400':
description: invalid request.
content:
application/json:
schema:
$ref: '#/components/schemas/Error'
'404':
description: path not found.
content:
application/json:
schema:
$ref: '#/components/schemas/Error'
'500':
description: server error.
content:
application/json:
schema:
$ref: '#/components/schemas/Error'
/v3/hlsmuxers/list:
get:
operationId: hlsMuxersList
tags: [HLS]
summary: returns all HLS muxers.
description: ''
parameters:
- name: page
in: query
description: page number.
schema:
type: integer
default: 0
- name: itemsPerPage
in: query
description: items per page.
schema:
type: integer
default: 100
responses:
'200':
description: the request was successful.
content:
application/json:
schema:
$ref: '#/components/schemas/HLSMuxerList'
'400':
description: invalid request.
content:
application/json:
schema:
$ref: '#/components/schemas/Error'
'500':
description: server error.
content:
application/json:
schema:
$ref: '#/components/schemas/Error'
/v3/hlsmuxers/get/{name}:
get:
operationId: hlsMuxersGet
tags: [HLS]
summary: returns a HLS muxer.
description: ''
parameters:
- name: name
in: path
required: true
description: name of the muxer.
schema:
type: string
responses:
'200':
description: the request was successful.
content:
application/json:
schema:
$ref: '#/components/schemas/HLSMuxer'
'400':
description: invalid request.
content:
application/json:
schema:
$ref: '#/components/schemas/Error'
'404':
description: muxer not found.
content:
application/json:
schema:
$ref: '#/components/schemas/Error'
'500':
description: server error.
content:
application/json:
schema:
$ref: '#/components/schemas/Error'
/v3/paths/list:
get:
operationId: pathsList
tags: [Paths]
summary: returns all paths.
description: ''
parameters:
- name: page
in: query
description: page number.
schema:
type: integer
default: 0
- name: itemsPerPage
in: query
description: items per page.
schema:
type: integer
default: 100
responses:
'200':
description: the request was successful.
content:
application/json:
schema:
$ref: '#/components/schemas/PathList'
'400':
description: invalid request.
content:
application/json:
schema:
$ref: '#/components/schemas/Error'
'500':
description: server error.
content:
application/json:
schema:
$ref: '#/components/schemas/Error'
/v3/paths/get/{name}:
get:
operationId: pathsGet
tags: [Paths]
summary: returns a path.
description: ''
parameters:
- name: name
in: path
required: true
description: name of the path.
schema:
type: string
responses:
'200':
description: the request was successful.
content:
application/json:
schema:
$ref: '#/components/schemas/Path'
'400':
description: invalid request.
content:
application/json:
schema:
$ref: '#/components/schemas/Error'
'404':
description: path not found.
content:
application/json:
schema:
$ref: '#/components/schemas/Error'
'500':
description: server error.
content:
application/json:
schema:
$ref: '#/components/schemas/Error'
/v3/rtspconns/list:
get:
operationId: rtspConnsList
tags: [RTSP]
summary: returns all RTSP connections.
description: ''
parameters:
- name: page
in: query
description: page number.
schema:
type: integer
default: 0
- name: itemsPerPage
in: query
description: items per page.
schema:
type: integer
default: 100
responses:
'200':
description: the request was successful.
content:
application/json:
schema:
$ref: '#/components/schemas/RTSPConnList'
'400':
description: invalid request.
content:
application/json:
schema:
$ref: '#/components/schemas/Error'
'500':
description: server error.
content:
application/json:
schema:
$ref: '#/components/schemas/Error'
/v3/rtspconns/get/{id}:
get:
operationId: rtspConnsGet
tags: [RTSP]
summary: returns a RTSP connection.
description: ''
parameters:
- name: id
in: path
required: true
description: ID of the connection.
schema:
type: string
responses:
'200':
description: the request was successful.
content:
application/json:
schema:
$ref: '#/components/schemas/RTSPConn'
'400':
description: invalid request.
content:
application/json:
schema:
$ref: '#/components/schemas/Error'
'404':
description: connection not found.
content:
application/json:
schema:
$ref: '#/components/schemas/Error'
'500':
description: server error.
content:
application/json:
schema:
$ref: '#/components/schemas/Error'
/v3/rtspsessions/list:
get:
operationId: rtspSessionsList
tags: [RTSP]
summary: returns all RTSP sessions.
description: ''
parameters:
- name: page
in: query
description: page number.
schema:
type: integer
default: 0
- name: itemsPerPage
in: query
description: items per page.
schema:
type: integer
default: 100
responses:
'200':
description: the request was successful.
content:
application/json:
schema:
$ref: '#/components/schemas/RTSPSessionList'
'400':
description: invalid request.
content:
application/json:
schema:
$ref: '#/components/schemas/Error'
'500':
description: server error.
content:
application/json:
schema:
$ref: '#/components/schemas/Error'
/v3/rtspsessions/get/{id}:
get:
operationId: rtspSessionsGet
tags: [RTSP]
summary: returns a RTSP session.
description: ''
parameters:
- name: id
in: path
required: true
description: ID of the connection.
schema:
type: string
responses:
'200':
description: the request was successful.
content:
application/json:
schema:
$ref: '#/components/schemas/RTSPSession'
'400':
description: invalid request.
content:
application/json:
schema:
$ref: '#/components/schemas/Error'
'404':
description: session not found.
content:
application/json:
schema:
$ref: '#/components/schemas/Error'
'500':
description: server error.
content:
application/json:
schema:
$ref: '#/components/schemas/Error'
/v3/rtspsessions/kick/{id}:
post:
operationId: rtspSessionsKick
tags: [RTSP]
summary: kicks out a RTSP session from the server.
description: ''
parameters:
- name: id
in: path
required: true
description: ID of the session.
schema:
type: string
responses:
'200':
description: the request was successful.
content:
application/json:
schema:
$ref: '#/components/schemas/OK'
'400':
description: invalid request.
content:
application/json:
schema:
$ref: '#/components/schemas/Error'
'404':
description: session not found.
content:
application/json:
schema:
$ref: '#/components/schemas/Error'
'500':
description: server error.
content:
application/json:
schema:
$ref: '#/components/schemas/Error'
/v3/rtspsconns/list:
get:
operationId: rtspsConnsList
tags: [RTSP]
summary: returns all RTSPS connections.
description: ''
parameters:
- name: page
in: query
description: page number.
schema:
type: integer
default: 0
- name: itemsPerPage
in: query
description: items per page.
schema:
type: integer
default: 100
responses:
'200':
description: the request was successful.
content:
application/json:
schema:
$ref: '#/components/schemas/RTSPConnList'
'400':
description: invalid request.
content:
application/json:
schema:
$ref: '#/components/schemas/Error'
'500':
description: server error.
content:
application/json:
schema:
$ref: '#/components/schemas/Error'
/v3/rtspsconns/get/{id}:
get:
operationId: rtspsConnsGet
tags: [RTSP]
summary: returns a RTSPS connection.
description: ''
parameters:
- name: id
in: path
required: true
description: ID of the connection.
schema:
type: string
responses:
'200':
description: the request was successful.
content:
application/json:
schema:
$ref: '#/components/schemas/RTSPConn'
'400':
description: invalid request.
content:
application/json:
schema:
$ref: '#/components/schemas/Error'
'404':
description: connection not found.
content:
application/json:
schema:
$ref: '#/components/schemas/Error'
'500':
description: server error.
content:
application/json:
schema:
$ref: '#/components/schemas/Error'
/v3/rtspssessions/list:
get:
operationId: rtspsSessionsList
tags: [RTSP]
summary: returns all RTSPS sessions.
description: ''
parameters:
- name: page
in: query
description: page number.
schema:
type: integer
default: 0
- name: itemsPerPage
in: query
description: items per page.
schema:
type: integer
default: 100
responses:
'200':
description: the request was successful.
content:
application/json:
schema:
$ref: '#/components/schemas/RTSPSessionList'
'400':
description: invalid request.
content:
application/json:
schema:
$ref: '#/components/schemas/Error'
'500':
description: server error.
content:
application/json:
schema:
$ref: '#/components/schemas/Error'
/v3/rtspssessions/get/{id}:
get:
operationId: rtspsSessionsGet
tags: [RTSP]
summary: returns a RTSPS session.
description: ''
parameters:
- name: id
in: path
required: true
description: ID of the connection.
schema:
type: string
responses:
'200':
description: the request was successful.
content:
application/json:
schema:
$ref: '#/components/schemas/RTSPSession'
'400':
description: invalid request.
content:
application/json:
schema:
$ref: '#/components/schemas/Error'
'404':
description: session not found.
content:
application/json:
schema:
$ref: '#/components/schemas/Error'
'500':
description: server error.
content:
application/json:
schema:
$ref: '#/components/schemas/Error'
/v3/rtspssessions/kick/{id}:
post:
operationId: rtspsSessionsKick
tags: [RTSP]
summary: kicks out a RTSPS session from the server.
description: ''
parameters:
- name: id
in: path
required: true
description: ID of the session.
schema:
type: string
responses:
'200':
description: the request was successful.
content:
application/json:
schema:
$ref: '#/components/schemas/OK'
'400':
description: invalid request.
content:
application/json:
schema:
$ref: '#/components/schemas/Error'
'404':
description: session not found.
content:
application/json:
schema:
$ref: '#/components/schemas/Error'
'500':
description: server error.
content:
application/json:
schema:
$ref: '#/components/schemas/Error'
/v3/rtmpconns/list:
get:
operationId: rtmpConnsList
tags: [RTMP]
summary: returns all RTMP connections.
description: ''
parameters:
- name: page
in: query
description: page number.
schema:
type: integer
default: 0
- name: itemsPerPage
in: query
description: items per page.
schema:
type: integer
default: 100
responses:
'200':
description: the request was successful.
content:
application/json:
schema:
$ref: '#/components/schemas/RTMPConnList'
'400':
description: invalid request.
content:
application/json:
schema:
$ref: '#/components/schemas/Error'
'500':
description: server error.
content:
application/json:
schema:
$ref: '#/components/schemas/Error'
/v3/rtmpconns/get/{id}:
get:
operationId: rtmpConnectionsGet
tags: [RTMP]
summary: returns a RTMP connection.
description: ''
parameters:
- name: id
in: path
required: true
description: ID of the connection.
schema:
type: string
responses:
'200':
description: the request was successful.
content:
application/json:
schema:
$ref: '#/components/schemas/RTMPConn'
'400':
description: invalid request.
content:
application/json:
schema:
$ref: '#/components/schemas/Error'
'404':
description: connection not found.
content:
application/json:
schema:
$ref: '#/components/schemas/Error'
'500':
description: server error.
content:
application/json:
schema:
$ref: '#/components/schemas/Error'
/v3/rtmpconns/kick/{id}:
post:
operationId: rtmpConnsKick
tags: [RTMP]
summary: kicks out a RTMP connection from the server.
description: ''
parameters:
- name: id
in: path
required: true
description: ID of the connection.
schema:
type: string
responses:
'200':
description: the request was successful.
content:
application/json:
schema:
$ref: '#/components/schemas/OK'
'400':
description: invalid request.
content:
application/json:
schema:
$ref: '#/components/schemas/Error'
'404':
description: connection not found.
content:
application/json:
schema:
$ref: '#/components/schemas/Error'
'500':
description: server error.
content:
application/json:
schema:
$ref: '#/components/schemas/Error'
/v3/rtmpsconns/list:
get:
operationId: rtmpsConnsList
tags: [RTMP]
summary: returns all RTMPS connections.
description: ''
parameters:
- name: page
in: query
description: page number.
schema:
type: integer
default: 0
- name: itemsPerPage
in: query
description: items per page.
schema:
type: integer
default: 100
responses:
'200':
description: the request was successful.
content:
application/json:
schema:
$ref: '#/components/schemas/RTMPConnList'
'400':
description: invalid request.
content:
application/json:
schema:
$ref: '#/components/schemas/Error'
'500':
description: server error.
content:
application/json:
schema:
$ref: '#/components/schemas/Error'
/v3/rtmpsconns/get/{id}:
get:
operationId: rtmpsConnectionsGet
tags: [RTMP]
summary: returns a RTMPS connection.
description: ''
parameters:
- name: id
in: path
required: true
description: ID of the connection.
schema:
type: string
responses:
'200':
description: the request was successful.
content:
application/json:
schema:
$ref: '#/components/schemas/RTMPConn'
'400':
description: invalid request.
content:
application/json:
schema:
$ref: '#/components/schemas/Error'
'404':
description: connection not found.
content:
application/json:
schema:
$ref: '#/components/schemas/Error'
'500':
description: server error.
content:
application/json:
schema:
$ref: '#/components/schemas/Error'
/v3/rtmpsconns/kick/{id}:
post:
operationId: rtmpsConnsKick
tags: [RTMP]
summary: kicks out a RTMPS connection from the server.
description: ''
parameters:
- name: id
in: path
required: true
description: ID of the connection.
schema:
type: string
responses:
'200':
description: the request was successful.
content:
application/json:
schema:
$ref: '#/components/schemas/OK'
'400':
description: invalid request.
content:
application/json:
schema:
$ref: '#/components/schemas/Error'
'404':
description: connection not found.
content:
application/json:
schema:
$ref: '#/components/schemas/Error'
'500':
description: server error.
content:
application/json:
schema:
$ref: '#/components/schemas/Error'
/v3/srtconns/list:
get:
operationId: srtConnsList
tags: [SRT]
summary: returns all SRT connections.
description: ''
parameters:
- name: page
in: query
description: page number.
schema:
type: integer
default: 0
- name: itemsPerPage
in: query
description: items per page.
schema:
type: integer
default: 100
responses:
'200':
description: the request was successful.
content:
application/json:
schema:
$ref: '#/components/schemas/SRTConnList'
'400':
description: invalid request.
content:
application/json:
schema:
$ref: '#/components/schemas/Error'
'500':
description: server error.
content:
application/json:
schema:
$ref: '#/components/schemas/Error'
/v3/srtconns/get/{id}:
get:
operationId: srtConnsGet
tags: [SRT]
summary: returns a SRT connection.
description: ''
parameters:
- name: id
in: path
required: true
description: ID of the connection.
schema:
type: string
responses:
'200':
description: the request was successful.
content:
application/json:
schema:
$ref: '#/components/schemas/SRTConn'
'400':
description: invalid request.
content:
application/json:
schema:
$ref: '#/components/schemas/Error'
'404':
description: connection not found.
content:
application/json:
schema:
$ref: '#/components/schemas/Error'
'500':
description: server error.
content:
application/json:
schema:
$ref: '#/components/schemas/Error'
/v3/srtconns/kick/{id}:
post:
operationId: srtConnsKick
tags: [SRT]
summary: kicks out a SRT connection from the server.
description: ''
parameters:
- name: id
in: path
required: true
description: ID of the connection.
schema:
type: string
responses:
'200':
description: the request was successful.
content:
application/json:
schema:
$ref: '#/components/schemas/OK'
'400':
description: invalid request.
content:
application/json:
schema:
$ref: '#/components/schemas/Error'
'404':
description: connection not found.
content:
application/json:
schema:
$ref: '#/components/schemas/Error'
'500':
description: server error.
content:
application/json:
schema:
$ref: '#/components/schemas/Error'
/v3/webrtcsessions/list:
get:
operationId: webrtcSessionsList
tags: [WebRTC]
summary: returns all WebRTC sessions.
description: ''
parameters:
- name: page
in: query
description: page number.
schema:
type: integer
default: 0
- name: itemsPerPage
in: query
description: items per page.
schema:
type: integer
default: 100
responses:
'200':
description: the request was successful.
content:
application/json:
schema:
$ref: '#/components/schemas/WebRTCSessionList'
'400':
description: invalid request.
content:
application/json:
schema:
$ref: '#/components/schemas/Error'
'500':
description: server error.
content:
application/json:
schema:
$ref: '#/components/schemas/Error'
/v3/webrtcsessions/get/{id}:
get:
operationId: webrtcSessionsGet
tags: [WebRTC]
summary: returns a WebRTC session.
description: ''
parameters:
- name: id
in: path
required: true
description: ID of the session.
schema:
type: string
responses:
'200':
description: the request was successful.
content:
application/json:
schema:
$ref: '#/components/schemas/WebRTCSession'
'400':
description: invalid request.
content:
application/json:
schema:
$ref: '#/components/schemas/Error'
'404':
description: session not found.
content:
application/json:
schema:
$ref: '#/components/schemas/Error'
'500':
description: server error.
content:
application/json:
schema:
$ref: '#/components/schemas/Error'
/v3/webrtcsessions/kick/{id}:
post:
operationId: webrtcSessionsKick
tags: [WebRTC]
summary: kicks out a WebRTC session from the server.
description: ''
parameters:
- name: id
in: path
required: true
description: ID of the session.
schema:
type: string
responses:
'200':
description: the request was successful.
content:
application/json:
schema:
$ref: '#/components/schemas/OK'
'400':
description: invalid request.
content:
application/json:
schema:
$ref: '#/components/schemas/Error'
'404':
description: session not found.
content:
application/json:
schema:
$ref: '#/components/schemas/Error'
'500':
description: server error.
content:
application/json:
schema:
$ref: '#/components/schemas/Error'
/v3/recordings/list:
get:
operationId: recordingsList
tags: [Recordings]
summary: returns all recordings, splitted by path.
description: ''
parameters:
- name: page
in: query
description: page number.
schema:
type: integer
default: 0
- name: itemsPerPage
in: query
description: items per page.
schema:
type: integer
default: 100
responses:
'200':
description: the request was successful.
content:
application/json:
schema:
$ref: '#/components/schemas/RecordingList'
'400':
description: invalid request.
content:
application/json:
schema:
$ref: '#/components/schemas/Error'
'500':
description: server error.
content:
application/json:
schema:
$ref: '#/components/schemas/Error'
/v3/recordings/get/{name}:
get:
operationId: recordingsGet
tags: [Recordings]
summary: returns recordings of a path.
description: ''
parameters:
- name: name
in: path
required: true
description: name of the path.
schema:
type: string
responses:
'200':
description: the request was successful.
content:
application/json:
schema:
$ref: '#/components/schemas/Recording'
'400':
description: invalid request.
content:
application/json:
schema:
$ref: '#/components/schemas/Error'
'404':
description: path not found.
content:
application/json:
schema:
$ref: '#/components/schemas/Error'
'500':
description: server error.
content:
application/json:
schema:
$ref: '#/components/schemas/Error'
/v3/recordings/deletesegment:
delete:
operationId: recordingsDeleteSegment
tags: [Recordings]
summary: deletes a recording segment.
description: ''
parameters:
- name: path
in: query
required: true
description: path.
schema:
type: string
- name: start
in: query
required: true
description: starting date of the segment.
schema:
type: string
responses:
'200':
description: the request was successful.
content:
application/json:
schema:
$ref: '#/components/schemas/OK'
'400':
description: invalid request.
content:
application/json:
schema:
$ref: '#/components/schemas/Error'
'404':
description: connection not found.
content:
application/json:
schema:
$ref: '#/components/schemas/Error'
'500':
description: server error.
content:
application/json:
schema:
$ref: '#/components/schemas/Error'
================================================
FILE: docker/ffmpeg-rpi.Dockerfile
================================================
#################################################################
FROM --platform=linux/amd64 scratch AS binaries
ADD binaries/mediamtx_*_linux_armv6.tar.gz /linux/arm/v6
ADD binaries/mediamtx_*_linux_armv7.tar.gz /linux/arm/v7
ADD binaries/mediamtx_*_linux_arm64.tar.gz /linux/arm64
#################################################################
FROM --platform=linux/arm/v7 debian:bullseye-slim AS base-arm-v7
# even though the base image is arm v7,
# Raspbian libraries and compilers provide arm v6 compatibility.
RUN apt update \
&& apt install -y wget gpg \
&& echo "deb http://archive.raspbian.org/raspbian bullseye main rpi firmware" > /etc/apt/sources.list \
&& echo "deb http://archive.raspberrypi.org/debian bullseye main" > /etc/apt/sources.list.d/raspi.list \
&& wget -O- https://archive.raspbian.org/raspbian.public.key | gpg --dearmor -o /etc/apt/trusted.gpg.d/raspbian.gpg \
&& wget -O- https://archive.raspberrypi.org/debian/raspberrypi.gpg.key | gpg --dearmor -o /etc/apt/trusted.gpg.d/raspberrypi.gpg \
&& rm -rf /var/lib/apt/lists/*
RUN apt update && apt install --reinstall -y \
libc6 \
libc-bin \
libstdc++6 \
&& rm -rf /var/lib/apt/lists/*
#################################################################
FROM --platform=linux/arm64 debian:bullseye-slim AS base-arm64
RUN apt update \
&& apt install -y wget gpg \
&& echo "deb http://archive.raspberrypi.org/debian bullseye main" > /etc/apt/sources.list.d/raspi.list \
&& wget -O- https://archive.raspberrypi.org/debian/raspberrypi.gpg.key | gpg --dearmor -o /etc/apt/trusted.gpg.d/raspberrypi.gpg \
&& rm -rf /var/lib/apt/lists/*
#################################################################
FROM --platform=linux/amd64 scratch AS base
COPY --from=base-arm-v7 / /linux/arm/v6
COPY --from=base-arm-v7 / /linux/arm/v7
COPY --from=base-arm64 / /linux/arm64
#################################################################
FROM scratch
ARG TARGETPLATFORM
COPY --from=base /$TARGETPLATFORM /
RUN apt update \
&& apt install -y --no-install-recommends ffmpeg \
&& rm -rf /var/lib/apt/lists/*
COPY --from=binaries /$TARGETPLATFORM /
ENTRYPOINT [ "/mediamtx" ]
================================================
FILE: docker/ffmpeg.Dockerfile
================================================
#################################################################
FROM --platform=linux/amd64 scratch AS binaries
ADD binaries/mediamtx_*_linux_amd64.tar.gz /linux/amd64
ADD binaries/mediamtx_*_linux_armv6.tar.gz /linux/arm/v6
ADD binaries/mediamtx_*_linux_armv7.tar.gz /linux/arm/v7
ADD binaries/mediamtx_*_linux_arm64.tar.gz /linux/arm64
#################################################################
FROM alpine:3.22
RUN apk add --no-cache ffmpeg
ARG TARGETPLATFORM
COPY --from=binaries /$TARGETPLATFORM /
ENTRYPOINT [ "/mediamtx" ]
================================================
FILE: docker/rpi.Dockerfile
================================================
#################################################################
FROM --platform=linux/amd64 scratch AS binaries
ADD binaries/mediamtx_*_linux_armv6.tar.gz /linux/arm/v6
ADD binaries/mediamtx_*_linux_armv7.tar.gz /linux/arm/v7
ADD binaries/mediamtx_*_linux_arm64.tar.gz /linux/arm64
#################################################################
FROM --platform=linux/arm/v7 debian:bullseye-slim AS base-arm-v7
# even though the base image is arm v7,
# Raspbian libraries and compilers provide arm v6 compatibility.
RUN apt update \
&& apt install -y wget gpg \
&& echo "deb http://archive.raspbian.org/raspbian bullseye main rpi firmware" > /etc/apt/sources.list \
&& echo "deb http://archive.raspberrypi.org/debian bullseye main" > /etc/apt/sources.list.d/raspi.list \
&& wget -O- https://archive.raspbian.org/raspbian.public.key | gpg --dearmor -o /etc/apt/trusted.gpg.d/raspbian.gpg \
&& wget -O- https://archive.raspberrypi.org/debian/raspberrypi.gpg.key | gpg --dearmor -o /etc/apt/trusted.gpg.d/raspberrypi.gpg \
&& rm -rf /var/lib/apt/lists/*
RUN apt update && apt install --reinstall -y \
libc6 \
libc-bin \
libstdc++6 \
&& rm -rf /var/lib/apt/lists/*
#################################################################
FROM --platform=linux/arm64 debian:bullseye-slim AS base-arm64
RUN apt update \
&& apt install -y wget gpg \
&& echo "deb http://archive.raspberrypi.org/debian bullseye main" > /etc/apt/sources.list.d/raspi.list \
&& wget -O- https://archive.raspberrypi.org/debian/raspberrypi.gpg.key | gpg --dearmor -o /etc/apt/trusted.gpg.d/raspberrypi.gpg \
&& rm -rf /var/lib/apt/lists/*
#################################################################
FROM --platform=linux/amd64 scratch AS base
COPY --from=base-arm-v7 / /linux/arm/v6
COPY --from=base-arm-v7 / /linux/arm/v7
COPY --from=base-arm64 / /linux/arm64
#################################################################
FROM scratch
ARG TARGETPLATFORM
COPY --from=base /$TARGETPLATFORM /
COPY --from=binaries /$TARGETPLATFORM /
ENTRYPOINT [ "/mediamtx" ]
================================================
FILE: docker/standard.Dockerfile
================================================
#################################################################
FROM --platform=linux/amd64 scratch AS binaries
ADD binaries/mediamtx_*_linux_amd64.tar.gz /linux/amd64
ADD binaries/mediamtx_*_linux_armv6.tar.gz /linux/arm/v6
ADD binaries/mediamtx_*_linux_armv7.tar.gz /linux/arm/v7
ADD binaries/mediamtx_*_linux_arm64.tar.gz /linux/arm64
#################################################################
FROM scratch
ARG TARGETPLATFORM
COPY --from=binaries /$TARGETPLATFORM /
ENTRYPOINT [ "/mediamtx" ]
================================================
FILE: docs/1-kickoff/1-introduction.md
================================================
# Introduction
Welcome to the MediaMTX documentation!
_MediaMTX_ is a ready-to-use and zero-dependency live media server and media proxy. It has been conceived as a "media router" that routes media streams from one end to the other, with a focus on efficiency and portability.
Main features:
- [Publish](../2-publish/01-overview.md) live streams to the server with SRT, WebRTC, RTSP, RTMP, HLS, MPEG-TS, RTP, using FFmpeg, GStreamer, OBS Studio, Python , Golang, Unity, Web browsers, Raspberry Pi Cameras and more.
- [Read](../3-read/01-overview.md) live streams from the server with SRT, WebRTC, RTSP, RTMP, HLS, using FFmpeg, GStreamer, VLC, OBS Studio, Python , Golang, Unity, Web browsers and more.
- Streams are automatically converted from a protocol to another
- Serve several streams at once in separate paths
- Reload the configuration without disconnecting existing clients (hot reloading)
- [Serve always-available streams](../4-other/05-always-available.md) even when the publisher is offline
- [Record](../4-other/06-record.md) streams to disk in fMP4 or MPEG-TS format
- [Playback](../4-other/07-playback.md) recorded streams
- [Authenticate](../4-other/03-authentication.md) users with internal, HTTP or JWT authentication
- [Forward](../4-other/08-forward.md) streams to other servers
- [Proxy](../4-other/09-proxy.md) requests to other servers
- [Control](../4-other/18-control-api.md) the server through the Control API
- [Extract metrics](../4-other/19-metrics.md) from the server in a Prometheus-compatible format
- [Monitor performance](../4-other/20-performance.md) to investigate CPU and RAM consumption
- [Run hooks](../4-other/17-hooks.md) (external commands) when clients connect, disconnect, read or publish streams
- Compatible with Linux, Windows and macOS, does not require any dependency or interpreter, it's a single executable
Use the menu to navigate through the documentation.
================================================
FILE: docs/1-kickoff/2-install.md
================================================
# Install
There are several installation methods available:
- [Standalone binary](#standalone-binary): use this if you are running Windows, macOS or you just want to try out _MediaMTX_.
- [Docker image](#docker-image): use this if you want to run _MediaMTX_ in an isolated and deterministic way. This is recommended for production environments.
- [Arch Linux package](#arch-linux-package): use this if you are running Arch Linux.
- [FreeBSD package](#freebsd-package): use this if you are running FreeBSD.
- [OpenWrt binary](#openwrt-binary): use this if you are running OpenWrt.
## Standalone binary
1. Visit the [Releases page](https://github.com/bluenviron/mediamtx/releases) on GitHub, download and extract a standalone binary that corresponds to your operating system and architecture (example: `mediamtx_{version_tag}_linux_amd64.tar.gz`).
2. Start the server by double clicking on `mediamtx` (`mediamtx.exe` on Windows) or writing in the terminal:
```sh
./mediamtx
```
## Docker image
Download and launch the `bluenviron/mediamtx:1` image with the following environment variables and ports:
```sh
docker run --rm -it \
-e MTX_RTSPTRANSPORTS=tcp \
-e MTX_WEBRTCADDITIONALHOSTS=192.168.x.x \
-p 8554:8554 \
-p 1935:1935 \
-p 8888:8888 \
-p 8889:8889 \
-p 8890:8890/udp \
-p 8189:8189/udp \
bluenviron/mediamtx:1
```
Fill the `MTX_WEBRTCADDITIONALHOSTS` environment variable with the IP that will be used to connect to the server.
The `MTX_RTSPTRANSPORTS=tcp` environment variable is meant to disable the UDP transport protocol of the RTSP server (which requires the real IP address and port of incoming UDP packets, that are sometimes replaced by the Docker network stack). If you want to use it, you need to bypass the Docker network stack through the `--network=host` flag (which is not compatible with Windows, macOS and Kubernetes):
```sh
docker run --rm -it --network=host bluenviron/mediamtx:1
```
There are four image variants:
| name | FFmpeg included | RPI Camera support |
| -------------------------------- | ------------------ | ------------------ |
| bluenviron/mediamtx:1 | :x: | :x: |
| bluenviron/mediamtx:1-ffmpeg | :heavy_check_mark: | :x: |
| bluenviron/mediamtx:1-rpi | :x: | :heavy_check_mark: |
| bluenviron/mediamtx:1-ffmpeg-rpi | :heavy_check_mark: | :heavy_check_mark: |
The `1` tag corresponds to the latest `1.x.x` release, that should guarantee backward compatibility when upgrading. It is also possible to bind the image to a specific release, by using the release name as tag (`bluenviron/mediamtx:{docker_version_tag}`).
The base image does not contain any utility, in order to minimize size and frequency of updates. If you need additional software (like curl, wget, GStreamer), you can build a custom image by creating a file named `Dockerfile` with this content:
```Dockerfile
FROM bluenviron/mediamtx:1 AS mediamtx
FROM ubuntu:24.04
COPY --from=mediamtx /mediamtx /
COPY --from=mediamtx /mediamtx.yml /
# add anything you need.
RUN apt update && apt install -y \
gstreamer1.0-tools
ENTRYPOINT [ "/mediamtx" ]
```
And then build it:
```sh
docker build . -t my-mediamtx
```
In particular, the custom image is using the official _MediaMTX_ image as a base stage, and then adds a Linux-based operating system on top of it. Since _MediaMTX_ binaries are not tied to a specific Linux distribution or version, you can use anything you like.
## Arch Linux package
If you are running the Arch Linux distribution, launch:
```sh
git clone https://aur.archlinux.org/mediamtx.git
cd mediamtx
makepkg -si
```
## FreeBSD package
Available via ports tree or using packages (2025Q2 and later) as listed below:
```sh
cd /usr/ports/multimedia/mediamtx && make install clean
pkg install mediamtx
```
## OpenWrt binary
If the architecture of the OpenWrt device is amd64, armv6, armv7 or arm64, use the [standalone binary method](#standalone-binary) and download a Linux binary that corresponds to your architecture.
Otherwise, [compile the server from source](../6-misc/1-compile.md).
================================================
FILE: docs/1-kickoff/3-upgrade.md
================================================
# Upgrade
If you have an existing _MediaMTX_ installation, you can upgrade it to the latest version. The procedure depends on how _MediaMTX_ was installed.
## Standalone binary
The standalone binary comes with an upgrade utility that can be launched with:
```sh
./mediamtx --upgrade
```
This will replace the _MediaMTX_ executable with its latest version. Privileges to write to the executable location are required.
## Docker image
Stop and remove the container:
```sh
docker stop id-of-mediamtx-container
docker rm id-of-mediamtx-container
```
Remove the _MediaMTX_ image from cache:
```sh
docker rm bluenviron/mediamtx:1
```
Then recreate the container as described in [Install](2-install.md#docker-image).
## Arch Linux package
Repeat the installation procedure.
## FreeBSD package
Repeat the installation procedure.
## OpenWrt binary
If the architecture of the OpenWrt device is amd64, armv6, armv7 or arm64, you can use the standalone binary method.
Otherwise, recompile the server from source.
================================================
FILE: docs/1-kickoff/4-basic-usage.md
================================================
# Basic usage
1. [Publish](../2-publish/01-overview.md) a stream. For instance, you can publish a stream from a MP4 file with _FFmpeg_:
```sh
ffmpeg -re -stream_loop -1 -i file.mp4 -c copy \
-f rtsp rtsp://localhost:8554/mystream
```
or _GStreamer_:
```sh
gst-launch-1.0 rtspclientsink name=s location=rtsp://localhost:8554/mystream filesrc location=file.mp4 \
! qtdemux name=d d.video_0 ! queue ! s.sink_0 d.audio_0 ! queue ! s.sink_1
```
2. [Read](../3-read/01-overview.md) the stream. For instance, you can read the stream with _VLC_:
```sh
vlc --network-caching=50 rtsp://localhost:8554/mystream
```
or _GStreamer_:
```sh
gst-play-1.0 rtsp://localhost:8554/mystream
```
or _FFmpeg_:
```sh
ffmpeg -i rtsp://localhost:8554/mystream -c copy output.mp4
```
================================================
FILE: docs/1-kickoff/index.md
================================================
# Kickoff
================================================
FILE: docs/2-publish/01-overview.md
================================================
# Publish a stream
Live streams can be published to the server with the following protocols and codecs:
| protocol | variants | codecs |
| ---------------------------------------------------------- | ------------------------------------------ | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
| [SRT clients](02-srt-clients.md) | | **Video**: H265, H264, MPEG-4 Video (H263, Xvid), MPEG-1/2 Video();
videoStream = sourceCamera.CaptureStream(videoWidth, videoHeight);
foreach (var track in videoStream.GetTracks())
{
pc.AddTrack(track);
}
StartCoroutine(WebRTC.Update());
StartCoroutine(createOffer());
}
private IEnumerator createOffer()
{
var op = pc.CreateOffer();
yield return op;
if (op.IsError) {
Debug.LogError("CreateOffer() failed");
yield break;
}
yield return setLocalDescription(op.Desc);
}
private IEnumerator setLocalDescription(RTCSessionDescription offer)
{
var op = pc.SetLocalDescription(ref offer);
yield return op;
if (op.IsError) {
Debug.LogError("SetLocalDescription() failed");
yield break;
}
yield return postOffer(offer);
}
private IEnumerator postOffer(RTCSessionDescription offer)
{
var content = new System.Net.Http.StringContent(offer.sdp);
content.Headers.ContentType = new System.Net.Http.Headers.MediaTypeHeaderValue("application/sdp");
var client = new System.Net.Http.HttpClient();
var task = System.Threading.Tasks.Task.Run(async () => {
var res = await client.PostAsync(new System.UriBuilder(url).Uri, content);
res.EnsureSuccessStatusCode();
return await res.Content.ReadAsStringAsync();
});
yield return new WaitUntil(() => task.IsCompleted);
if (task.Exception != null) {
Debug.LogError(task.Exception);
yield break;
}
yield return setRemoteDescription(task.Result);
}
private IEnumerator setRemoteDescription(string answer)
{
RTCSessionDescription desc = new RTCSessionDescription();
desc.type = RTCSdpType.Answer;
desc.sdp = answer;
var op = pc.SetRemoteDescription(ref desc);
yield return op;
if (op.IsError) {
Debug.LogError("SetRemoteDescription() failed");
yield break;
}
yield break;
}
void OnDestroy()
{
pc?.Close();
pc?.Dispose();
videoStream?.Dispose();
}
}
```
In the _Hierarchy_ window, find or create a scene and a camera, then add the `WebRTCPublisher.cs` script as component of the camera, by dragging it inside the _Inspector_ window. then Press the _Play_ button at the top of the page.
The resulting stream will be available on path `/unity`.
================================================
FILE: docs/2-publish/21-web-browsers.md
================================================
# Web browsers
Web browsers can publish a stream to the server by using the [WebRTC protocol](04-webrtc-clients.md). Start the server and open the web page:
```
http://localhost:8889/mystream/publish
```
The resulting stream will be available on path `/mystream`.
This web page can be embedded into another web page by using an iframe:
```html
```
For more advanced setups, you can create and serve a custom web page by starting from the [source code of the WebRTC publish page](https://github.com/bluenviron/mediamtx/blob/{version_tag}/internal/servers/webrtc/publish_index.html). In particular, there's a ready-to-use, standalone JavaScript class for publishing streams with WebRTC, available in [publisher.js](https://github.com/bluenviron/mediamtx/blob/{version_tag}/internal/servers/webrtc/publisher.js).
================================================
FILE: docs/2-publish/index.md
================================================
# Publish
================================================
FILE: docs/3-read/01-overview.md
================================================
# Read a stream
Live streams can be read from the server with the following protocols and codecs:
| protocol | variants | codecs |
| ------------------------------ | ------------------------------------------ | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
| [SRT clients](02-srt.md) | | **Video**: H265, H264, MPEG-4 Video (H263, Xvid), MPEG-1/2 Video();
AudioSource audioSource = gameObject.GetComponentInChildren();
pc = new RTCPeerConnection();
receiveStream = new MediaStream();
pc.OnTrack = e =>
{
receiveStream.AddTrack(e.Track);
};
receiveStream.OnAddTrack = e =>
{
if (e.Track is VideoStreamTrack videoTrack)
{
videoTrack.OnVideoReceived += (tex) =>
{
rawImage.texture = tex;
};
}
else if (e.Track is AudioStreamTrack audioTrack)
{
audioSource.SetTrack(audioTrack);
audioSource.loop = true;
audioSource.Play();
}
};
RTCRtpTransceiverInit init = new RTCRtpTransceiverInit();
init.direction = RTCRtpTransceiverDirection.RecvOnly;
pc.AddTransceiver(TrackKind.Audio, init);
pc.AddTransceiver(TrackKind.Video, init);
StartCoroutine(WebRTC.Update());
StartCoroutine(createOffer());
}
private IEnumerator createOffer()
{
var op = pc.CreateOffer();
yield return op;
if (op.IsError) {
Debug.LogError("CreateOffer() failed");
yield break;
}
yield return setLocalDescription(op.Desc);
}
private IEnumerator setLocalDescription(RTCSessionDescription offer)
{
var op = pc.SetLocalDescription(ref offer);
yield return op;
if (op.IsError) {
Debug.LogError("SetLocalDescription() failed");
yield break;
}
yield return postOffer(offer);
}
private IEnumerator postOffer(RTCSessionDescription offer)
{
var content = new System.Net.Http.StringContent(offer.sdp);
content.Headers.ContentType = new System.Net.Http.Headers.MediaTypeHeaderValue("application/sdp");
var client = new System.Net.Http.HttpClient();
var task = System.Threading.Tasks.Task.Run(async () => {
var res = await client.PostAsync(new System.UriBuilder(url).Uri, content);
res.EnsureSuccessStatusCode();
return await res.Content.ReadAsStringAsync();
});
yield return new WaitUntil(() => task.IsCompleted);
if (task.Exception != null) {
Debug.LogError(task.Exception);
yield break;
}
yield return setRemoteDescription(task.Result);
}
private IEnumerator setRemoteDescription(string answer)
{
RTCSessionDescription desc = new RTCSessionDescription();
desc.type = RTCSdpType.Answer;
desc.sdp = answer;
var op = pc.SetRemoteDescription(ref desc);
yield return op;
if (op.IsError) {
Debug.LogError("SetRemoteDescription() failed");
yield break;
}
yield break;
}
void OnDestroy()
{
pc?.Close();
pc?.Dispose();
receiveStream?.Dispose();
}
}
```
Edit the `url` variable according to your needs.
In the _Hierarchy_ window, find or create a scene. Inside the scene, add a _Canvas_. Inside the Canvas, add a _Raw Image_ and an _Audio Source_. Then add the `WebRTCReader.cs` script as component of the canvas, by dragging it inside the _Inspector_ window. then Press the _Play_ button at the top of the page.
================================================
FILE: docs/3-read/14-web-browsers.md
================================================
# Web browsers
Web browsers can read a stream from the server in several ways.
## Web browsers and WebRTC
You can read a stream by using the [WebRTC protocol](03-webrtc.md) by visiting the web page:
```
http://localhost:8889/mystream
```
See [Embed streams in a website](../4-other/14-embed-streams-in-a-website.md) for instructions on how to embed the stream into an external website.
## Web browsers and HLS
Web browsers can also read a stream with the [HLS protocol](06-hls.md). Latency is higher but there are fewer problems related to connectivity between server and clients, furthermore the server load can be balanced by using a common HTTP CDN (like Cloudflare or CloudFront), and this allows to handle an unlimited amount of readers. Visit the web page:
```
http://localhost:8888/mystream
```
See [Embed streams in a website](../4-other/14-embed-streams-in-a-website.md) for instructions on how to embed the stream into an external website.
================================================
FILE: docs/3-read/index.md
================================================
# Read
================================================
FILE: docs/4-other/02-configuration.md
================================================
# Configuration
All the configuration parameters are listed and commented in the [configuration file](../5-references/1-configuration-file.md) (`mediamtx.yml`).
## Change the configuration
There are several ways to change the configuration:
1. By editing the configuration file, that is
- included into the release bundle
- available in the root folder of the Docker image (`/mediamtx.yml`); it can be overridden in this way:
```sh
docker run --rm -it --network=host -v "$PWD/mediamtx.yml:/mediamtx.yml:ro" bluenviron/mediamtx:1
```
The configuration can be changed dynamically when the server is running (hot reloading) by writing to the configuration file. Changes are detected and applied without disconnecting existing clients, whenever it's possible.
2. By overriding configuration parameters with environment variables, in the format `MTX_PARAMNAME`, where `PARAMNAME` is the uppercase name of a parameter. For instance, the `rtspAddress` parameter can be overridden in the following way:
```
MTX_RTSPADDRESS="127.0.0.1:8554" ./mediamtx
```
Parameters that have array as value can be overridden by setting a comma-separated list. For example:
```
MTX_RTSPTRANSPORTS="tcp,udp"
```
Parameters in maps can be overridden by using underscores, in the following way:
```
MTX_PATHS_TEST_SOURCE=rtsp://myurl ./mediamtx
```
Parameters in lists can be overridden in the same way as parameters in maps, using their position like an additional key. This is particularly useful if you want to use internal users but define credentials through environment variables:
```
MTX_AUTHINTERNALUSERS_0_USER=username
MTX_AUTHINTERNALUSERS_0_PASS=password
```
This method is particularly useful when using Docker; any configuration parameter can be changed by passing environment variables with the `-e` flag:
```
docker run --rm -it --network=host -e MTX_PATHS_TEST_SOURCE=rtsp://myurl bluenviron/mediamtx:1
```
3. By using the [Control API](18-control-api.md).
## Encrypt the configuration
The configuration file can be entirely encrypted for security purposes by using the `crypto_secretbox` function of the NaCL function. An online tool for performing this operation is [available here](https://play.golang.org/p/rX29jwObNe4).
After performing the encryption, put the base64-encoded result into the configuration file, and launch the server with the `MTX_CONFKEY` variable:
```
MTX_CONFKEY=mykey ./mediamtx
```
================================================
FILE: docs/4-other/03-authentication.md
================================================
# Authentication
_MediaMTX_ can be configured to ask clients for credentials, either in the form of username/password or a string-based token. These credentials are then validated through a chosen method.
## Credential validation
Credentials can be validated through one of these methods:
- Internal database: credentials are stored in the configuration file
- External HTTP server: an external HTTP URL is contacted to perform authentication
- External JWT provider: an external identity server provides signed tokens that are then verified by the server
### Internal database
The internal authentication method is the default one. Users are stored inside the configuration file, in this format:
```yml
authInternalUsers:
# Username. 'any' means any user, including anonymous ones.
- user: any
# Password. Not used in case of 'any' user.
pass:
# IPs or networks allowed to use this user. An empty list means any IP.
ips: []
# Permissions.
permissions:
# Available actions are: publish, read, playback, api, metrics, pprof.
- action: publish
# Paths can be set to further restrict access to a specific path.
# An empty path means any path.
# Regular expressions can be used by using a tilde as prefix.
path:
- action: read
path:
- action: playback
path:
```
Only clients that provide a valid username and password will be able to perform a certain action.
If storing plain credentials in the configuration file is a security problem, username and passwords can be stored as hashed strings. The Argon2 and SHA256 hashing algorithms are supported. To use Argon2, the string must be hashed using Argon2id (recommended) or Argon2i:
```
echo -n "mypass" | argon2 saltItWithSalt -id -l 32 -e
```
Then stored with the `argon2:` prefix:
```yml
authInternalUsers:
- user: argon2:$argon2id$v=19$m=4096,t=3,p=1$MTIzNDU2Nzg$OGGO0eCMN0ievb4YGSzvS/H+Vajx1pcbUmtLp2tRqRU
pass: argon2:$argon2i$v=19$m=4096,t=3,p=1$MTIzNDU2Nzg$oct3kOiFywTdDdt19kT07hdvmsPTvt9zxAUho2DLqZw
permissions:
- action: publish
```
To use SHA256, the string must be hashed with SHA256 and encoded with base64:
```
echo -n "mypass" | openssl dgst -binary -sha256 | openssl base64
```
Then stored with the `sha256:` prefix:
```yml
authInternalUsers:
- user: sha256:j1tsRqDEw9xvq/D7/9tMx6Jh/jMhk3UfjwIB2f1zgMo=
pass: sha256:BdSWkrdV+ZxFBLUQQY7+7uv9RmiSVA8nrPmjGjJtZQQ=
permissions:
- action: publish
```
**WARNING**: enable encryption or use a VPN to ensure that no one is intercepting the credentials in transit.
### External HTTP server
Authentication can be delegated to an external HTTP server:
```yml
authMethod: http
authHTTPAddress: http://myauthserver/auth
```
Each time a user needs to be authenticated, the specified URL will be requested with the POST method and this payload:
```json
{
"user": "user",
"password": "password",
"token": "token",
"ip": "ip",
"action": "publish|read|playback|api|metrics|pprof",
"path": "path",
"protocol": "rtsp|rtmp|hls|webrtc|srt",
"id": "id",
"query": "query"
}
```
If the URL returns a status code that begins with `20` (i.e. `200`), authentication is successful, otherwise it fails. Be aware that it's perfectly normal for the authentication server to receive requests with empty users and passwords, i.e.:
```json
{
"user": "",
"password": ""
}
```
This happens because RTSP clients don't provide credentials until they are asked to. In order to receive the credentials, the authentication server must reply with status code `401`, then the client will send credentials.
Some actions can be excluded from the process:
```yml
# Actions to exclude from HTTP-based authentication.
# Format is the same as the one of user permissions.
authHTTPExclude:
- action: api
- action: metrics
- action: pprof
```
If the authentication server uses HTTPS and has a self-signed or invalid TLS certificate, you can provide the fingerprint of the certificate to validate it anyway:
```yml
authMethod: http
authHTTPAddress: https://myauthserver/auth
authHTTPFingerprint: 33949e05fffb5ff3e8aa16f8213a6251b4d9363804ba53233c4da9a46d6f2739
```
The fingerprint can be obtained with:
```sh
openssl s_client -connect myauthserver:443 /dev/null | sed -n '/BEGIN/,/END/p' > server.crt
openssl x509 -in server.crt -noout -fingerprint -sha256 | cut -d "=" -f2 | tr -d ':'
```
### External JWT provider
Authentication can be delegated to an external identity server, that is capable of generating JWTs and provides a JWKS endpoint. With respect to the HTTP-based method, this has the advantage that the external server is contacted once, and not for every request, greatly improving performance. In order to use the JWT-based authentication method, set `authMethod` and `authJWTJWKS`:
```yml
authMethod: jwt
authJWTJWKS: http://my_identity_server/jwks_endpoint
authJWTClaimKey: mediamtx_permissions
```
Users are expected to pass the encoded JWT as token.
The JWT is expected to contain a claim, with a list of permissions in the same format as the one of user permissions:
```json
{
"mediamtx_permissions": [
{
"action": "publish",
"path": ""
}
]
}
```
If the JWKS server uses TLS and has a self-signed or invalid TLS certificate, you can provide the fingerprint of the certificate to validate it anyway:
```yml
authMethod: jwt
authJWTJWKS: https://my_identity_server/jwks_endpoint
authJWTJWKSFingerprint: 33949e05fffb5ff3e8aa16f8213a6251b4d9363804ba53233c4da9a46d6f2739
authJWTClaimKey: mediamtx_permissions
```
The fingerprint can be obtained with:
```sh
openssl s_client -connect my_identity_server:443 /dev/null | sed -n '/BEGIN/,/END/p' > server.crt
openssl x509 -in server.crt -noout -fingerprint -sha256 | cut -d "=" -f2 | tr -d ':'
```
Optionally, the JWT `iss` (issuer) and `aud` (audience) claims can be validated by setting `authJWTIssuer` and `authJWTAudience`. When set, tokens that don't contain the expected values will be rejected:
```yml
authMethod: jwt
authJWTJWKS: http://my_identity_server/jwks_endpoint
authJWTClaimKey: mediamtx_permissions
authJWTIssuer: http://my_identity_server
authJWTAudience: mediamtx
```
Leave these fields empty to skip validation of the respective claims.
#### Keycloak setup
Here's a tutorial on how to setup the [Keycloak identity server](https://www.keycloak.org/) in order to provide JWTs.
1. Start Keycloak:
```sh
docker run --name=keycloak -p 8080:8080 \
-e KEYCLOAK_ADMIN=admin -e KEYCLOAK_ADMIN_PASSWORD=admin \
quay.io/keycloak/keycloak:23.0.7 start-dev
```
2. Open the Keycloak web UI on http://localhost:8080, click on _Administration Console_ and log in.
3. Click on _master_ in the top left corner, _Create realm_, set realm name to `mediamtx`, _Create_.
4. Open page _Client scopes_, _Create client scope_, set name to `mediamtx`, _Save_.
5. Open tab _Mappers_, _Configure a new Mapper_, _User Attribute_:
- Name: `mediamtx_permissions`
- User Attribute: `mediamtx_permissions`
- Token Claim Name: `mediamtx_permissions`
- Claim JSON Type: `JSON`
- Multivalued: `On`
Save.
6. Open page _Clients_, _Create client_, set Client ID to `mediamtx`, _Next_, _Client authentication_ `On`, _Next_, _Save_.
7. Open tab _Credentials_, copy client secret somewhere.
8. Open tab _Client scopes_, set _Assigned type_ of all existing client scopes to _Optional_. This decreases the length of the JWT, since many clients impose limits on it.
9. In tab _Client scopes_, _Add client scope_, Select `mediamtx`, _Add_, _Default_.
10. Open page _Users_, _Add user_, Username `testuser`, _Create_, Tab _Credentials_, _Set password_, pick a password, _Save_.
11. Open tab _Attributes_, _Add an attribute_:
- Key: `mediamtx_permissions`
- Value: `{"action":"publish", "path": ""}`
You can add as many attributes with key `mediamtx_permissions` as you want, each with a single permission in it.
12. In MediaMTX, use the following JWKS URL:
```yml
authJWTJWKS: http://localhost:8080/realms/mediamtx/protocol/openid-connect/certs
```
13. Perform authentication on Keycloak:
```
curl \
-d "client_id=mediamtx" \
-d "client_secret=$CLIENT_SECRET" \
-d "username=$USER" \
-d "password=$PASS" \
-d "grant_type=password" \
http://localhost:8080/realms/mediamtx/protocol/openid-connect/token
```
The JWT is inside the `access_token` key of the response:
```json
{
"access_token": "eyJhbGciOiJSUzI1NiIsInR5cCIgOiAiSldUIiwia2lkIiA6ICIyNzVjX3ptOVlOdHQ0TkhwWVk4Und6ZndUclVGSzRBRmQwY3lsM2wtY3pzIn0.eyJleHAiOjE3MDk1NTUwOTIsImlhdCI6MTcwOTU1NDc5MiwianRpIjoiMzE3ZTQ1NGUtNzczMi00OTM1LWExNzAtOTNhYzQ2ODhhYWIxIiwiaXNzIjoiaHR0cDovL2xvY2FsaG9zdDo4MDgwL3JlYWxtcy9tZWRpYW10eCIsImF1ZCI6ImFjY291bnQiLCJzdWIiOiI2NTBhZDA5Zi03MDgxLTQyNGItODI4Ni0xM2I3YTA3ZDI0MWEiLCJ0eXAiOiJCZWFyZXIiLCJhenAiOiJtZWRpYW10eCIsInNlc3Npb25fc3RhdGUiOiJjYzJkNDhjYy1kMmU5LTQ0YjAtODkzZS0wYTdhNjJiZDI1YmQiLCJhY3IiOiIxIiwiYWxsb3dlZC1vcmlnaW5zIjpbIi8qIl0sInJlYWxtX2FjY2VzcyI6eyJyb2xlcyI6WyJvZmZsaW5lX2FjY2VzcyIsInVtYV9hdXRob3JpemF0aW9uIiwiZGVmYXVsdC1yb2xlcy1tZWRpYW10eCJdfSwicmVzb3VyY2VfYWNjZXNzIjp7ImFjY291bnQiOnsicm9sZXMiOlsibWFuYWdlLWFjY291bnQiLCJtYW5hZ2UtYWNjb3VudC1saW5rcyIsInZpZXctcHJvZmlsZSJdfX0sInNjb3BlIjoibWVkaWFtdHggcHJvZmlsZSBlbWFpbCIsInNpZCI6ImNjMmQ0OGNjLWQyZTktNDRiMC04OTNlLTBhN2E2MmJkMjViZCIsImVtYWlsX3ZlcmlmaWVkIjpmYWxzZSwibWVkaWFtdHhfcGVybWlzc2lvbnMiOlt7ImFjdGlvbiI6InB1Ymxpc2giLCJwYXRocyI6ImFsbCJ9XSwicHJlZmVycmVkX3VzZXJuYW1lIjoidGVzdHVzZXIifQ.Gevz7rf1qHqFg7cqtSfSP31v_NS0VH7MYfwAdra1t6Yt5rTr9vJzqUeGfjYLQWR3fr4XC58DrPOhNnILCpo7jWRdimCnbPmuuCJ0AYM-Aoi3PAsWZNxgmtopq24_JokbFArY9Y1wSGFvF8puU64lt1jyOOyxf2M4cBHCs_EarCKOwuQmEZxSf8Z-QV9nlfkoTUszDCQTiKyeIkLRHL2Iy7Fw7_T3UI7sxJjVIt0c6HCNJhBBazGsYzmcSQ_GrmhbUteMTg00o6FicqkMBe99uZFnx9wIBm_QbO9hbAkkzF923I-DTAQrFLxT08ESMepDwmzFrmnwWYBLE3u8zuUlCA",
"expires_in": 300,
"refresh_expires_in": 1800,
"refresh_token": "eyJhbGciOiJIUzI1NiIsInR5cCIgOiAiSldUIiwia2lkIiA6ICI3OTI3Zjg4Zi05YWM4LTRlNmEtYWE1OC1kZmY0MDQzZDRhNGUifQ.eyJleHAiOjE3MDk1NTY1OTIsImlhdCI6MTcwOTU1NDc5MiwianRpIjoiMGVhZWFhMWItYzNhMC00M2YxLWJkZjAtZjI2NTRiODlkOTE3IiwiaXNzIjoiaHR0cDovL2xvY2FsaG9zdDo4MDgwL3JlYWxtcy9tZWRpYW10eCIsImF1ZCI6Imh0dHA6Ly9sb2NhbGhvc3Q6ODA4MC9yZWFsbXMvbWVkaWFtdHgiLCJzdWIiOiI2NTBhZDA5Zi03MDgxLTQyNGItODI4Ni0xM2I3YTA3ZDI0MWEiLCJ0eXAiOiJSZWZyZXNoIiwiYXpwIjoibWVkaWFtdHgiLCJzZXNzaW9uX3N0YXRlIjoiY2MyZDQ4Y2MtZDJlOS00NGIwLTg5M2UtMGE3YTYyYmQyNWJkIiwic2NvcGUiOiJtZWRpYW10eCBwcm9maWxlIGVtYWlsIiwic2lkIjoiY2MyZDQ4Y2MtZDJlOS00NGIwLTg5M2UtMGE3YTYyYmQyNWJkIn0.yuXV8_JU0TQLuosNdp5xlYMjn7eO5Xq-PusdHzE7bsQ",
"token_type": "Bearer",
"not-before-policy": 0,
"session_state": "cc2d48cc-d2e9-44b0-893e-0a7a62bd25bd",
"scope": "mediamtx profile email"
}
```
## Providing username and password
### RTSP
Prepend username and password and a `@` to the host:
```
rtsp rtsp://myuser:mypass@localhost:8554/mystream
```
### RTMP
Use the `user` and `pass` query parameters:
```
rtmp://localhost/mystream?user=myuser&pass=mypass
```
### SRT
Append username and password to `streamid`:
```
srt://localhost:8890?streamid=publish:mystream:user:pass&pkt_size=1316
```
### HLS and WebRTC
Username and password can be passed through the `Authorization: Basic` HTTP header:
```
Authorization: Basic base64(user:pass)
```
When using a web browser, a dialog is first shown to users, asking for credentials, and then the header is automatically inserted into every request. If you need to automatically fill credentials from a parent web page, read [Embed streams in a website](14-embed-streams-in-a-website.md).
If the `Authorization: Basic` header cannot be used (for instance, in software like OBS Studio, which only allows to provide a "Bearer Token"), credentials can be passed through the `Authorization: Bearer` header (i.e. the "Bearer Token" in OBS), where the value is the concatenation of username and password, separated by a colon:
```
Authorization: Bearer username:password
```
## Providing tokens / JWTs
### RTSP
Pass the token as a query parameter:
```
rtsp://localhost:8554/mystream?jwt=jwt
```
WARNING: FFmpeg implementation of RTSP does not support URLs that are longer than 4096 characters (this is the [MAX_URL_SIZE constant](https://github.com/FFmpeg/FFmpeg/blob/f951aa9ef382d6bb517e05d04d52710f751de427/libavformat/internal.h#L30)), therefore you have to configure your identity server in order to produce JWTs that are shorter than this threshold.
### RTMP
Pass the token as a query parameter:
```
rtmp://localhost/mystream?jwt=jwt
```
WARNING: FFmpeg implementation of RTMP does not support URLs that are longer than 1024 characters (this is the [TCURL_MAX_LENGTH constant](https://github.com/FFmpeg/FFmpeg/blob/f951aa9ef382d6bb517e05d04d52710f751de427/libavformat/rtmpproto.c#L55)), therefore you have to configure your identity server in order to produce JWTs that are shorter than this threshold.
### SRT
Pass the token as password, with an arbitrary user:
```
srt://localhost:8890?streamid=publish:mystream:user:jwt&pkt_size=1316
```
WARNING: SRT does not support Stream IDs that are longer than 512 characters, therefore you have to configure your identity server in order to produce JWTs that are shorter than this threshold.
### HLS and WebRTC
The token can be passed through the `Authorization: Bearer` header:
```
Authorization: Bearer MY_JWT
```
In OBS Studio, this is the "Bearer Token" field.
If the `Authorization: Bearer` token cannot be directly provided (for instance, with web browsers that directly access _MediaMTX_ and show a credential dialog), you can pass the token as password, using an arbitrary user.
In web browsers, if you need to automatically fill credentials from a parent web page, read [Embed streams in a website](14-embed-streams-in-a-website.md).
================================================
FILE: docs/4-other/04-remuxing-reencoding-compression.md
================================================
# Re-encoding
To change the format, codec or compression of a stream, use _FFmpeg_ or _GStreamer_ together with _MediaMTX_. For instance, to re-encode an existing stream, that is available in the `/original` path, and publish the resulting stream in the `/compressed` path, edit `mediamtx.yml` and replace everything inside section `paths` with the following content:
```yml
paths:
compressed:
original:
runOnReady: >
ffmpeg -i rtsp://localhost:$RTSP_PORT/$MTX_PATH
-c:v libx264 -pix_fmt yuv420p -preset ultrafast -b:v 600k
-max_muxing_queue_size 1024 -f rtsp rtsp://localhost:$RTSP_PORT/compressed
runOnReadyRestart: yes
```
================================================
FILE: docs/4-other/05-always-available.md
================================================
# Always-available
When the publisher or source of a stream is offline, the server can be configured to fill gaps in the stream with an offline segment that is played on repeat until a publisher comes back online. This allows readers to stay connected regardless of the state of the stream. The offline segment and online stream are concatenated without re-encoding any frame, using the original codec.
This feature can be enabled by toggling the `alwaysAvailable` flag and filling `alwaysAvailableTracks`:
```yml
paths:
mypath:
alwaysAvailable: true
alwaysAvailableTracks:
# Available values are: AV1, VP9, H265, H264, Opus, MPEG4Audio, G711, LPCM
- codec: H264
# in case of MPEG4Audio, G711, LPCM, sampleRate and ChannelCount must be provided too.
# sampleRate: 48000
# channelCount: 2
# in case of G711, muLaw must be provided too.
# muLaw: false
```
By default, the server uses a default offline segment with the text "STREAM IS OFFLINE". The segment can be replaced with an external MP4 file:
```yml
paths:
mypath:
alwaysAvailable: true
alwaysAvailableFile: "./h264.mp4"
```
================================================
FILE: docs/4-other/06-record.md
================================================
# Record
Live streams be recorded to disk and played back with the following file containers and codecs:
| container | codecs |
| --------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| fMP4 | **Video**: AV1, VP9, H265, H264, MPEG-4 Video (H263, Xvid), MPEG-1/2 Video, M-JPEG tag:
```html
```
The fMP4 format may offer limited compatibility with some players. To fix the issue, it's possible to use the standard MP4 format, by adding `format=mp4` to a `/get` request:
```
http://localhost:9996/get?path=[mypath]&start=[start_date]&duration=[duration]&format=mp4
```
================================================
FILE: docs/4-other/08-forward.md
================================================
# Forward
To forward incoming streams to another server, use _FFmpeg_ inside the `runOnReady` parameter:
```yml
pathDefaults:
runOnReady: >
ffmpeg -i rtsp://localhost:$RTSP_PORT/$MTX_PATH
-c copy
-f rtsp rtsp://other-server:8554/another-path
runOnReadyRestart: yes
```
================================================
FILE: docs/4-other/09-proxy.md
================================================
# Proxy
The server allows to proxy incoming requests to other servers or cameras. This is useful to expose servers or cameras behind a NAT. Edit `mediamtx.yml` and replace everything inside section `paths` with the following content:
```yml
paths:
"~^proxy_(.+)$":
# If path name is a regular expression, $G1, $G2, etc will be replaced
# with regular expression groups.
source: rtsp://other-server:8554/$G1
sourceOnDemand: yes
```
All requests addressed to `rtsp://server:8854/proxy_a` will be forwarded to `rtsp://other-server:8854/a` and so on.
================================================
FILE: docs/4-other/10-extract-snapshots.md
================================================
# Extract snapshots
You can periodically extract snapshots from available streams by using FFmpeg inside the `runOnReady` hook:
```yml
pathDefaults:
runOnReady: |
bash -c "
while true; do
mkdir -p $(dirname snapshots/$MTX_PATH)
ffmpeg -i rtsp://localhost:8554/$MTX_PATH -frames:v 1 -update true -y snapshots/$MTX_PATH.jpg
sleep 10
done"
```
Where `10` is the interval between snapshots.
================================================
FILE: docs/4-other/11-on-demand-publishing.md
================================================
# On-demand publishing
Edit `mediamtx.yml` and replace everything inside section `paths` with the following content:
```yml
paths:
ondemand:
runOnDemand: ffmpeg -re -stream_loop -1 -i file.mp4 -c copy -f rtsp rtsp://localhost:$RTSP_PORT/$MTX_PATH
runOnDemandRestart: yes
```
The command inserted into `runOnDemand` will start only when a client requests the path `ondemand`, therefore the file will start streaming only when requested.
================================================
FILE: docs/4-other/12-absolute-timestamps.md
================================================
# Route absolute timestamps
Some streaming protocols allow to route absolute timestamps, associated with each frame, that are useful for synchronizing several video or data streams together. In particular, _MediaMTX_ supports receiving absolute timestamps with the following protocols and devices:
- HLS
- RTSP
- WebRTC
- Raspberry Pi Camera
and supports sending absolute timestamps with the following protocols:
- HLS
- RTSP
- WebRTC
By default, absolute timestamps of incoming frames are not used, instead they are replaced with the system timestamp. This prevents users from arbitrarily changing recording dates, and also allows to support sources that do not send absolute timestamps. It is possible to preserve original absolute timestamps by toggling the `useAbsoluteTimestamp` parameter:
```yml
pathDefaults:
# Use absolute timestamp of frames, instead of replacing them with the current time.
useAbsoluteTimestamp: false
```
## Absolute timestamp in HLS
In the HLS protocol, absolute timestamps are routed by adding a `EXT-X-PROGRAM-DATE-TIME` tag before each segment:
```
#EXTM3U
#EXT-X-VERSION:9
#EXT-X-MEDIA-SEQUENCE:20
#EXT-X-TARGETDURATION:2
#EXT-X-PROGRAM-DATE-TIME:2015-02-05T01:02:00Z
#EXTINF:2,
segment1.mp4
#EXT-X-PROGRAM-DATE-TIME:2015-02-05T01:04:00Z
#EXTINF:2,
segment2.mp4
```
The `EXT-X-PROGRAM-DATE-TIME` value is the absolute timestamp that corresponds to the first frame of the segment. The absolute timestamp of following frames can be obtained by summing `EXT-X-PROGRAM-DATE-TIME` with the relative frame timestamp.
A library that can read absolute timestamps with HLS is [gohlslib](https://github.com/bluenviron/gohlslib).
## Absolute timestamp in RTSP and WebRTC
In RTSP and WebRTC, absolute timestamps are routed through periodic RTCP sender reports:
```
0 1 2 3
0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
header |V=2|P| RC | PT=SR=200 | length |
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
| SSRC of sender |
+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+
sender | NTP timestamp, most significant word |
info +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
| NTP timestamp, least significant word |
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
| RTP timestamp |
...
```
The sender report contains a reference absolute timestamp (NTP timestamp) and a reference relative timestamp (RTP timestamp). The absolute timestamp of each frame can be computed by using these values together with the RTP timestamp of the frame (shipped with each frame), through the formula:
```
frame_abs_timestamp = ref_ntp_timestamp + (frame_rtp_timestamp - ref_rtp_timestamp) / clock_rate
```
A library that can read absolute timestamps with RTSP is [gortsplib](https://github.com/bluenviron/gortsplib).
A browser can read absolute timestamps with WebRTC if it exposes the [estimatedPlayoutTimestamp](https://www.w3.org/TR/webrtc-stats/#dom-rtcinboundrtpstreamstats-estimatedplayouttimestamp) statistic.
================================================
FILE: docs/4-other/13-expose-the-server-in-a-subfolder.md
================================================
# Expose the server in a subfolder
HTTP-based services (WebRTC, HLS, Control API, Playback Server, Metrics, pprof) can be exposed in a subfolder of an existing HTTP server or reverse proxy. The reverse proxy must be able to intercept HTTP requests addressed to _MediaMTX_ and corresponding responses, and perform the following changes:
- The subfolder path must be stripped from request paths. For instance, if the server is exposed behind `/subpath` and the reverse proxy receives a request with path `/subpath/mystream/index.m3u8`, this has to be changed into `/mystream/index.m3u8`.
- Any `Location` header in responses must be prefixed with the subfolder path. For instance, if the server is exposed behind `/subpath` and the server sends a response with `Location: /mystream/index.m3u8`, this has to be changed into `Location: /subfolder/mystream/index.m3u8`.
If _nginx_ is the reverse proxy, this can be achieved with the following configuration:
```
location /subpath/ {
proxy_pass http://mediamtx-ip:8889/;
proxy_redirect / /subpath/;
}
```
If _Apache HTTP Server_ is the reverse proxy, this can be achieved with the following configuration:
```
ProxyPass http://mediamtx-ip:8889
ProxyPassReverse http://mediamtx-ip:8889
Header edit Location ^(.*)$ "/subpath$1"
```
If _Caddy_ is the reverse proxy, this can be achieved with the following configuration:
```
:80 {
handle_path /subpath/* {
reverse_proxy {
to mediamtx-ip:8889
header_down Location ^/ /subpath/
}
}
}
```
================================================
FILE: docs/4-other/14-embed-streams-in-a-website.md
================================================
# Embed streams in a website
Live streams can be embedded into an external website by using the WebRTC or HLS protocol. Before embedding, check that the stream is ready and can be accessed with intended protocol by using URLs mentioned in [Read a stream](../3-read/01-overview.md).
## WebRTC in iframe
The simplest way to embed a live stream in a web page, using the WebRTC protocol, consists in adding an `
```
The iframe can be controlled by adding query parameters to the URL (example: `http://mediamtx-ip:8889/mystream?muted=false`). The following parameters are available:
- `controls` (boolean): whether to show controls. Default is true.
- `muted` (boolean): whether to start the stream muted. Default is true.
- `autoplay` (boolean): whether to autoplay the stream. Default is true.
- `playsInline` (boolean): whether to play the stream without using the entire window of mobile devices. Default is true.
- `disablepictureinpicture` (boolean): whether to disable the ability to open the stream in a dedicated window. Default is false.
The iframe method is fit for most use cases, but it has some limitations:
- it doesn't allow to pass credentials (username, password or token) from the website to _MediaMTX_; credentials are asked directly to users.
- it doesn't allow to directly access the video tag, to extract data from it, or to perform dynamic actions.
## WebRTC with JavaScript
In order to overcome the limitations of the iframe-based method, it is possible to load the stream directly inside a `` tag in the web page, through a JavaScript library.
Download [reader.js](https://github.com/bluenviron/mediamtx/blob/{version_tag}/internal/servers/webrtc/reader.js) from the repository and serve it together with the other assets of the website.
If you are using a JavaScript bundler, you can import it by using:
```js
import "./reader.js";
```
Otherwise, you can add a `
```
Add a `` tag:
```html
` tag in the web page, through the _hls.js_ library.
If you are using a JavaScript bundler, you can import _hls.js_ by adding [its npm package](https://www.npmjs.com/package/hls.js) as dependency and then importing it:
```js
import Hls from "hls.js";
```
Otherwise, you can use a `
```
Add a `` tag:
```html
mediamtx
mediamtx
%BASE%/mediamtx.exe
```
Open a terminal, navigate to the folder and run:
```
WinSW-x64 install
```
The server is now installed as a system service and will start at boot time.
================================================
FILE: docs/4-other/16-logging.md
================================================
# Logging
## Log verbosity
Log verbosity can be set with the `logLevel` parameter:
```yml
# Verbosity of the program; available values are "error", "warn", "info", "debug".
logLevel: info
```
## Log destinations
Log entries can be sent to multiple destinations. By default, they are printed on the console (stdout).
It is possible to write logs to a file by using these parameters:
```yml
# Destinations of log messages; available values are "stdout", "file" and "syslog".
logDestinations: [file]
# If "file" is in logDestinations, this is the file which will receive the logs.
logFile: mediamtx.log
```
It is possible to write logs to the system logging server (syslog) by using these parameters:
```yml
# Destinations of log messages; available values are "stdout", "file" and "syslog".
logDestinations: [syslog]
# If "syslog" is in logDestinations, use prefix for logs.
sysLogPrefix: mediamtx
```
Log entries can be queried by using:
```sh
journalctl SYSLOG_IDENTIFIER=mediamtx
```
If _MediaMTX_ is also running as a [system service](15-start-on-boot.md), log entries can be queried by using:
```sh
journalctl -u mediamtx
```
## Structured logging
Log collectors (like Loki, Logstash, CloudWatch and fluentd) parse logs in a more reliable way if they are fed with entries in structured format (JSONL). This can be enabled with the `logStructured` parameter:
```yml
# When destination is "stdout" or "file", emit logs in structured format (JSONL).
logStructured: true
```
Obtaining:
```
{"timestamp":"20XX-YY-ZZT10:45:05.999999999+01:00","level":"INF","message":"[RTSP] listener opened on :8554 (TCP), :8000 (UDP/RTP), :8001 (UDP/RTCP)"}
{"timestamp":"20XX-YY-ZZT10:45:05.999999999+01:00","level":"INF","message":"[RTMP] listener opened on :1935"}
{"timestamp":"20XX-YY-ZZT10:45:05.999999999+01:00","level":"INF","message":"[HLS] listener opened on :8888"}
{"timestamp":"20XX-YY-ZZT10:45:05.999999999+01:00","level":"INF","message":"[WebRTC] listener opened on :8889 (HTTP), :8189 (ICE/UDP)"}
{"timestamp":"20XX-YY-ZZT10:45:05.999999999+01:00","level":"INF","message":"[SRT] listener opened on :8890 (UDP)"}
```
## Log file rotation
The log file can be periodically rotated or truncated by using an external utility.
On most Linux distributions, the `logrotate` utility is in charge of managing log files. It can be configured to handle the _MediaMTX_ log file too by creating a configuration file, placed in `/etc/logrotate.d/mediamtx`, with this content:
```
/my/mediamtx/path/mediamtx.log {
daily
copytruncate
rotate 7
compress
delaycompress
missingok
notifempty
}
```
This file will rotate the log file every day, adding a `.NUMBER` suffix to older copies:
```
mediamtx.log.1
mediamtx.log.2
mediamtx.log.3
...
```
================================================
FILE: docs/4-other/17-hooks.md
================================================
# Hooks
The server allows to specify commands that are executed when a certain event happens, allowing the propagation of events to external software.
## runOnConnect
`runOnConnect` allows to run a command when a client connects to the server:
```yml
# Command to run when a client connects to the server.
# This is terminated with SIGINT when a client disconnects from the server.
# The following environment variables are available:
# * MTX_CONN_TYPE: connection type
# * MTX_CONN_ID: connection ID
# * RTSP_PORT: RTSP server port
runOnConnect: curl http://my-custom-server/webhook?conn_type=$MTX_CONN_TYPE&conn_id=$MTX_CONN_ID
# Restart the command if it exits.
runOnConnectRestart: no
```
## runOnDisconnect
`runOnDisconnect` allows to run a command when a client disconnects from the server:
```yml
# Command to run when a client disconnects from the server.
# Environment variables are the same as runOnConnect.
runOnDisconnect: curl http://my-custom-server/webhook?conn_type=$MTX_CONN_TYPE&conn_id=$MTX_CONN_ID
```
## runOnInit
`runOnInit` allows to run a command when a path is initialized. This can be used to publish a stream when the server is launched:
```yml
paths:
mypath:
# Command to run when this path is initialized.
# This can be used to publish a stream when the server is launched.
# The following environment variables are available:
# * MTX_PATH: path name
# * RTSP_PORT: RTSP server port
# * G1, G2, ...: regular expression groups, if path name is
# a regular expression.
runOnInit: ffmpeg -i my_file.mp4 -c copy -f rtsp rtsp://localhost:8554/mypath
# Restart the command if it exits.
runOnInitRestart: no
```
## runOnDemand
`runOnDemand` allows to run a command when a path is requested by a reader. This can be used to publish a stream on demand:
```yml
pathDefaults:
# Command to run when this path is requested by a reader
# and no one is publishing to this path yet.
# This is terminated with SIGINT when there are no readers anymore.
# The following environment variables are available:
# * MTX_PATH: path name
# * MTX_QUERY: query parameters (passed by first reader)
# * RTSP_PORT: RTSP server port
# * G1, G2, ...: regular expression groups, if path name is
# a regular expression.
runOnDemand: ffmpeg -i my_file.mp4 -c copy -f rtsp rtsp://localhost:8554/mypath
# Restart the command if it exits.
runOnDemandRestart: no
```
## runOnUnDemand
`runOnUnDemand` allows to run a command when there are no readers anymore:
```yml
pathDefaults:
# Command to run when there are no readers anymore.
# Environment variables are the same as runOnDemand.
runOnUnDemand:
```
## runOnReady
`runOnReady` allows to run a command when a stream is ready to be read:
```yml
pathDefaults:
# Command to run when the stream is ready to be read, whenever it is
# published by a client or pulled from a server / camera.
# This is terminated with SIGINT when the stream is not ready anymore.
# The following environment variables are available:
# * MTX_PATH: path name
# * MTX_QUERY: query parameters (passed by publisher)
# * MTX_SOURCE_TYPE: source type
# * MTX_SOURCE_ID: source ID
# * RTSP_PORT: RTSP server port
# * G1, G2, ...: regular expression groups, if path name is
# a regular expression.
runOnReady: curl http://my-custom-server/webhook?path=$MTX_PATH&source_type=$MTX_SOURCE_TYPE&source_id=$MTX_SOURCE_ID
# Restart the command if it exits.
runOnReadyRestart: no
```
## runOnNotReady
`runOnNotReady` allows to run a command when a stream is not available anymore:
```yml
pathDefaults:
# Command to run when the stream is not available anymore.
# Environment variables are the same as runOnReady.
runOnNotReady: curl http://my-custom-server/webhook?path=$MTX_PATH&source_type=$MTX_SOURCE_TYPE&source_id=$MTX_SOURCE_ID
```
## runOnRead
`runOnRead` allows to run a command when a client starts reading:
```yml
pathDefaults:
# Command to run when a client starts reading.
# This is terminated with SIGINT when a client stops reading.
# The following environment variables are available:
# * MTX_PATH: path name
# * MTX_QUERY: query parameters (passed by reader)
# * MTX_READER_TYPE: reader type
# * MTX_READER_ID: reader ID
# * RTSP_PORT: RTSP server port
# * G1, G2, ...: regular expression groups, if path name is
# a regular expression.
runOnRead: curl http://my-custom-server/webhook?path=$MTX_PATH&reader_type=$MTX_READER_TYPE&reader_id=$MTX_READER_ID
# Restart the command if it exits.
runOnReadRestart: no
```
## runOnUnread
`runOnUnread` allows to run a command when a client stops reading:
```yml
pathDefaults:
# Command to run when a client stops reading.
# Environment variables are the same as runOnRead.
runOnUnread: curl http://my-custom-server/webhook?path=$MTX_PATH&reader_type=$MTX_READER_TYPE&reader_id=$MTX_READER_ID
```
## runOnRecordSegmentCreate
`runOnRecordSegmentCreate` allows to run a command when a recording segment is created:
```yml
pathDefaults:
# Command to run when a recording segment is created.
# The following environment variables are available:
# * MTX_PATH: path name
# * MTX_SEGMENT_PATH: segment file path
# * RTSP_PORT: RTSP server port
# * G1, G2, ...: regular expression groups, if path name is
# a regular expression.
runOnRecordSegmentCreate: curl http://my-custom-server/webhook?path=$MTX_PATH&segment_path=$MTX_SEGMENT_PATH
```
## runOnRecordSegmentComplete
`runOnRecordSegmentComplete` allows to run a command when a recording segment is complete:
```yml
pathDefaults:
# Command to run when a recording segment is complete.
# The following environment variables are available:
# * MTX_PATH: path name
# * MTX_SEGMENT_PATH: segment file path
# * MTX_SEGMENT_DURATION: segment duration
# * RTSP_PORT: RTSP server port
# * G1, G2, ...: regular expression groups, if path name is
# a regular expression.
runOnRecordSegmentComplete: curl http://my-custom-server/webhook?path=$MTX_PATH&segment_path=$MTX_SEGMENT_PATH
```
================================================
FILE: docs/4-other/18-control-api.md
================================================
# Control API
The server can be queried and controlled with an API, that can be enabled by toggling the `api` parameter in the configuration:
```yml
api: yes
```
To obtain a list of active paths, run:
```
curl http://127.0.0.1:9997/v3/paths/list
```
The control API is documented in the [Control API Reference page](../5-references/2-control-api.md) and in the [OpenAPI / Swagger file](https://github.com/bluenviron/mediamtx/blob/{version_tag}/api/openapi.yaml).
Be aware that by default the Control API is accessible by localhost only; to increase visibility or add authentication, check [Authentication](03-authentication.md).
================================================
FILE: docs/4-other/19-metrics.md
================================================
# Extract metrics
_MediaMTX_ provides several metrics through a dedicated HTTP server, in a format compatible with [Prometheus](https://prometheus.io/).
This server can be enabled by setting `metrics: yes` in the configuration.
Metrics can be extracted with Prometheus or with a simple HTTP request:
```
curl localhost:9998/metrics
```
Obtaining:
```ini
# metrics of every path
paths{name="[path_name]",state="[state]"} 1
paths_bytes_received{name="[path_name]",state="[state]"} 1234
paths_bytes_sent{name="[path_name]",state="[state]"} 1234
paths_readers{name="[path_name]",state="[state]"} 1234
# metrics of every HLS muxer
hls_muxers{name="[name]"} 1
hls_muxers_bytes_sent{name="[name]"} 187
# metrics of every RTSP connection
rtsp_conns{id="[id]"} 1
rtsp_conns_bytes_received{id="[id]"} 1234
rtsp_conns_bytes_sent{id="[id]"} 187
# metrics of every RTSP session
rtsp_sessions{id="[id]",path="[path]",remoteAddr="[remoteAddr]",state="[state]"} 1
rtsp_sessions_bytes_received{id="[id]",path="[path]",remoteAddr="[remoteAddr]",state="[state]"} 1234
rtsp_sessions_bytes_sent{id="[id]",path="[path]",remoteAddr="[remoteAddr]",state="[state]"} 187
rtsp_sessions_rtp_packets_received{id="[id]",path="[path]",remoteAddr="[remoteAddr]",state="[state]"} 123
rtsp_sessions_rtp_packets_sent{id="[id]",path="[path]",remoteAddr="[remoteAddr]",state="[state]"} 123
rtsp_sessions_rtp_packets_lost{id="[id]",path="[path]",remoteAddr="[remoteAddr]",state="[state]"} 123
rtsp_sessions_rtp_packets_in_error{id="[id]",path="[path]",remoteAddr="[remoteAddr]",state="[state]"} 123
rtsp_sessions_rtp_packets_jitter{id="[id]",path="[path]",remoteAddr="[remoteAddr]",state="[state]"} 123
rtsp_sessions_rtcp_packets_received{id="[id]",path="[path]",remoteAddr="[remoteAddr]",state="[state]"} 123
rtsp_sessions_rtcp_packets_sent{id="[id]",path="[path]",remoteAddr="[remoteAddr]",state="[state]"} 123
rtsp_sessions_rtcp_packets_in_error{id="[id]",path="[path]",remoteAddr="[remoteAddr]",state="[state]"} 123
# metrics of every RTSPS connection
rtsps_conns{id="[id]"} 1
rtsps_conns_bytes_received{id="[id]"} 1234
rtsps_conns_bytes_sent{id="[id]"} 187
# metrics of every RTSPS session
rtsps_sessions{id="[id]",path="[path]",remoteAddr="[remoteAddr]",state="[state]"} 1
rtsps_sessions_bytes_received{id="[id]",path="[path]",remoteAddr="[remoteAddr]",state="[state]"} 1234
rtsps_sessions_bytes_sent{id="[id]",path="[path]",remoteAddr="[remoteAddr]",state="[state]"} 187
rtsps_sessions_rtp_packets_received{id="[id]",path="[path]",remoteAddr="[remoteAddr]",state="[state]"} 123
rtsps_sessions_rtp_packets_sent{id="[id]",path="[path]",remoteAddr="[remoteAddr]",state="[state]"} 123
rtsps_sessions_rtp_packets_lost{id="[id]",path="[path]",remoteAddr="[remoteAddr]",state="[state]"} 123
rtsps_sessions_rtp_packets_in_error{id="[id]",path="[path]",remoteAddr="[remoteAddr]",state="[state]"} 123
rtsps_sessions_rtp_packets_jitter{id="[id]",path="[path]",remoteAddr="[remoteAddr]",state="[state]"} 123
rtsps_sessions_rtcp_packets_received{id="[id]",path="[path]",remoteAddr="[remoteAddr]",state="[state]"} 123
rtsps_sessions_rtcp_packets_sent{id="[id]",path="[path]",remoteAddr="[remoteAddr]",state="[state]"} 123
rtsps_sessions_rtcp_packets_in_error{id="[id]",path="[path]",remoteAddr="[remoteAddr]",state="[state]"} 123
# metrics of every RTMP connection
rtmp_conns{id="[id]",path="[path]",remoteAddr="[remoteAddr]",state="[state]"} 1
rtmp_conns_bytes_received{id="[id]",path="[path]",remoteAddr="[remoteAddr]",state="[state]"} 1234
rtmp_conns_bytes_sent{id="[id]",path="[path]",remoteAddr="[remoteAddr]",state="[state]"} 187
# metrics of every RTMPS connection
rtmps_conns{id="[id]",path="[path]",remoteAddr="[remoteAddr]",state="[state]"} 1
rtmps_conns_bytes_received{id="[id]",path="[path]",remoteAddr="[remoteAddr]",state="[state]"} 1234
rtmps_conns_bytes_sent{id="[id]",path="[path]",remoteAddr="[remoteAddr]",state="[state]"} 187
# metrics of every SRT connection
srt_conns{id="[id]",path="[path]",remoteAddr="[remoteAddr]",state="[state]"} 1
srt_conns_packets_sent{id="[id]",path="[path]",remoteAddr="[remoteAddr]",state="[state]"} 123
srt_conns_packets_received{id="[id]",path="[path]",remoteAddr="[remoteAddr]",state="[state]"} 123
srt_conns_packets_sent_unique{id="[id]",path="[path]",remoteAddr="[remoteAddr]",state="[state]"} 123
srt_conns_packets_received_unique{id="[id]",path="[path]",remoteAddr="[remoteAddr]",state="[state]"} 123
srt_conns_packets_send_loss{id="[id]",path="[path]",remoteAddr="[remoteAddr]",state="[state]"} 123
srt_conns_packets_received_loss{id="[id]",path="[path]",remoteAddr="[remoteAddr]",state="[state]"} 123
srt_conns_packets_retrans{id="[id]",path="[path]",remoteAddr="[remoteAddr]",state="[state]"} 123
srt_conns_packets_received_retrans{id="[id]",path="[path]",remoteAddr="[remoteAddr]",state="[state]"} 123
srt_conns_packets_sent_ack{id="[id]",path="[path]",remoteAddr="[remoteAddr]",state="[state]"} 123
srt_conns_packets_received_ack{id="[id]",path="[path]",remoteAddr="[remoteAddr]",state="[state]"} 123
srt_conns_packets_sent_nak{id="[id]",path="[path]",remoteAddr="[remoteAddr]",state="[state]"} 123
srt_conns_packets_received_nak{id="[id]",path="[path]",remoteAddr="[remoteAddr]",state="[state]"} 123
srt_conns_packets_sent_km{id="[id]",path="[path]",remoteAddr="[remoteAddr]",state="[state]"} 123
srt_conns_packets_received_km{id="[id]",path="[path]",remoteAddr="[remoteAddr]",state="[state]"} 123
srt_conns_us_snd_duration{id="[id]",path="[path]",remoteAddr="[remoteAddr]",state="[state]"} 123
srt_conns_packets_send_drop{id="[id]",path="[path]",remoteAddr="[remoteAddr]",state="[state]"} 123
srt_conns_packets_received_drop{id="[id]",path="[path]",remoteAddr="[remoteAddr]",state="[state]"} 123
srt_conns_packets_received_undecrypt{id="[id]",path="[path]",remoteAddr="[remoteAddr]",state="[state]"} 123
srt_conns_bytes_sent{id="[id]",path="[path]",remoteAddr="[remoteAddr]",state="[state]"} 187
srt_conns_bytes_received{id="[id]",path="[path]",remoteAddr="[remoteAddr]",state="[state]"} 1234
srt_conns_bytes_sent_unique{id="[id]",path="[path]",remoteAddr="[remoteAddr]",state="[state]"} 123
srt_conns_bytes_received_unique{id="[id]",path="[path]",remoteAddr="[remoteAddr]",state="[state]"} 123
srt_conns_bytes_received_loss{id="[id]",path="[path]",remoteAddr="[remoteAddr]",state="[state]"} 123
srt_conns_bytes_retrans{id="[id]",path="[path]",remoteAddr="[remoteAddr]",state="[state]"} 123
srt_conns_bytes_received_retrans{id="[id]",path="[path]",remoteAddr="[remoteAddr]",state="[state]"} 123
srt_conns_bytes_send_drop{id="[id]",path="[path]",remoteAddr="[remoteAddr]",state="[state]"} 123
srt_conns_bytes_received_drop{id="[id]",path="[path]",remoteAddr="[remoteAddr]",state="[state]"} 123
srt_conns_bytes_received_undecrypt{id="[id]",path="[path]",remoteAddr="[remoteAddr]",state="[state]"} 123
srt_conns_us_packets_send_period{id="[id]",path="[path]",remoteAddr="[remoteAddr]",state="[state]"} 123.123
srt_conns_packets_flow_window{id="[id]",path="[path]",remoteAddr="[remoteAddr]",state="[state]"} 123
srt_conns_packets_flight_size{id="[id]",path="[path]",remoteAddr="[remoteAddr]",state="[state]"} 123
srt_conns_ms_rtt{id="[id]",path="[path]",remoteAddr="[remoteAddr]",state="[state]"} 123.123
srt_conns_mbps_send_rate{id="[id]",path="[path]",remoteAddr="[remoteAddr]",state="[state]"} 123
srt_conns_mbps_receive_rate{id="[id]",path="[path]",remoteAddr="[remoteAddr]",state="[state]"} 123.123
srt_conns_mbps_link_capacity{id="[id]",path="[path]",remoteAddr="[remoteAddr]",state="[state]"} 123.123
srt_conns_bytes_avail_send_buf{id="[id]",path="[path]",remoteAddr="[remoteAddr]",state="[state]"} 123
srt_conns_bytes_avail_receive_buf{id="[id]",path="[path]",remoteAddr="[remoteAddr]",state="[state]"} 123
srt_conns_mbps_max_bw{id="[id]",path="[path]",remoteAddr="[remoteAddr]",state="[state]"} -123
srt_conns_bytes_mss{id="[id]",path="[path]",remoteAddr="[remoteAddr]",state="[state]"} 123
srt_conns_packets_send_buf{id="[id]",path="[path]",remoteAddr="[remoteAddr]",state="[state]"} 123
srt_conns_bytes_send_buf{id="[id]",path="[path]",remoteAddr="[remoteAddr]",state="[state]"} 123
srt_conns_ms_send_buf{id="[id]",path="[path]",remoteAddr="[remoteAddr]",state="[state]"} 123
srt_conns_ms_send_tsb_pd_delay{id="[id]",path="[path]",remoteAddr="[remoteAddr]",state="[state]"} 123
srt_conns_packets_receive_buf{id="[id]",path="[path]",remoteAddr="[remoteAddr]",state="[state]"} 123
srt_conns_bytes_receive_buf{id="[id]",path="[path]",remoteAddr="[remoteAddr]",state="[state]"} 123
srt_conns_ms_receive_buf{id="[id]",path="[path]",remoteAddr="[remoteAddr]",state="[state]"} 123
srt_conns_ms_receive_tsb_pd_delay{iid="[id]",path="[path]",remoteAddr="[remoteAddr]",state="[state]"} 123
srt_conns_packets_reorder_tolerance{id="[id]",path="[path]",remoteAddr="[remoteAddr]",state="[state]"} 123
srt_conns_packets_received_avg_belated_time{id="[id]",path="[path]",remoteAddr="[remoteAddr]",state="[state]"} 123
srt_conns_packets_send_loss_rate{id="[id]",path="[path]",remoteAddr="[remoteAddr]",state="[state]"} 123
srt_conns_packets_received_loss_rate{id="[id]",path="[path]",remoteAddr="[remoteAddr]",state="[state]"} 123
# metrics of every WebRTC session
webrtc_sessions{id="[id]",path="[path]",remoteAddr="[remoteAddr]",state="[state]"} 1
webrtc_sessions_bytes_received{id="[id]",path="[path]",remoteAddr="[remoteAddr]",state="[state]"} 1234
webrtc_sessions_bytes_sent{id="[id]",path="[path]",remoteAddr="[remoteAddr]",state="[state]"} 187
webrtc_sessions_rtp_packets_received{id="[id]",path="[path]",remoteAddr="[remoteAddr]",state="[state]"} 123
webrtc_sessions_rtp_packets_sent{id="[id]",path="[path]",remoteAddr="[remoteAddr]",state="[state]"} 123
webrtc_sessions_rtp_packets_lost{id="[id]",path="[path]",remoteAddr="[remoteAddr]",state="[state]"} 123
webrtc_sessions_rtp_packets_jitter{id="[id]",path="[path]",remoteAddr="[remoteAddr]",state="[state]"} 123
webrtc_sessions_rtcp_packets_received{id="[id]",path="[path]",remoteAddr="[remoteAddr]",state="[state]"} 123
webrtc_sessions_rtcp_packets_sent{id="[id]",path="[path]",remoteAddr="[remoteAddr]",state="[state]"} 123
```
Bitrates are not provided directly as metrics because they can be computed from received and sent bytes by any metrics analyzer (i.e. Grafana).
Metrics can be filtered by using HTTP query parameters:
- `type=[TYPE]`: show metrics of a certain type only (where TYPE can be `paths`, `hls_muxers`, `rtsp_conns`, `rtsp_sessions`, `rtsps_conns`, `rtsps_sessions`, `rtmp_conns`, `rtmps_conns`, `srt_conns`, `webrtc_sessions`)
- `path=[PATH]`: show metrics belonging to a specific path only
- `hls_muxer=[PATH]`: show metrics belonging to a specific HLS muxer only
- `rtsp_conn=[ID]` show metrics belonging to a specific RTSP connection only
- `rtsp_session=[SESSION]`: show metrics belonging to a specific RTSP session only
- `rtsps_conn=[ID]` show metrics belonging to a specific RTSPS connection only
- `rtsps_session=[SESSION]`: show metrics belonging to a specific RTSPS session only
- `rtmp_conn=[ID]` show metrics belonging to a specific RTMP connection only
- `rtmps_conn=[ID]` show metrics belonging to a specific RTMPS connection only
- `srt_conn=[ID]` show metrics belonging to a specific SRT connection only
- `webrtc_session=[ID]` show metrics belonging to a specific WebRTC session only
================================================
FILE: docs/4-other/20-performance.md
================================================
# Monitor performance
CPU and memory consumption can be monitored over time through an integrated performance monitor, that produces reports in a format compatible with [pprof](https://github.com/google/pprof), which is a tool included in any Go installation.
The performance monitor can be enabled by setting `pprof: yes` in the configuration.
Reports can be extracted and displayed by using the `go tool pprof` command.
Occupied memory can be analyzed by running:
```sh
go tool pprof -text http://localhost:9999/debug/pprof/heap
```
Obtaining:
```
Fetching profile over HTTP from http://localhost:9999/debug/pprof/heap
Saved profile in /home/xxx/pprof/pprof.mediamtx.alloc_objects.alloc_space.inuse_objects.inuse_space.007.pb.gz
File: mediamtx
Build ID: dfb7c97dbb5e9ce59438172269231b35a873e3e9
Type: inuse_space
Time: Sep 99, 9999 at 12:00pm (CEST)
Showing nodes accounting for 5145.10kB, 100% of 5145.10kB total
flat flat% sum% cum cum%
2052kB 39.88% 39.88% 2052kB 39.88% runtime.allocm
525.43kB 10.21% 50.09% 525.43kB 10.21% github.com/go-playground/validator/v10.map.init.7
518.65kB 10.08% 60.18% 518.65kB 10.08% github.com/go-playground/validator/v10.map.init.3
512.75kB 9.97% 70.14% 512.75kB 9.97% github.com/bluenviron/gortsplib/v4.(*serverUDPListener).run.func1 (inline)
512.22kB 9.96% 80.10% 512.22kB 9.96% runtime.malg
512.02kB 9.95% 90.05% 512.02kB 9.95% crypto/tls.init
512.02kB 9.95% 100% 512.02kB 9.95% internal/abi.NewName
0 0% 100% 512.75kB 9.97% github.com/bluenviron/gortsplib/v4.(*serverUDPListener).run
0 0% 100% 512.02kB 9.95% github.com/bluenviron/mediamtx/internal/conf.init
0 0% 100% 512.02kB 9.95% github.com/bluenviron/mediamtx/internal/conf.init.func2 (inline)
0 0% 100% 1044.08kB 20.29% github.com/go-playground/validator/v10.init
0 0% 100% 512.02kB 9.95% reflect.StructOf
0 0% 100% 512.02kB 9.95% reflect.newName (inline)
0 0% 100% 512.02kB 9.95% reflect.runtimeStructField
0 0% 100% 2068.13kB 40.20% runtime.doInit (inline)
0 0% 100% 2068.13kB 40.20% runtime.doInit1
0 0% 100% 2068.13kB 40.20% runtime.main
0 0% 100% 513kB 9.97% runtime.mcall
0 0% 100% 1539kB 29.91% runtime.mstart
0 0% 100% 1539kB 29.91% runtime.mstart0
0 0% 100% 1539kB 29.91% runtime.mstart1
0 0% 100% 2052kB 39.88% runtime.newm
0 0% 100% 512.22kB 9.96% runtime.newproc.func1
0 0% 100% 512.22kB 9.96% runtime.newproc1
0 0% 100% 513kB 9.97% runtime.park_m
0 0% 100% 2052kB 39.88% runtime.resetspinning
0 0% 100% 2052kB 39.88% runtime.schedule
0 0% 100% 2052kB 39.88% runtime.startm
0 0% 100% 512.22kB 9.96% runtime.systemstack
0 0% 100% 2052kB 39.88% runtime.wakep
```
Consumed CPU can be analyzed by running:
```sh
go tool pprof -text http://localhost:9999/debug/pprof/profile?seconds=15
```
Obtaining:
```
Fetching profile over HTTP from http://localhost:9999/debug/pprof/profile?seconds=15
Saved profile in /home/xxx/pprof/pprof.mediamtx.samples.cpu.003.pb.gz
File: mediamtx
Build ID: dfb7c97dbb5e9ce59438172269231b35a873e3e9
Type: cpu
Time: Sep 99, 9999 at 12:00pm (CEST)
Duration: 15s, Total samples = 0
Showing nodes accounting for 70ms, 100% of 70ms total
flat flat% sum% cum cum%
30ms 42.86% 42.86% 30ms 42.86% internal/runtime/syscall.Syscall6
10ms 14.29% 57.14% 10ms 14.29% runtime.(*consistentHeapStats).acquire
10ms 14.29% 71.43% 10ms 14.29% runtime.futex
10ms 14.29% 85.71% 10ms 14.29% runtime.mapIterStart
10ms 14.29% 100% 10ms 14.29% runtime.netpollblockcommit
0 0% 100% 10ms 14.29% github.com/bluenviron/gortsplib/v4.(*serverSessionFormat).readPacketRTP
0 0% 100% 10ms 14.29% github.com/bluenviron/gortsplib/v4.(*serverSessionMedia).readPacketRTPUDPRecord
0 0% 100% 50ms 71.43% github.com/bluenviron/gortsplib/v4.(*serverUDPListener).run
0 0% 100% 10ms 14.29% github.com/bluenviron/gortsplib/v4.(*serverUDPListener).run.func2
0 0% 100% 10ms 14.29% github.com/bluenviron/mediamtx/internal/protocols/rtsp.ToStream.func2
0 0% 100% 10ms 14.29% github.com/bluenviron/mediamtx/internal/stream.(*Stream).WriteRTPPacket
0 0% 100% 10ms 14.29% github.com/bluenviron/mediamtx/internal/stream.(*streamFormat).writeRTPPacket
0 0% 100% 10ms 14.29% github.com/bluenviron/mediamtx/internal/stream.(*streamFormat).writeUnitInner
0 0% 100% 30ms 42.86% internal/poll.(*FD).ReadFromInet6
0 0% 100% 10ms 14.29% internal/runtime/syscall.EpollWait
0 0% 100% 40ms 57.14% net.(*UDPConn).ReadFrom
0 0% 100% 30ms 42.86% net.(*UDPConn).readFrom
0 0% 100% 30ms 42.86% net.(*UDPConn).readFromUDP
0 0% 100% 30ms 42.86% net.(*netFD).readFromInet6
0 0% 100% 10ms 14.29% runtime.(*mcache).nextFree
0 0% 100% 10ms 14.29% runtime.(*mcache).refill
0 0% 100% 10ms 14.29% runtime.entersyscall
0 0% 100% 10ms 14.29% runtime.entersyscall_sysmon
0 0% 100% 10ms 14.29% runtime.findRunnable
0 0% 100% 10ms 14.29% runtime.futexwakeup
0 0% 100% 10ms 14.29% runtime.mallocgc
0 0% 100% 10ms 14.29% runtime.mallocgcSmallScanNoHeader
0 0% 100% 20ms 28.57% runtime.mcall
0 0% 100% 10ms 14.29% runtime.netpoll
0 0% 100% 10ms 14.29% runtime.newobject
0 0% 100% 10ms 14.29% runtime.notewakeup
0 0% 100% 20ms 28.57% runtime.park_m
0 0% 100% 10ms 14.29% runtime.reentersyscall
0 0% 100% 10ms 14.29% runtime.schedule
0 0% 100% 10ms 14.29% runtime.systemstack
0 0% 100% 20ms 28.57% syscall.RawSyscall6
0 0% 100% 30ms 42.86% syscall.Syscall6
0 0% 100% 30ms 42.86% syscall.recvfrom
0 0% 100% 30ms 42.86% syscall.recvfromInet6
```
Active routines can be listed by running:
```sh
go tool pprof -text http://localhost:9999/debug/pprof/goroutine
```
Obtaining:
```
Fetching profile over HTTP from http://localhost:9999/debug/pprof/goroutine
Saved profile in /home/xxx/pprof/pprof.mediamtx.goroutine.044.pb.gz
File: mediamtx
Build ID: dfb7c97dbb5e9ce59438172269231b35a873e3e9
Type: goroutine
Time: Sep 99, 9999 at 12:00pm (CEST)
Showing nodes accounting for 27, 100% of 27 total
flat flat% sum% cum cum%
25 92.59% 92.59% 25 92.59% runtime.gopark
1 3.70% 96.30% 1 3.70% runtime.goroutineProfileWithLabels
1 3.70% 100% 1 3.70% runtime.notetsleepg
0 0% 100% 1 3.70% github.com/bluenviron/gortsplib/v4.(*Server).Wait (inline)
0 0% 100% 1 3.70% github.com/bluenviron/gortsplib/v4.(*Server).run
0 0% 100% 1 3.70% github.com/bluenviron/gortsplib/v4.(*Server).runInner
0 0% 100% 1 3.70% github.com/bluenviron/gortsplib/v4.(*serverTCPListener).run
0 0% 100% 2 7.41% github.com/bluenviron/gortsplib/v4.(*serverUDPListener).run
0 0% 100% 1 3.70% github.com/bluenviron/mediamtx/internal/confwatcher.(*ConfWatcher).run
0 0% 100% 1 3.70% github.com/bluenviron/mediamtx/internal/core.(*Core).Wait (inline)
0 0% 100% 1 3.70% github.com/bluenviron/mediamtx/internal/core.(*Core).run
0 0% 100% 1 3.70% github.com/bluenviron/mediamtx/internal/core.(*pathManager).run
0 0% 100% 1 3.70% github.com/bluenviron/mediamtx/internal/protocols/httpp.(*handlerExitOnPanic).ServeHTTP
0 0% 100% 1 3.70% github.com/bluenviron/mediamtx/internal/protocols/httpp.(*handlerFilterRequests).ServeHTTP
0 0% 100% 1 3.70% github.com/bluenviron/mediamtx/internal/protocols/httpp.(*handlerLogger).ServeHTTP
0 0% 100% 1 3.70% github.com/bluenviron/mediamtx/internal/protocols/httpp.(*handlerServerHeader).ServeHTTP
0 0% 100% 1 3.70% github.com/bluenviron/mediamtx/internal/recordcleaner.(*Cleaner).run
0 0% 100% 1 3.70% github.com/bluenviron/mediamtx/internal/servers/hls.(*Server).run
0 0% 100% 1 3.70% github.com/bluenviron/mediamtx/internal/servers/rtmp.(*Server).run
0 0% 100% 1 3.70% github.com/bluenviron/mediamtx/internal/servers/rtmp.(*listener).run
0 0% 100% 1 3.70% github.com/bluenviron/mediamtx/internal/servers/rtmp.(*listener).runInner
0 0% 100% 1 3.70% github.com/bluenviron/mediamtx/internal/servers/rtsp.(*Server).run
0 0% 100% 1 3.70% github.com/bluenviron/mediamtx/internal/servers/rtsp.(*Server).run.func1
0 0% 100% 1 3.70% github.com/bluenviron/mediamtx/internal/servers/srt.(*Server).run
0 0% 100% 1 3.70% github.com/bluenviron/mediamtx/internal/servers/srt.(*listener).run
0 0% 100% 1 3.70% github.com/bluenviron/mediamtx/internal/servers/srt.(*listener).runInner
0 0% 100% 1 3.70% github.com/bluenviron/mediamtx/internal/servers/webrtc.(*Server).run
0 0% 100% 1 3.70% github.com/datarhei/gosrt.(*listener).Accept2
0 0% 100% 1 3.70% github.com/datarhei/gosrt.(*listener).reader
0 0% 100% 1 3.70% github.com/datarhei/gosrt.Listen.func1
0 0% 100% 1 3.70% github.com/fsnotify/fsnotify.(*inotify).readEvents
0 0% 100% 1 3.70% github.com/gin-contrib/pprof.RouteRegister.WrapH.func9
0 0% 100% 1 3.70% github.com/gin-gonic/gin.(*Context).Next (inline)
0 0% 100% 1 3.70% github.com/gin-gonic/gin.(*Engine).ServeHTTP
0 0% 100% 1 3.70% github.com/gin-gonic/gin.(*Engine).handleHTTPRequest
0 0% 100% 1 3.70% github.com/pion/ice/v4.(*UDPMuxDefault).connWorker
0 0% 100% 5 18.52% internal/poll.(*FD).Accept
0 0% 100% 2 7.41% internal/poll.(*FD).Read
0 0% 100% 4 14.81% internal/poll.(*FD).ReadFromInet6
0 0% 100% 11 40.74% internal/poll.(*pollDesc).wait
0 0% 100% 11 40.74% internal/poll.(*pollDesc).waitRead (inline)
0 0% 100% 11 40.74% internal/poll.runtime_pollWait
0 0% 100% 1 3.70% main.main
0 0% 100% 5 18.52% net.(*TCPListener).Accept
0 0% 100% 5 18.52% net.(*TCPListener).accept
0 0% 100% 4 14.81% net.(*UDPConn).ReadFrom
0 0% 100% 4 14.81% net.(*UDPConn).readFrom
0 0% 100% 4 14.81% net.(*UDPConn).readFromUDP
0 0% 100% 1 3.70% net.(*conn).Read
0 0% 100% 1 3.70% net.(*netFD).Read
0 0% 100% 5 18.52% net.(*netFD).accept
0 0% 100% 4 14.81% net.(*netFD).readFromInet6
0 0% 100% 3 11.11% net/http.(*Server).Serve
0 0% 100% 1 3.70% net/http.(*conn).serve
0 0% 100% 1 3.70% net/http.(*connReader).backgroundRead
0 0% 100% 1 3.70% net/http.serverHandler.ServeHTTP
0 0% 100% 1 3.70% net/http/pprof.handler.ServeHTTP
0 0% 100% 1 3.70% os.(*File).Read
0 0% 100% 1 3.70% os.(*File).read (inline)
0 0% 100% 1 3.70% os/signal.loop
0 0% 100% 1 3.70% os/signal.signal_recv
0 0% 100% 1 3.70% runtime.chanrecv
0 0% 100% 1 3.70% runtime.chanrecv1
0 0% 100% 1 3.70% runtime.goparkunlock (inline)
0 0% 100% 1 3.70% runtime.main
0 0% 100% 11 40.74% runtime.netpollblock
0 0% 100% 1 3.70% runtime.pprof_goroutineProfileWithLabels
0 0% 100% 12 44.44% runtime.selectgo
0 0% 100% 1 3.70% runtime.semacquire1
0 0% 100% 1 3.70% runtime/pprof.(*Profile).WriteTo
0 0% 100% 1 3.70% runtime/pprof.writeGoroutine
0 0% 100% 1 3.70% runtime/pprof.writeRuntimeProfile
0 0% 100% 1 3.70% sync.(*WaitGroup).Wait
0 0% 100% 1 3.70% sync.runtime_SemacquireWaitGroup
```
================================================
FILE: docs/4-other/21-srt-specific-features.md
================================================
# SRT-specific features
SRT is a protocol that can be used for publishing and reading streams. Regarding specific tasks, read [Publish](../2-publish/02-srt-clients.md) and [Read](../3-read/02-srt.md). Features in this page are shared among both tasks.
## Standard stream ID syntax
In SRT, the stream ID is a string that is sent to the remote part in order to advertise what action the caller is going to do (publish or read), the path and the credentials. All this information has to be encoded into a single string. This server supports two stream ID syntaxes, a custom one (that is the one reported in the rest of the README) and also a [standard one](https://github.com/Haivision/srt/blob/master/docs/features/access-control.md) proposed by the authors of the protocol and enforced by some hardware. The standard syntax can be used in this way:
```
srt://localhost:8890?streamid=#!::m=publish,r=mypath,u=myuser,s=mypass&pkt_size=1316
```
Where:
- key `m` contains the action (`publish` or `request`)
- key `r` contains the path
- key `u` contains the username
- key `s` contains the password
================================================
FILE: docs/4-other/22-webrtc-specific-features.md
================================================
# WebRTC-specific features
WebRTC is a protocol that can be used for publishing and reading streams. Regarding specific tasks, read [Publish](../2-publish/04-webrtc-clients.md) and [Read](../3-read/03-webrtc.md). Features in this page are shared among both tasks.
## Codec support in browsers
The server can ingest and broadcast with WebRTC a wide variety of video and audio codecs (that are listed at the beginning of the README), but not all browsers can publish and read all codecs due to internal limitations that cannot be overcome by this or any other server.
In particular, reading and publishing H265 tracks with WebRTC was not possible until some time ago due to lack of browser support. The situation improved recently and can be described as following:
- Safari on iOS and macOS fully support publishing and reading H265 tracks.
- Chrome on Windows supports publishing and reading H265 tracks when a capable GPU is present.
You can check what codecs your browser can publish or read with WebRTC by [using this tool](https://jsfiddle.net/v24s8q1f/).
If you want to support most browsers, you can re-encode the stream by using H264 and Opus codecs, for instance by using FFmpeg:
```sh
ffmpeg -i rtsp://original-source \
-c:v libx264 -pix_fmt yuv420p -preset ultrafast -b:v 600k \
-c:a libopus -b:a 64K -async 50 \
-f rtsp rtsp://localhost:8554/mystream
```
## Solving WebRTC connectivity issues
In WebRTC, the handshake between server and clients happens through standard HTTP requests and responses, while media streaming takes place inside a dedicated communication channel (peer connection) that is set up shortly after the handshake. The server supports establishing peer connections through the following methods (ordered by efficiency and simplicity):
1. using a static UDP server port (`webrtcLocalUDPAddress` must be filled, it is by default)
2. using a static TCP server port (`webrtcLocalTCPAddress` must be filled, it is not by default)
3. using a random UDP server port and UDP client port with the hole-punching technique (`webrtcICEServers2` must contain a STUN server, not present by default)
4. using a relay (TURN server) that exposes a TCP port that is accessed by both server and clients (`webrtcICEServers2` must contain a TURN server, not present by default)
Establishing the peer connection might get difficult when the server is hosted inside a container or there is a NAT / firewall between server and clients.
The first thing to do is making sure that `webrtcAdditionalHosts` includes your public IPs, that are IPs that can be used by clients to reach the server. If clients are on the same LAN as the server, add the LAN address of the server. If clients are coming from the internet, add the public IP address of the server, or alternatively a DNS name, if you have one. You can add several values to support all scenarios:
```yml
webrtcAdditionalHosts: [192.168.x.x, 1.2.3.4, my-dns.example.org, ...]
```
If there's a NAT / container between server and clients, it must be configured to route all incoming UDP packets on port 8189 to the server. If you're using Docker, this can be achieved with the flag:
```sh
docker run --rm -it \
-p 8189:8189/udp
....
bluenviron/mediamtx:1
```
If you still have problems, the UDP protocol might be blocked by a firewall. Switch to the TCP protocol by enabling the TCP server port:
```yml
webrtcLocalTCPAddress: :8189
```
If there's a NAT / container between server and clients, it must be configured to route all incoming TCP packets on port 8189 to the server.
If you still have problems, add a STUN server, that is used by both server and clients to find out their public IP. Connections are then established with the "UDP hole punching" technique, that uses a random UDP port that does not need to be explicitly opened. For instance:
```yml
webrtcICEServers2:
- url: stun:stun.l.google.com:19302
```
If you really still have problems, you can force all WebRTC/ICE connections to pass through a TURN server. The server address and credentials must be set in the configuration file:
```yml
webrtcICEServers2:
- url: turn:host:port
username: user
password: password
```
Where user and pass are the username and password of the server. Note that port is not optional.
If the server uses a secret-based authentication (for instance, Coturn with the use-auth-secret option), it must be configured by using AUTH_SECRET as username, and the secret as password:
```yml
webrtcICEServers2:
- url: turn:host:port
username: AUTH_SECRET
password: secret
```
Where secret is the secret of the TURN server. _MediaMTX_ will generate a set of credentials by using the secret, and credentials will be sent to clients before the WebRTC/ICE connection is established.
In some cases you may want the browser to connect using TURN servers but have _MediaMTX_ not using TURN (for example if the TURN server is on the same network as mediamtx). To allow this you can configure the TURN server to be client only:
```yml
webrtcICEServers2:
- url: turn:host:port
username: user
password: password
clientOnly: true
```
## Coturn setup
Here's how to setup the [Coturn](https://github.com/coturn/coturn) TURN server and use it with _MediaMTX_. This is needed only if all other WebRTC connectivity methods have failed. Start Coturn with Docker:
```sh
docker run --rm -it \
--network=host \
coturn/coturn \
--log-file=stdout -v \
--no-udp --no-dtls --no-tls \
--min-port=49152 --max-port=65535 \
--use-auth-secret --static-auth-secret=mysecret -r myrealm
```
We are suggesting and using the following settings:
- enable the TCP transport only. We are assuming you are setting up Coturn because other connectivity methods have failed, thus TCP is more reliable.
- toggle `--network=host` since Coturn allocates a TCP port for each peer connection.
- set `min-port` and `max-port` to specify the range of TCP ports.
- enable secret-based authentication, that prevents clients from storing permanently valid credentials.
Configure MediaMTX to use the TURN server:
```yml
webrtcICEServers2:
- url: turn:REPLACE_WITH_COTURN_IP:3478?transport=tcp
username: AUTH_SECRET
password: mysecret
```
The `?transport=tcp` suffix is needed to force TCP usage. Use `AUTH_SECRET` as username and the shared secret as the password.
================================================
FILE: docs/4-other/23-rtsp-specific-features.md
================================================
# RTSP-specific features
RTSP is a protocol that can be used for publishing and reading streams. Regarding specific tasks, read [Publish](../2-publish/06-rtsp-clients.md) and [Read](../3-read/04-rtsp.md). Features in this page are shared among both tasks.
## Transport protocols
A RTSP session is split in two parts: the handshake, which is always performed with the TCP protocol, and data streaming, which can be performed with an arbitrary underlying transport protocol, which is chosen by the client during the handshake:
- UDP: the most performant, but requires clients to access two additional UDP ports on the server, which is often impossible due to blocking or remapping by NATs/firewalls in between.
- UDP-multicast: allows to save bandwidth when clients are all in the same LAN, by sending packets once to a fixed multicast IP.
- TCP: the most versatile.
To change the transport protocol, you have to tune the configuration of the client you are using to publish or read streams. In most clients, the default transport protocol is UDP.
FFmpeg allows to change the transport protocol with the `-rtsp_transport` flag:
```sh
ffmpeg -rtsp_transport tcp -i rtsp://localhost:8554/mystream -c copy output.mp4
```
Available options are:
- `-rtsp_transport tcp` to pick the TCP transport protocol
- `-rtsp_transport udp` to pick the UDP transport protocol
- `-rtsp_transport udp_multicast` to pick the UDP-multicast transport protocol
GStreamer allows to change the transport protocol with the `protocols` property of `rtspsrc` and `rtspclientsink`:
```sh
gst-launch-1.0 filesrc location=file.mp4 ! qtdemux name=d \
d.video_0 ! rtspclientsink location=rtsp://localhost:8554/mystream protocols=tcp
```
Available options are:
- `protocols=tcp` to pick the TCP transport protocol
- `protocols=udp` to pick the UDP transport protocol
- `protocols=udp-mcast` to pick the UDP-multicast transport protocol
VLC allows to use the TCP transport protocol through the `--rtsp_tcp` flag:
```sh
vlc --network-caching=50 --rtsp-tcp rtsp://localhost:8554/mystream
```
VLC allows to use the UDP-multicast transport protocol by appending `?vlcmulticast` to the URL:
```sh
vlc --network-caching=50 rtsp://localhost:8554/mystream?vlcmulticast
```
## Encryption
Incoming and outgoing RTSP streams can be encrypted by replacing all the subprotocols that are normally used in RTSP with their secure variants (RTSPS, SRTP, SRTCP). A TLS certificate is needed and can be generated with OpenSSL:
```sh
openssl genrsa -out server.key 2048
openssl req -new -x509 -sha256 -key server.key -out server.crt -days 3650
```
Edit `mediamtx.yml` and set the `encryption`, `serverKey` and serverCert parameters:
```yml
rtspEncryption: optional
rtspServerKey: server.key
rtspServerCert: server.crt
```
Streams can be published and read with the `rtsps` scheme and the `8322` port:
```
rtsps://localhost:8322/mystream
```
Some clients require additional flags for encryption to work properly.
When reading with GStreamer, set `tls-validation-flags` to `0`:
```sh
gst-launch-1.0 rtspsrc tls-validation-flags=0 location=rtsps://ip:8322/...
```
When publishing with GStreamer, set `tls-validation-flags` to `0` and `profiles` to `GST_RTSP_PROFILE_SAVP`:
```sh
gst-launch-1.0 filesrc location=file.mp4 ! qtdemux name=d \
d.video_0 ! rtspclientsink location=rtsp://localhost:8554/mystream tls-validation-flags=0 profiles=GST_RTSP_PROFILE_SAVP
```
## Tunneling
In environments where HTTP is the only protocol available for exposing services (for instance, when there are mandatory API gateways or strict firewalls), the RTSP protocol can be tunneled inside HTTP. There are two standardized HTTP tunneling variants:
- RTSP over WebSocket: more efficient, requires WebSocket support from the gateway / firewall
- RTSP over HTTP: older variant, should work even in extreme cases
_MediaMTX_ is automatically able to handle incoming HTTP-tunneled RTSP connections without any configuration required.
In order to read a stream from an external RTSP server using HTTP tunneling, you can use the `rtsp+http` scheme:
```yml
paths:
source: rtsp+http://standard-rtsp-url
```
There are also the `rtsp+https`, `rtsp+ws`, `rtsp+wss` schemes to handle any combination.
## MPEG-TS inside RTSP
read [MPEG-TS inside RTSP](../2-publish/06-rtsp-clients.md#mpeg-ts-inside-rtsp) in the "Publish with RTSP clients" page.
================================================
FILE: docs/4-other/24-rtmp-specific-features.md
================================================
# RTMP-specific features
RTMP is a protocol that can be used for publishing and reading streams. Regarding specific tasks, read [Publish](../2-publish/08-rtmp-clients.md) and [Read](../3-read/05-rtmp.md). Features in this page are shared among both tasks.
## Encryption
RTMP connections can be encrypted by using the secure protocol variant (RTMPS). A TLS certificate is needed and can be generated with OpenSSL:
```yml
openssl genrsa -out server.key 2048
openssl req -new -x509 -sha256 -key server.key -out server.crt -days 3650
```
Edit mediamtx.yml and set the `rtmpEncryption`, `rtmpServerKey` and `rtmpServerCert` parameters:
```yml
rtmpEncryption: optional
rtmpServerKey: server.key
rtmpServerCert: server.crt
```
Streams can be published and read with the rtmps scheme and the 1937 port:
```
rtmps://localhost:1937/...
```
Be aware that RTMPS is currently unsupported by all major players. However, you can use a local _MediaMTX_ instance to decrypt streams before reading them, or alternatively a proxy like [stunnel](https://www.stunnel.org) or [nginx](https://nginx.org/). For instance, you can launch a local _MediaMTX_ instance with this configuration:
```yml
paths:
decrypted:
source: rtmps://original-stream
```
And then read `rtmp://localhost/decrypted` instead of `rtmps://original-stream`.
================================================
FILE: docs/4-other/25-decrease-packet-loss.md
================================================
# Decrease packet loss
MediaMTX is meant for routing live streams, and makes use of a series of protocols and techniques which try to preserve the real-time aspect of streams and minimize latency at cost of losing packets in transmit, in particular:
- most protocols are built on UDP, which is an "unreliable transport", specifically picked because it allows dropping late packets in case of network congestion.
- there's a circular buffer that stores outgoing packets and drops packets if full.
Packet losses are usually detected and printed in _MediaMTX_ logs.
If you need to improve the stream reliability and decrease packet losses, the first thing to do is to check whether the physical network between the _MediaMTX_ instance and the intended publishers and readers has sufficient bandwidth for transmitting the media stream. Most of the time, packet losses are caused by a network which is not fit for this scope. This limitation can be overcome by either recompressing the stream with a lower bitrate, or by upgrading the network infrastructure (routers, cables, Wi-Fi, firewalls, topology, etc).
Nonetheless there are some parameters that can be tuned to improve the situation, at cost of increasing RAM consumption:
- When publishing a stream with a UDP-based protocol (currently RTSP, MPEG-TS, RTP, SRT, WebRTC), packets might get discarded by the server because the read buffer size of UDP sockets is too small. It can be increased with this parameter:
```yml
udpReadBufferSize: 1000000
```
The `udpReadBufferSize` parameter requires the `net.core.rmem_max` system parameter to be equal or greater than it. It can be set with this command:
```sh
sudo sysctl net.core.rmem_max=100000000
```
- When reading a stream, packets might get discarded because the write queue is too small. This can be noticed in logs through the "reader is too slow" message. Try increasing the write queue:
```yml
writeQueueSize: 1024
```
- When publishing or reading a stream with RTSP, it's possible to switch from the UDP transport protocol to the TCP transport protocol, which is less performant but has a packet retransmission mechanism:
```yml
rtspTransports: [tcp]
```
In case the source is a camera:
```yml
paths:
test:
source: rtsp://..
rtspTransport: tcp
```
================================================
FILE: docs/4-other/index.md
================================================
# Other features
================================================
FILE: docs/5-references/1-configuration-file.md
================================================
# Configuration file reference
This is a copy of the configuration file (`mediamtx.yml`) of the latest _MediaMTX_ release ({version_tag}), that contains all available parameters. Check the [Configuration usage page](../4-other/02-configuration.md) for instructions on how to change it.
================================================
FILE: docs/5-references/2-control-api.md
================================================
# Control API reference
This is the reference of the Control API of the latest _MediaMTX_ release ({version_tag}), generated automatically from the [OpenAPI / Swagger file](https://github.com/bluenviron/mediamtx/blob/{version_tag}/api/openapi.yaml) available in the repository. Check the [Control API usage page](../4-other/18-control-api.md) for instructions on how to use the API.
================================================
FILE: docs/5-references/index.md
================================================
# References
================================================
FILE: docs/6-misc/1-compile.md
================================================
# Compile from source
## Standard procedure
1. Install git and Go ≥ 1.25.
2. Clone the repository, enter into the folder and start the building process:
```sh
git clone https://github.com/bluenviron/mediamtx
cd mediamtx
go generate ./...
CGO_ENABLED=0 go build .
```
This will produce the `mediamtx` binary.
## Custom libcamera
If you need to use a custom or external libcamera to interact with some Raspberry Pi Camera model that requires it, additional steps are required:
1. Download [mediamtx-rpicamera source code](https://github.com/bluenviron/mediamtx-rpicamera) and compile it against the external libcamera. Instructions are in the repository.
2. Install git and Go ≥ 1.25.
3. Clone the _MediaMTX_ repository:
```sh
git clone https://github.com/bluenviron/mediamtx
```
4. Inside the _MediaMTX_ folder, run:
```sh
go generate ./...
```
5. Copy `build/mtxrpicam_32` and/or `build/mtxrpicam_64` (depending on the architecture) from `mediamtx-rpicamera` to `mediamtx`, inside folder `internal/staticsources/rpicamera/`, overriding existing folders.
6. Compile:
```sh
go run .
```
This will produce the `mediamtx` binary.
## Cross compile
Cross compilation allows to build an executable for a target machine from another machine with a different operating system or architecture. This is useful in case the target machine doesn't have enough resources for compilation or if you don't want to install the compilation dependencies on it.
1. On the machine you want to use to compile, install git and Go ≥ 1.25.
2. Clone the repository, enter into the folder and start the building process:
```sh
git clone https://github.com/bluenviron/mediamtx
cd mediamtx
go generate ./...
CGO_ENABLED=0 GOOS=my_os GOARCH=my_arch go build .
```
Replace `my_os` and `my_arch` with the operating system and architecture of your target machine. A list of all supported combinations can be obtained with:
```sh
go tool dist list
```
For instance:
```sh
CGO_ENABLED=0 GOOS=linux GOARCH=arm64 go build .
```
In case of the `arm` architecture, there's an additional flag available, `GOARM`, that allows to set the ARM version:
```sh
CGO_ENABLED=0 GOOS=linux GOARCH=arm64 GOARM=7 go build .
```
In case of the `mips` architecture, there's an additional flag available, `GOMIPS`, that allows to set additional parameters:
```sh
CGO_ENABLED=0 GOOS=linux GOARCH=mips GOMIPS=softfloat go build .
```
The command will produce the `mediamtx` binary.
## Compile for all supported platforms
Install Docker and launch:
```sh
make binaries
```
The command will produce tarballs in folder `binaries/`.
## Docker image
The official Docker image can be recompiled by following these steps:
1. Build binaries for all supported platforms:
```sh
make binaries
```
2. Build the image by using one of the Dockerfiles inside the `docker/` folder:
```
docker build . -f docker/standard.Dockerfile -t my-mediamtx
```
This will produce the `my-mediamtx` image.
A Dockerfile is available for each image variant (`standard.Dockerfile`, `ffmpeg.Dockerfile`, `rpi.Dockerfile`, `ffmpeg-rpi.Dockerfile`).
================================================
FILE: docs/6-misc/2-license.md
================================================
# License
All the code in the main _MediaMTX_ repository is released under the [MIT License](https://github.com/bluenviron/mediamtx/blob/{version_tag}/LICENSE). Compiled binaries include some third-party dependencies:
- all the Golang dependencies listed into the [go.mod file](https://github.com/bluenviron/mediamtx/blob/{version_tag}/go.mod), which are all released under either the MIT license, BSD 3-Clause license or Apache License 2.0.
- hls.js, released under the [Apache License 2.0](https://github.com/video-dev/hls.js/blob/master/LICENSE).
- mediamtx-rpicamera, which is released under the same license of _MediaMTX_ but includes some [third-party dependencies](https://github.com/bluenviron/mediamtx-rpicamera?tab=readme-ov-file#license).
================================================
FILE: docs/6-misc/3-security.md
================================================
# Security
## Security of released binaries
Binaries published in the [Releases](https://github.com/bluenviron/mediamtx/releases) section of GitHub are the output of a building process that is fully visible, prevents hidden changes or external interferences in published artifacts, and allows validation by third parties:
1. During every release, the [Release workflow](https://github.com/bluenviron/mediamtx/actions/workflows/release.yml) is triggered on GitHub.
2. The release workflow pulls the source code and builds binaries.
3. The release workflow computes SHA256 checksums of binaries and publishes them to a public blockchain (Sigstore Public Good Instance) through [GitHub Attestations](https://docs.github.com/en/actions/concepts/security/artifact-attestations).
4. Checksums and binaries are published on the Release page.
5. Binaries can be downloaded by users.
It is possible to verify that SHA256 checksums of binaries correspond to the one published on Sigstore by running:
```sh
ls mediamtx_* | xargs -L1 gh attestation verify --repo bluenviron/mediamtx
```
It is possible to verify that binaries have not been altered during transfer from GitHub to the final destination by downloading `checksums.sha256` and running:
```sh
cat checksums.sha256 | grep "$(ls mediamtx_*)" | sha256sum --check
```
## Reporting vulnerabilities
Vulnerabilities can be reported privately by using the [Security Advisory](https://github.com/bluenviron/mediamtx/security/advisories/new) feature of GitHub.
================================================
FILE: docs/6-misc/4-specifications.md
================================================
# Specifications
| name | area |
| ------------------------------------------------------------------------------------------------------------- | -------------- |
| [RTSP / RTP / RTCP specifications](https://github.com/bluenviron/gortsplib#specifications) | RTSP |
| [HLS specifications](https://github.com/bluenviron/gohlslib#specifications) | HLS |
| [RTMP specifications](https://github.com/bluenviron/gortmplib#specifications) | RTMP |
| [WebRTC: Real-Time Communication in Browsers](https://www.w3.org/TR/webrtc/) | WebRTC |
| [RFC8835, Transports for WebRTC](https://datatracker.ietf.org/doc/html/rfc8835) | WebRTC |
| [RFC7742, WebRTC Video Processing and Codec Requirements](https://datatracker.ietf.org/doc/html/rfc7742) | WebRTC |
| [RFC7874, WebRTC Audio Codec and Processing Requirements](https://datatracker.ietf.org/doc/html/rfc7874) | WebRTC |
| [RFC7875, Additional WebRTC Audio Codecs for Interoperability](https://datatracker.ietf.org/doc/html/rfc7875) | WebRTC |
| [H.265 Profile for WebRTC](https://datatracker.ietf.org/doc/draft-ietf-avtcore-hevc-webrtc/) | WebRTC |
| [WebRTC HTTP Ingestion Protocol (WHIP)](https://datatracker.ietf.org/doc/draft-ietf-wish-whip/) | WebRTC |
| [WebRTC HTTP Egress Protocol (WHEP)](https://datatracker.ietf.org/doc/draft-murillo-whep/) | WebRTC |
| [The SRT Protocol](https://haivision.github.io/srt-rfc/draft-sharabayko-srt.html) | SRT |
| [Codec specifications](https://github.com/bluenviron/mediacommon#specifications) | codecs |
| [Golang project layout](https://github.com/golang-standards/project-layout) | project layout |
================================================
FILE: docs/6-misc/5-related-projects.md
================================================
# Related projects
- [gortsplib (RTSP library used internally)](https://github.com/bluenviron/gortsplib)
- [gohlslib (HLS library used internally)](https://github.com/bluenviron/gohlslib)
- [gortmplib (RTMP library used internally)](https://github.com/bluenviron/gortmplib)
- [mediacommon (codecs and formats library used internally)](https://github.com/bluenviron/mediacommon)
- [mediamtx-rpicamera (Raspberry Pi Camera component)](https://github.com/bluenviron/mediamtx-rpicamera)
- [datarhei/gosrt (SRT library used internally)](https://github.com/datarhei/gosrt)
- [pion/webrtc (WebRTC library used internally)](https://github.com/pion/webrtc)
- [pion/sdp (SDP library used internally)](https://github.com/pion/sdp)
- [pion/rtp (RTP library used internally)](https://github.com/pion/rtp)
- [pion/rtcp (RTCP library used internally)](https://github.com/pion/rtcp)
- [go-astits (MPEG-TS library used internally)](https://github.com/asticode/go-astits)
- [go-mp4 (MP4 library used internally)](https://github.com/abema/go-mp4)
- [hls.js (browser-side HLS library used internally)](https://github.com/video-dev/hls.js)
================================================
FILE: docs/6-misc/index.md
================================================
# Misc
================================================
FILE: docs/redirects.yaml
================================================
kickoff/installation: kickoff/install
usage/publish: publish/overview
usage/read: read/overview
usage/log-management: other/logging
usage/basic-usage: other/basic-usage
usage/configuration: other/configuration
usage/authentication: other/authentication
usage/remuxing-reencoding-compression: other/remuxing-reencoding-compression
usage/always-available: other/always-available
usage/record: other/record
usage/playback: other/playback
usage/forward: other/forward
usage/proxy: other/proxy
usage/extract-snapshots: other/extract-snapshots
usage/on-demand-publishing: other/on-demand-publishing
usage/route-absolute-timestamps: other/route-absolute-timestamps
usage/expose-the-server-in-a-subfolder: other/expose-the-server-in-a-subfolder
usage/embed-streams-in-a-website: other/embed-streams-in-a-website
usage/start-on-boot: other/start-on-boot
usage/logging: other/logging
usage/hooks: other/hooks
usage/control-api: other/control-api
usage/metrics: other/metrics
usage/performance: other/performance
usage/srt-specific-features: other/srt-specific-features
usage/webrtc-specific-features: other/webrtc-specific-features
usage/rtsp-specific-features: other/rtsp-specific-features
usage/rtmp-specific-features: other/rtmp-specific-features
usage/decrease-packet-loss: other/decrease-packet-loss
other/compile: misc/compile
other/license: misc/license
other/security: misc/security
other/specifications: misc/specifications
other/related-projects: misc/related-projects
other/route-absolute-timestamps: other/absolute-timestamps
================================================
FILE: go.mod
================================================
module github.com/bluenviron/mediamtx
go 1.25.0
require (
code.cloudfoundry.org/bytefmt v0.67.0
github.com/Masterminds/semver/v3 v3.4.0
github.com/MicahParks/jwkset v0.11.0
github.com/MicahParks/keyfunc/v3 v3.8.0
github.com/abema/go-mp4 v1.5.0
github.com/alecthomas/kong v1.14.0
github.com/asticode/go-astits v1.15.0
github.com/bluenviron/gohlslib/v2 v2.2.9
github.com/bluenviron/gortmplib v0.3.0
github.com/bluenviron/gortsplib/v5 v5.5.0
github.com/bluenviron/mediacommon/v2 v2.8.3
github.com/datarhei/gosrt v0.10.0
github.com/fsnotify/fsnotify v1.9.0
github.com/gin-contrib/pprof v1.5.3
github.com/gin-gonic/gin v1.12.0
github.com/go-git/go-billy/v5 v5.8.0
github.com/go-git/go-git/v5 v5.17.0
github.com/goccy/go-yaml v1.19.2
github.com/golang-jwt/jwt/v5 v5.3.1
github.com/google/gopacket v1.1.19
github.com/google/uuid v1.6.0
github.com/gookit/color v1.6.0
github.com/gorilla/websocket v1.5.3
github.com/kballard/go-shellquote v0.0.0-20180428030007-95032a82bc51
github.com/matthewhartstonge/argon2 v1.4.6
github.com/minio/selfupdate v0.6.0
github.com/pion/ice/v4 v4.2.1
github.com/pion/interceptor v0.1.44
github.com/pion/logging v0.2.4
github.com/pion/rtcp v1.2.16
github.com/pion/rtp v1.10.1
github.com/pion/sdp/v3 v3.0.18
github.com/pion/transport/v4 v4.0.1
github.com/pion/webrtc/v4 v4.2.9
github.com/stretchr/testify v1.11.1
golang.org/x/crypto v0.49.0
golang.org/x/sys v0.42.0
golang.org/x/term v0.41.0
)
require (
aead.dev/minisign v0.2.0 // indirect
dario.cat/mergo v1.0.0 // indirect
github.com/Microsoft/go-winio v0.6.2 // indirect
github.com/ProtonMail/go-crypto v1.1.6 // indirect
github.com/asticode/go-astikit v0.30.0 // indirect
github.com/benburkert/openpgp v0.0.0-20160410205803-c2471f86866c // indirect
github.com/bytedance/gopkg v0.1.3 // indirect
github.com/bytedance/sonic v1.15.0 // indirect
github.com/bytedance/sonic/loader v0.5.0 // indirect
github.com/cloudflare/circl v1.6.3 // indirect
github.com/cloudwego/base64x v0.1.6 // indirect
github.com/cyphar/filepath-securejoin v0.4.1 // indirect
github.com/davecgh/go-spew v1.1.1 // indirect
github.com/emirpasic/gods v1.18.1 // indirect
github.com/gabriel-vasile/mimetype v1.4.12 // indirect
github.com/gin-contrib/sse v1.1.0 // indirect
github.com/go-git/gcfg v1.5.1-0.20230307220236-3a3c6141e376 // indirect
github.com/go-playground/locales v0.14.1 // indirect
github.com/go-playground/universal-translator v0.18.1 // indirect
github.com/go-playground/validator/v10 v10.30.1 // indirect
github.com/goccy/go-json v0.10.5 // indirect
github.com/golang/groupcache v0.0.0-20241129210726-2c02b8208cf8 // indirect
github.com/jbenet/go-context v0.0.0-20150711004518-d14ea06fba99 // indirect
github.com/json-iterator/go v1.1.12 // indirect
github.com/kevinburke/ssh_config v1.2.0 // indirect
github.com/klauspost/cpuid/v2 v2.3.0 // indirect
github.com/leodido/go-urn v1.4.0 // indirect
github.com/mattn/go-isatty v0.0.20 // indirect
github.com/modern-go/concurrent v0.0.0-20180306012644-bacd9c7ef1dd // indirect
github.com/modern-go/reflect2 v1.0.2 // indirect
github.com/pelletier/go-toml/v2 v2.2.4 // indirect
github.com/pion/datachannel v1.6.0 // indirect
github.com/pion/dtls/v3 v3.1.2 // indirect
github.com/pion/mdns/v2 v2.1.0 // indirect
github.com/pion/randutil v0.1.0 // indirect
github.com/pion/sctp v1.9.2 // indirect
github.com/pion/srtp/v3 v3.0.10 // indirect
github.com/pion/stun/v3 v3.1.1 // indirect
github.com/pion/turn/v4 v4.1.4 // indirect
github.com/pjbgf/sha1cd v0.3.2 // indirect
github.com/pmezard/go-difflib v1.0.0 // indirect
github.com/quic-go/qpack v0.6.0 // indirect
github.com/quic-go/quic-go v0.59.0 // indirect
github.com/sergi/go-diff v1.3.2-0.20230802210424-5b0b94c5c0d3 // indirect
github.com/skeema/knownhosts v1.3.1 // indirect
github.com/twitchyliquid64/golang-asm v0.15.1 // indirect
github.com/ugorji/go/codec v1.3.1 // indirect
github.com/wlynxg/anet v0.0.5 // indirect
github.com/xanzy/ssh-agent v0.3.3 // indirect
github.com/xo/terminfo v0.0.0-20220910002029-abceb7e1c41e // indirect
go.mongodb.org/mongo-driver/v2 v2.5.0 // indirect
golang.org/x/arch v0.22.0 // indirect
golang.org/x/net v0.52.0 // indirect
golang.org/x/text v0.35.0 // indirect
golang.org/x/time v0.12.0 // indirect
google.golang.org/protobuf v1.36.10 // indirect
gopkg.in/warnings.v0 v0.1.2 // indirect
gopkg.in/yaml.v3 v3.0.1 // indirect
)
================================================
FILE: go.sum
================================================
aead.dev/minisign v0.2.0 h1:kAWrq/hBRu4AARY6AlciO83xhNnW9UaC8YipS2uhLPk=
aead.dev/minisign v0.2.0/go.mod h1:zdq6LdSd9TbuSxchxwhpA9zEb9YXcVGoE8JakuiGaIQ=
code.cloudfoundry.org/bytefmt v0.67.0 h1:5zOnQBHYlHQMXXs42nzUJHUVTlhni0Kdlaxzwguxudg=
code.cloudfoundry.org/bytefmt v0.67.0/go.mod h1:JT2/SZbghzGk207djL8l4a1IMsxG/48vf+RbqTa/SBA=
dario.cat/mergo v1.0.0 h1:AGCNq9Evsj31mOgNPcLyXc+4PNABt905YmuqPYYpBWk=
dario.cat/mergo v1.0.0/go.mod h1:uNxQE+84aUszobStD9th8a29P2fMDhsBdgRYvZOxGmk=
github.com/Masterminds/semver/v3 v3.4.0 h1:Zog+i5UMtVoCU8oKka5P7i9q9HgrJeGzI9SA1Xbatp0=
github.com/Masterminds/semver/v3 v3.4.0/go.mod h1:4V+yj/TJE1HU9XfppCwVMZq3I84lprf4nC11bSS5beM=
github.com/MicahParks/jwkset v0.11.0 h1:yc0zG+jCvZpWgFDFmvs8/8jqqVBG9oyIbmBtmjOhoyQ=
github.com/MicahParks/jwkset v0.11.0/go.mod h1:U2oRhRaLgDCLjtpGL2GseNKGmZtLs/3O7p+OZaL5vo0=
github.com/MicahParks/keyfunc/v3 v3.8.0 h1:Hx2dgIjAXGk9slakM6rV9BOeaWDPEXXZ4Us8guNBfds=
github.com/MicahParks/keyfunc/v3 v3.8.0/go.mod h1:z66bkCviwqfg2YUp+Jcc/xRE9IXLcMq6DrgV/+Htru0=
github.com/Microsoft/go-winio v0.5.2/go.mod h1:WpS1mjBmmwHBEWmogvA2mj8546UReBk4v8QkMxJ6pZY=
github.com/Microsoft/go-winio v0.6.2 h1:F2VQgta7ecxGYO8k3ZZz3RS8fVIXVxONVUPlNERoyfY=
github.com/Microsoft/go-winio v0.6.2/go.mod h1:yd8OoFMLzJbo9gZq8j5qaps8bJ9aShtEA8Ipt1oGCvU=
github.com/ProtonMail/go-crypto v1.1.6 h1:ZcV+Ropw6Qn0AX9brlQLAUXfqLBc7Bl+f/DmNxpLfdw=
github.com/ProtonMail/go-crypto v1.1.6/go.mod h1:rA3QumHc/FZ8pAHreoekgiAbzpNsfQAosU5td4SnOrE=
github.com/abema/go-mp4 v1.5.0 h1:aJnu723gFuNswIiM08h4kO28pUZr0QXNAJGoZWT96AU=
github.com/abema/go-mp4 v1.5.0/go.mod h1:vPl9t5ZK7K0x68jh12/+ECWBCXoWuIDtNgPtU2f04ws=
github.com/alecthomas/assert/v2 v2.11.0 h1:2Q9r3ki8+JYXvGsDyBXwH3LcJ+WK5D0gc5E8vS6K3D0=
github.com/alecthomas/assert/v2 v2.11.0/go.mod h1:Bze95FyfUr7x34QZrjL+XP+0qgp/zg8yS+TtBj1WA3k=
github.com/alecthomas/kong v1.14.0 h1:gFgEUZWu2ZmZ+UhyZ1bDhuutbKN1nTtJTwh19Wsn21s=
github.com/alecthomas/kong v1.14.0/go.mod h1:wrlbXem1CWqUV5Vbmss5ISYhsVPkBb1Yo7YKJghju2I=
github.com/alecthomas/repr v0.5.2 h1:SU73FTI9D1P5UNtvseffFSGmdNci/O6RsqzeXJtP0Qs=
github.com/alecthomas/repr v0.5.2/go.mod h1:Fr0507jx4eOXV7AlPV6AVZLYrLIuIeSOWtW57eE/O/4=
github.com/anmitsu/go-shlex v0.0.0-20200514113438-38f4b401e2be h1:9AeTilPcZAjCFIImctFaOjnTIavg87rW78vTPkQqLI8=
github.com/anmitsu/go-shlex v0.0.0-20200514113438-38f4b401e2be/go.mod h1:ySMOLuWl6zY27l47sB3qLNK6tF2fkHG55UZxx8oIVo4=
github.com/armon/go-socks5 v0.0.0-20160902184237-e75332964ef5 h1:0CwZNZbxp69SHPdPJAN/hZIm0C4OItdklCFmMRWYpio=
github.com/armon/go-socks5 v0.0.0-20160902184237-e75332964ef5/go.mod h1:wHh0iHkYZB8zMSxRWpUBQtwG5a7fFgvEO+odwuTv2gs=
github.com/asticode/go-astikit v0.30.0 h1:DkBkRQRIxYcknlaU7W7ksNfn4gMFsB0tqMJflxkRsZA=
github.com/asticode/go-astikit v0.30.0/go.mod h1:h4ly7idim1tNhaVkdVBeXQZEE3L0xblP7fCWbgwipF0=
github.com/asticode/go-astits v1.15.0 h1:yRyCiUc8Jj4F7clt2GDxHghMpWuFL5rkaLuGUd2/0J4=
github.com/asticode/go-astits v1.15.0/go.mod h1:QSHmknZ51pf6KJdHKZHJTLlMegIrhega3LPWz3ND/iI=
github.com/benburkert/openpgp v0.0.0-20160410205803-c2471f86866c h1:8XZeJrs4+ZYhJeJ2aZxADI2tGADS15AzIF8MQ8XAhT4=
github.com/benburkert/openpgp v0.0.0-20160410205803-c2471f86866c/go.mod h1:x1vxHcL/9AVzuk5HOloOEPrtJY0MaalYr78afXZ+pWI=
github.com/bluenviron/gohlslib/v2 v2.2.9 h1:ahRbuBzw+FvdVDwli731RgJsErunyBDWhghpS5fT2qQ=
github.com/bluenviron/gohlslib/v2 v2.2.9/go.mod h1:kA0hTg96hmTZjeZ/Vxwpu/Njy0emAoidEoDGQ/KlMH0=
github.com/bluenviron/gortmplib v0.3.0 h1:jBNl7bYtXSq+USx70gQ4kzRsffM1h0XRjGwlHQHZVq8=
github.com/bluenviron/gortmplib v0.3.0/go.mod h1:3tUsWceMOrs8Ylt5UyQEHNHCVl52V1gi9tz+IaLTafI=
github.com/bluenviron/gortsplib/v5 v5.5.0 h1:2wlUKhlSw1ptKEVnkEuZMpQuN8Xt311Fdd/SB124JPA=
github.com/bluenviron/gortsplib/v5 v5.5.0/go.mod h1:otcPqR836QZej/EYx7njn8vl4TLj8Ya3QAf+GBwh2cQ=
github.com/bluenviron/mediacommon/v2 v2.8.3 h1:T6xb7ZK3eBixi/HynzhtGRCEIrazwcmGIeu0WDTVISY=
github.com/bluenviron/mediacommon/v2 v2.8.3/go.mod h1:CsYjGgzIz8RbloQf4BHR4uReogZsB4PEKWfePVIzJv8=
github.com/bytedance/gopkg v0.1.3 h1:TPBSwH8RsouGCBcMBktLt1AymVo2TVsBVCY4b6TnZ/M=
github.com/bytedance/gopkg v0.1.3/go.mod h1:576VvJ+eJgyCzdjS+c4+77QF3p7ubbtiKARP3TxducM=
github.com/bytedance/sonic v1.15.0 h1:/PXeWFaR5ElNcVE84U0dOHjiMHQOwNIx3K4ymzh/uSE=
github.com/bytedance/sonic v1.15.0/go.mod h1:tFkWrPz0/CUCLEF4ri4UkHekCIcdnkqXw9VduqpJh0k=
github.com/bytedance/sonic/loader v0.5.0 h1:gXH3KVnatgY7loH5/TkeVyXPfESoqSBSBEiDd5VjlgE=
github.com/bytedance/sonic/loader v0.5.0/go.mod h1:AR4NYCk5DdzZizZ5djGqQ92eEhCCcdf5x77udYiSJRo=
github.com/cloudflare/circl v1.6.3 h1:9GPOhQGF9MCYUeXyMYlqTR6a5gTrgR/fBLXvUgtVcg8=
github.com/cloudflare/circl v1.6.3/go.mod h1:2eXP6Qfat4O/Yhh8BznvKnJ+uzEoTQ6jVKJRn81BiS4=
github.com/cloudwego/base64x v0.1.6 h1:t11wG9AECkCDk5fMSoxmufanudBtJ+/HemLstXDLI2M=
github.com/cloudwego/base64x v0.1.6/go.mod h1:OFcloc187FXDaYHvrNIjxSe8ncn0OOM8gEHfghB2IPU=
github.com/creack/pty v1.1.7/go.mod h1:lj5s0c3V2DBrqTV7llrYr5NG6My20zk30Fl46Y7DoTY=
github.com/cyphar/filepath-securejoin v0.4.1 h1:JyxxyPEaktOD+GAnqIqTf9A8tHyAG22rowi7HkoSU1s=
github.com/cyphar/filepath-securejoin v0.4.1/go.mod h1:Sdj7gXlvMcPZsbhwhQ33GguGLDGQL7h7bg04C/+u9jI=
github.com/datarhei/gosrt v0.10.0 h1:dPn+gOo93JTvW2Rfd8Jfz+J/sUbdr+miE9eHUNMoPZY=
github.com/datarhei/gosrt v0.10.0/go.mod h1:M+KtvdduBtW64WqCByr6Mb27eNYBMNs0/RtTgY7d6TQ=
github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c=
github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
github.com/elazarl/goproxy v1.7.2 h1:Y2o6urb7Eule09PjlhQRGNsqRfPmYI3KKQLFpCAV3+o=
github.com/elazarl/goproxy v1.7.2/go.mod h1:82vkLNir0ALaW14Rc399OTTjyNREgmdL2cVoIbS6XaE=
github.com/emirpasic/gods v1.18.1 h1:FXtiHYKDGKCW2KzwZKx0iC0PQmdlorYgdFG9jPXJ1Bc=
github.com/emirpasic/gods v1.18.1/go.mod h1:8tpGGwCnJ5H4r6BWwaV6OrWmMoPhUl5jm/FMNAnJvWQ=
github.com/fsnotify/fsnotify v1.9.0 h1:2Ml+OJNzbYCTzsxtv8vKSFD9PbJjmhYF14k/jKC7S9k=
github.com/fsnotify/fsnotify v1.9.0/go.mod h1:8jBTzvmWwFyi3Pb8djgCCO5IBqzKJ/Jwo8TRcHyHii0=
github.com/gabriel-vasile/mimetype v1.4.12 h1:e9hWvmLYvtp846tLHam2o++qitpguFiYCKbn0w9jyqw=
github.com/gabriel-vasile/mimetype v1.4.12/go.mod h1:d+9Oxyo1wTzWdyVUPMmXFvp4F9tea18J8ufA774AB3s=
github.com/gin-contrib/pprof v1.5.3 h1:Bj5SxJ3kQDVez/s/+f9+meedJIqLS+xlkIVDe/lcvgM=
github.com/gin-contrib/pprof v1.5.3/go.mod h1:0+LQSZ4SLO0B6+2n6JBzaEygpTBxe/nI+YEYpfQQ6xY=
github.com/gin-contrib/sse v1.1.0 h1:n0w2GMuUpWDVp7qSpvze6fAu9iRxJY4Hmj6AmBOU05w=
github.com/gin-contrib/sse v1.1.0/go.mod h1:hxRZ5gVpWMT7Z0B0gSNYqqsSCNIJMjzvm6fqCz9vjwM=
github.com/gin-gonic/gin v1.12.0 h1:b3YAbrZtnf8N//yjKeU2+MQsh2mY5htkZidOM7O0wG8=
github.com/gin-gonic/gin v1.12.0/go.mod h1:VxccKfsSllpKshkBWgVgRniFFAzFb9csfngsqANjnLc=
github.com/gliderlabs/ssh v0.3.8 h1:a4YXD1V7xMF9g5nTkdfnja3Sxy1PVDCj1Zg4Wb8vY6c=
github.com/gliderlabs/ssh v0.3.8/go.mod h1:xYoytBv1sV0aL3CavoDuJIQNURXkkfPA/wxQ1pL1fAU=
github.com/go-git/gcfg v1.5.1-0.20230307220236-3a3c6141e376 h1:+zs/tPmkDkHx3U66DAb0lQFJrpS6731Oaa12ikc+DiI=
github.com/go-git/gcfg v1.5.1-0.20230307220236-3a3c6141e376/go.mod h1:an3vInlBmSxCcxctByoQdvwPiA7DTK7jaaFDBTtu0ic=
github.com/go-git/go-billy/v5 v5.8.0 h1:I8hjc3LbBlXTtVuFNJuwYuMiHvQJDq1AT6u4DwDzZG0=
github.com/go-git/go-billy/v5 v5.8.0/go.mod h1:RpvI/rw4Vr5QA+Z60c6d6LXH0rYJo0uD5SqfmrrheCY=
github.com/go-git/go-git-fixtures/v4 v4.3.2-0.20231010084843-55a94097c399 h1:eMje31YglSBqCdIqdhKBW8lokaMrL3uTkpGYlE2OOT4=
github.com/go-git/go-git-fixtures/v4 v4.3.2-0.20231010084843-55a94097c399/go.mod h1:1OCfN199q1Jm3HZlxleg+Dw/mwps2Wbk9frAWm+4FII=
github.com/go-git/go-git/v5 v5.17.0 h1:AbyI4xf+7DsjINHMu35quAh4wJygKBKBuXVjV/pxesM=
github.com/go-git/go-git/v5 v5.17.0/go.mod h1:f82C4YiLx+Lhi8eHxltLeGC5uBTXSFa6PC5WW9o4SjI=
github.com/go-logr/logr v1.4.3 h1:CjnDlHq8ikf6E492q6eKboGOC0T8CDaOvkHCIg8idEI=
github.com/go-logr/logr v1.4.3/go.mod h1:9T104GzyrTigFIr8wt5mBrctHMim0Nb2HLGrmQ40KvY=
github.com/go-playground/assert/v2 v2.2.0 h1:JvknZsQTYeFEAhQwI4qEt9cyV5ONwRHC+lYKSsYSR8s=
github.com/go-playground/assert/v2 v2.2.0/go.mod h1:VDjEfimB/XKnb+ZQfWdccd7VUvScMdVu0Titje2rxJ4=
github.com/go-playground/locales v0.14.1 h1:EWaQ/wswjilfKLTECiXz7Rh+3BjFhfDFKv/oXslEjJA=
github.com/go-playground/locales v0.14.1/go.mod h1:hxrqLVvrK65+Rwrd5Fc6F2O76J/NuW9t0sjnWqG1slY=
github.com/go-playground/universal-translator v0.18.1 h1:Bcnm0ZwsGyWbCzImXv+pAJnYK9S473LQFuzCbDbfSFY=
github.com/go-playground/universal-translator v0.18.1/go.mod h1:xekY+UJKNuX9WP91TpwSH2VMlDf28Uj24BCp08ZFTUY=
github.com/go-playground/validator/v10 v10.30.1 h1:f3zDSN/zOma+w6+1Wswgd9fLkdwy06ntQJp0BBvFG0w=
github.com/go-playground/validator/v10 v10.30.1/go.mod h1:oSuBIQzuJxL//3MelwSLD5hc2Tu889bF0Idm9Dg26cM=
github.com/go-task/slim-sprig/v3 v3.0.0 h1:sUs3vkvUymDpBKi3qH1YSqBQk9+9D/8M2mN1vB6EwHI=
github.com/go-task/slim-sprig/v3 v3.0.0/go.mod h1:W848ghGpv3Qj3dhTPRyJypKRiqCdHZiAzKg9hl15HA8=
github.com/goccy/go-json v0.10.5 h1:Fq85nIqj+gXn/S5ahsiTlK3TmC85qgirsdTP/+DeaC4=
github.com/goccy/go-json v0.10.5/go.mod h1:oq7eo15ShAhp70Anwd5lgX2pLfOS3QCiwU/PULtXL6M=
github.com/goccy/go-yaml v1.19.2 h1:PmFC1S6h8ljIz6gMRBopkjP1TVT7xuwrButHID66PoM=
github.com/goccy/go-yaml v1.19.2/go.mod h1:XBurs7gK8ATbW4ZPGKgcbrY1Br56PdM69F7LkFRi1kA=
github.com/golang-jwt/jwt/v5 v5.3.1 h1:kYf81DTWFe7t+1VvL7eS+jKFVWaUnK9cB1qbwn63YCY=
github.com/golang-jwt/jwt/v5 v5.3.1/go.mod h1:fxCRLWMO43lRc8nhHWY6LGqRcf+1gQWArsqaEUEa5bE=
github.com/golang/groupcache v0.0.0-20241129210726-2c02b8208cf8 h1:f+oWsMOmNPc8JmEHVZIycC7hBoQxHH9pNKQORJNozsQ=
github.com/golang/groupcache v0.0.0-20241129210726-2c02b8208cf8/go.mod h1:wcDNUvekVysuuOpQKo3191zZyTpiI6se1N1ULghS0sw=
github.com/google/go-cmp v0.7.0 h1:wk8382ETsv4JYUZwIsn6YpYiWiBsYLSJiTsyBybVuN8=
github.com/google/go-cmp v0.7.0/go.mod h1:pXiqmnSA92OHEEa9HXL2W4E7lf9JzCmGVUdgjX3N/iU=
github.com/google/gofuzz v1.0.0/go.mod h1:dBl0BpW6vV/+mYPU4Po3pmUjxk6FQPldtuIdl/M65Eg=
github.com/google/gopacket v1.1.19 h1:ves8RnFZPGiFnTS0uPQStjwru6uO6h+nlr9j6fL7kF8=
github.com/google/gopacket v1.1.19/go.mod h1:iJ8V8n6KS+z2U1A8pUwu8bW5SyEMkXJB8Yo/Vo+TKTo=
github.com/google/pprof v0.0.0-20260302011040-a15ffb7f9dcc h1:VBbFa1lDYWEeV5FZKUiYKYT0VxCp9twUmmaq9eb8sXw=
github.com/google/pprof v0.0.0-20260302011040-a15ffb7f9dcc/go.mod h1:MxpfABSjhmINe3F1It9d+8exIHFvUqtLIRCdOGNXqiI=
github.com/google/uuid v1.1.2/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo=
github.com/google/uuid v1.6.0 h1:NIvaJDMOsjHA8n1jAhLSgzrAzy1Hgr+hNrb57e+94F0=
github.com/google/uuid v1.6.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo=
github.com/gookit/assert v0.1.1 h1:lh3GcawXe/p+cU7ESTZ5Ui3Sm/x8JWpIis4/1aF0mY0=
github.com/gookit/assert v0.1.1/go.mod h1:jS5bmIVQZTIwk42uXl4lyj4iaaxx32tqH16CFj0VX2E=
github.com/gookit/color v1.6.0 h1:JjJXBTk1ETNyqyilJhkTXJYYigHG24TM9Xa2M1xAhRA=
github.com/gookit/color v1.6.0/go.mod h1:9ACFc7/1IpHGBW8RwuDm/0YEnhg3dwwXpoMsmtyHfjs=
github.com/gorilla/websocket v1.5.3 h1:saDtZ6Pbx/0u+bgYQ3q96pZgCzfhKXGPqt7kZ72aNNg=
github.com/gorilla/websocket v1.5.3/go.mod h1:YR8l580nyteQvAITg2hZ9XVh4b55+EU/adAjf1fMHhE=
github.com/hexops/gotextdiff v1.0.3 h1:gitA9+qJrrTCsiCl7+kh75nPqQt1cx4ZkudSTLoUqJM=
github.com/hexops/gotextdiff v1.0.3/go.mod h1:pSWU5MAI3yDq+fZBTazCSJysOMbxWL1BSow5/V2vxeg=
github.com/jbenet/go-context v0.0.0-20150711004518-d14ea06fba99 h1:BQSFePA1RWJOlocH6Fxy8MmwDt+yVQYULKfN0RoTN8A=
github.com/jbenet/go-context v0.0.0-20150711004518-d14ea06fba99/go.mod h1:1lJo3i6rXxKeerYnT8Nvf0QmHCRC1n8sfWVwXF2Frvo=
github.com/json-iterator/go v1.1.12 h1:PV8peI4a0ysnczrg+LtxykD8LfKY9ML6u2jnxaEnrnM=
github.com/json-iterator/go v1.1.12/go.mod h1:e30LSqwooZae/UwlEbR2852Gd8hjQvJoHmT4TnhNGBo=
github.com/kballard/go-shellquote v0.0.0-20180428030007-95032a82bc51 h1:Z9n2FFNUXsshfwJMBgNA0RU6/i7WVaAegv3PtuIHPMs=
github.com/kballard/go-shellquote v0.0.0-20180428030007-95032a82bc51/go.mod h1:CzGEWj7cYgsdH8dAjBGEr58BoE7ScuLd+fwFZ44+/x8=
github.com/kevinburke/ssh_config v1.2.0 h1:x584FjTGwHzMwvHx18PXxbBVzfnxogHaAReU4gf13a4=
github.com/kevinburke/ssh_config v1.2.0/go.mod h1:CT57kijsi8u/K/BOFA39wgDQJ9CxiF4nAY/ojJ6r6mM=
github.com/klauspost/cpuid/v2 v2.3.0 h1:S4CRMLnYUhGeDFDqkGriYKdfoFlDnMtqTiI/sFzhA9Y=
github.com/klauspost/cpuid/v2 v2.3.0/go.mod h1:hqwkgyIinND0mEev00jJYCxPNVRVXFQeu1XKlok6oO0=
github.com/kr/pretty v0.1.0/go.mod h1:dAy3ld7l9f0ibDNOQOHHMYYIIbhfbHSm3C4ZsoJORNo=
github.com/kr/pretty v0.3.1 h1:flRD4NNwYAUpkphVc1HcthR4KEIFJ65n8Mw5qdRn3LE=
github.com/kr/pretty v0.3.1/go.mod h1:hoEshYVHaxMs3cyo3Yncou5ZscifuDolrwPKZanG3xk=
github.com/kr/pty v1.1.1/go.mod h1:pFQYn66WHrOpPYNljwOMqo10TkYh1fy3cYio2l3bCsQ=
github.com/kr/pty v1.1.8/go.mod h1:O1sed60cT9XZ5uDucP5qwvh+TE3NnUj51EiZO/lmSfw=
github.com/kr/text v0.1.0/go.mod h1:4Jbv+DJW3UT/LiOwJeYQe1efqtUx/iVham/4vfdArNI=
github.com/kr/text v0.2.0 h1:5Nx0Ya0ZqY2ygV366QzturHI13Jq95ApcVaJBhpS+AY=
github.com/kr/text v0.2.0/go.mod h1:eLer722TekiGuMkidMxC/pM04lWEeraHUUmBw8l2grE=
github.com/leodido/go-urn v1.4.0 h1:WT9HwE9SGECu3lg4d/dIA+jxlljEa1/ffXKmRjqdmIQ=
github.com/leodido/go-urn v1.4.0/go.mod h1:bvxc+MVxLKB4z00jd1z+Dvzr47oO32F/QSNjSBOlFxI=
github.com/matthewhartstonge/argon2 v1.4.6 h1:CI9OKgahL9wxUQbbONgh8s03snO0b4uvaSXhVcjpRXI=
github.com/matthewhartstonge/argon2 v1.4.6/go.mod h1:mskW9VTvhcsq1shvh9IfHw0v+tdDRd+lFITnW9IKnMk=
github.com/mattn/go-isatty v0.0.20 h1:xfD0iDuEKnDkl03q4limB+vH+GxLEtL/jb4xVJSWWEY=
github.com/mattn/go-isatty v0.0.20/go.mod h1:W+V8PltTTMOvKvAeJH7IuucS94S2C6jfK/D7dTCTo3Y=
github.com/minio/selfupdate v0.6.0 h1:i76PgT0K5xO9+hjzKcacQtO7+MjJ4JKA8Ak8XQ9DDwU=
github.com/minio/selfupdate v0.6.0/go.mod h1:bO02GTIPCMQFTEvE5h4DjYB58bCoZ35XLeBf0buTDdM=
github.com/modern-go/concurrent v0.0.0-20180228061459-e0a39a4cb421/go.mod h1:6dJC0mAP4ikYIbvyc7fijjWJddQyLn8Ig3JB5CqoB9Q=
github.com/modern-go/concurrent v0.0.0-20180306012644-bacd9c7ef1dd h1:TRLaZ9cD/w8PVh93nsPXa1VrQ6jlwL5oN8l14QlcNfg=
github.com/modern-go/concurrent v0.0.0-20180306012644-bacd9c7ef1dd/go.mod h1:6dJC0mAP4ikYIbvyc7fijjWJddQyLn8Ig3JB5CqoB9Q=
github.com/modern-go/reflect2 v1.0.2 h1:xBagoLtFs94CBntxluKeaWgTMpvLxC4ur3nMaC9Gz0M=
github.com/modern-go/reflect2 v1.0.2/go.mod h1:yWuevngMOJpCy52FWWMvUC8ws7m/LJsjYzDa0/r8luk=
github.com/onsi/ginkgo v1.16.5 h1:8xi0RTUf59SOSfEtZMvwTvXYMzG4gV23XVHOZiXNtnE=
github.com/onsi/ginkgo/v2 v2.28.1 h1:S4hj+HbZp40fNKuLUQOYLDgZLwNUVn19N3Atb98NCyI=
github.com/onsi/ginkgo/v2 v2.28.1/go.mod h1:CLtbVInNckU3/+gC8LzkGUb9oF+e8W8TdUsxPwvdOgE=
github.com/onsi/gomega v1.39.1 h1:1IJLAad4zjPn2PsnhH70V4DKRFlrCzGBNrNaru+Vf28=
github.com/onsi/gomega v1.39.1/go.mod h1:hL6yVALoTOxeWudERyfppUcZXjMwIMLnuSfruD2lcfg=
github.com/orcaman/writerseeker v0.0.0-20200621085525-1d3f536ff85e h1:s2RNOM/IGdY0Y6qfTeUKhDawdHDpK9RGBdx80qN4Ttw=
github.com/orcaman/writerseeker v0.0.0-20200621085525-1d3f536ff85e/go.mod h1:nBdnFKj15wFbf94Rwfq4m30eAcyY9V/IyKAGQFtqkW0=
github.com/pelletier/go-toml/v2 v2.2.4 h1:mye9XuhQ6gvn5h28+VilKrrPoQVanw5PMw/TB0t5Ec4=
github.com/pelletier/go-toml/v2 v2.2.4/go.mod h1:2gIqNv+qfxSVS7cM2xJQKtLSTLUE9V8t9Stt+h56mCY=
github.com/pion/datachannel v1.6.0 h1:XecBlj+cvsxhAMZWFfFcPyUaDZtd7IJvrXqlXD/53i0=
github.com/pion/datachannel v1.6.0/go.mod h1:ur+wzYF8mWdC+Mkis5Thosk+u/VOL287apDNEbFpsIk=
github.com/pion/dtls/v3 v3.1.2 h1:gqEdOUXLtCGW+afsBLO0LtDD8GnuBBjEy6HRtyofZTc=
github.com/pion/dtls/v3 v3.1.2/go.mod h1:Hw/igcX4pdY69z1Hgv5x7wJFrUkdgHwAn/Q/uo7YHRo=
github.com/pion/ice/v4 v4.2.1 h1:XPRYXaLiFq3LFDG7a7bMrmr3mFr27G/gtXN3v/TVfxY=
github.com/pion/ice/v4 v4.2.1/go.mod h1:2quLV1S5v1tAx3VvAJaH//KGitRXvo4RKlX6D3tnN+c=
github.com/pion/interceptor v0.1.44 h1:sNlZwM8dWXU9JQAkJh8xrarC0Etn8Oolcniukmuy0/I=
github.com/pion/interceptor v0.1.44/go.mod h1:4atVlBkcgXuUP+ykQF0qOCGU2j7pQzX2ofvPRFsY5RY=
github.com/pion/logging v0.2.4 h1:tTew+7cmQ+Mc1pTBLKH2puKsOvhm32dROumOZ655zB8=
github.com/pion/logging v0.2.4/go.mod h1:DffhXTKYdNZU+KtJ5pyQDjvOAh/GsNSyv1lbkFbe3so=
github.com/pion/mdns/v2 v2.1.0 h1:3IJ9+Xio6tWYjhN6WwuY142P/1jA0D5ERaIqawg/fOY=
github.com/pion/mdns/v2 v2.1.0/go.mod h1:pcez23GdynwcfRU1977qKU0mDxSeucttSHbCSfFOd9A=
github.com/pion/randutil v0.1.0 h1:CFG1UdESneORglEsnimhUjf33Rwjubwj6xfiOXBa3mA=
github.com/pion/randutil v0.1.0/go.mod h1:XcJrSMMbbMRhASFVOlj/5hQial/Y8oH/HVo7TBZq+j8=
github.com/pion/rtcp v1.2.16 h1:fk1B1dNW4hsI78XUCljZJlC4kZOPk67mNRuQ0fcEkSo=
github.com/pion/rtcp v1.2.16/go.mod h1:/as7VKfYbs5NIb4h6muQ35kQF/J0ZVNz2Z3xKoCBYOo=
github.com/pion/rtp v1.10.1 h1:xP1prZcCTUuhO2c83XtxyOHJteISg6o8iPsE2acaMtA=
github.com/pion/rtp v1.10.1/go.mod h1:rF5nS1GqbR7H/TCpKwylzeq6yDM+MM6k+On5EgeThEM=
github.com/pion/sctp v1.9.2 h1:HxsOzEV9pWoeggv7T5kewVkstFNcGvhMPx0GvUOUQXo=
github.com/pion/sctp v1.9.2/go.mod h1:OTOlsQ5EDQ6mQ0z4MUGXt2CgQmKyafBEXhUVqLRB6G8=
github.com/pion/sdp/v3 v3.0.18 h1:l0bAXazKHpepazVdp+tPYnrsy9dfh7ZbT8DxesH5ZnI=
github.com/pion/sdp/v3 v3.0.18/go.mod h1:ZREGo6A9ZygQ9XkqAj5xYCQtQpif0i6Pa81HOiAdqQ8=
github.com/pion/srtp/v3 v3.0.10 h1:tFirkpBb3XccP5VEXLi50GqXhv5SKPxqrdlhDCJlZrQ=
github.com/pion/srtp/v3 v3.0.10/go.mod h1:3mOTIB0cq9qlbn59V4ozvv9ClW/BSEbRp4cY0VtaR7M=
github.com/pion/stun/v3 v3.1.1 h1:CkQxveJ4xGQjulGSROXbXq94TAWu8gIX2dT+ePhUkqw=
github.com/pion/stun/v3 v3.1.1/go.mod h1:qC1DfmcCTQjl9PBaMa5wSn3x9IPmKxSdcCsxBcDBndM=
github.com/pion/transport/v3 v3.1.1 h1:Tr684+fnnKlhPceU+ICdrw6KKkTms+5qHMgw6bIkYOM=
github.com/pion/transport/v3 v3.1.1/go.mod h1:+c2eewC5WJQHiAA46fkMMzoYZSuGzA/7E2FPrOYHctQ=
github.com/pion/transport/v4 v4.0.1 h1:sdROELU6BZ63Ab7FrOLn13M6YdJLY20wldXW2Cu2k8o=
github.com/pion/transport/v4 v4.0.1/go.mod h1:nEuEA4AD5lPdcIegQDpVLgNoDGreqM/YqmEx3ovP4jM=
github.com/pion/turn/v4 v4.1.4 h1:EU11yMXKIsK43FhcUnjLlrhE4nboHZq+TXBIi3QpcxQ=
github.com/pion/turn/v4 v4.1.4/go.mod h1:ES1DXVFKnOhuDkqn9hn5VJlSWmZPaRJLyBXoOeO/BmQ=
github.com/pion/webrtc/v4 v4.2.9 h1:DZIh1HAhPIL3RvwEDFsmL5hfPSLEpxsQk9/Jir2vkJE=
github.com/pion/webrtc/v4 v4.2.9/go.mod h1:9EmLZve0H76eTzf8v2FmchZ6tcBXtDgpfTEu+drW6SY=
github.com/pjbgf/sha1cd v0.3.2 h1:a9wb0bp1oC2TGwStyn0Umc/IGKQnEgF0vVaZ8QF8eo4=
github.com/pjbgf/sha1cd v0.3.2/go.mod h1:zQWigSxVmsHEZow5qaLtPYxpcKMMQpa09ixqBxuCS6A=
github.com/pkg/errors v0.9.1 h1:FEBLx1zS214owpjy7qsBeixbURkuhQAwrK5UwLGTwt4=
github.com/pkg/errors v0.9.1/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0=
github.com/pkg/profile v1.4.0/go.mod h1:NWz/XGvpEW1FyYQ7fCx4dqYBLlfTcE+A9FLAkNKqjFE=
github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM=
github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
github.com/quic-go/qpack v0.6.0 h1:g7W+BMYynC1LbYLSqRt8PBg5Tgwxn214ZZR34VIOjz8=
github.com/quic-go/qpack v0.6.0/go.mod h1:lUpLKChi8njB4ty2bFLX2x4gzDqXwUpaO1DP9qMDZII=
github.com/quic-go/quic-go v0.59.0 h1:OLJkp1Mlm/aS7dpKgTc6cnpynnD2Xg7C1pwL6vy/SAw=
github.com/quic-go/quic-go v0.59.0/go.mod h1:upnsH4Ju1YkqpLXC305eW3yDZ4NfnNbmQRCMWS58IKU=
github.com/rogpeppe/go-internal v1.14.1 h1:UQB4HGPB6osV0SQTLymcB4TgvyWu6ZyliaW0tI/otEQ=
github.com/rogpeppe/go-internal v1.14.1/go.mod h1:MaRKkUm5W0goXpeCfT7UZI6fk/L7L7so1lCWt35ZSgc=
github.com/sergi/go-diff v1.3.2-0.20230802210424-5b0b94c5c0d3 h1:n661drycOFuPLCN3Uc8sB6B/s6Z4t2xvBgU1htSHuq8=
github.com/sergi/go-diff v1.3.2-0.20230802210424-5b0b94c5c0d3/go.mod h1:A0bzQcvG0E7Rwjx0REVgAGH58e96+X0MeOfepqsbeW4=
github.com/sirupsen/logrus v1.7.0/go.mod h1:yWOB1SBYBC5VeMP7gHvWumXLIWorT60ONWic61uBYv0=
github.com/skeema/knownhosts v1.3.1 h1:X2osQ+RAjK76shCbvhHHHVl3ZlgDm8apHEHFqRjnBY8=
github.com/skeema/knownhosts v1.3.1/go.mod h1:r7KTdC8l4uxWRyK2TpQZ/1o5HaSzh06ePQNxPwTcfiY=
github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
github.com/stretchr/objx v0.4.0/go.mod h1:YvHI0jy2hoMjB+UWwv71VJQ9isScKT/TqJzVSSt89Yw=
github.com/stretchr/objx v0.5.0/go.mod h1:Yh+to48EsGEfYuaHDzXPcE3xhTkx73EhmCGUpEOglKo=
github.com/stretchr/objx v0.5.2/go.mod h1:FRsXN1f5AsAjCGJKqEizvkpNtU+EGNCLh3NxZ/8L+MA=
github.com/stretchr/testify v1.2.2/go.mod h1:a8OnRcib4nhh0OaRAV+Yts87kKdq0PP7pXfy6kDkUVs=
github.com/stretchr/testify v1.3.0/go.mod h1:M5WIy9Dh21IEIfnGCwXGc5bZfKNJtfHm1UVUgZn+9EI=
github.com/stretchr/testify v1.4.0/go.mod h1:j7eGeouHqKxXV5pUuKE4zz7dFj8WfuZ+81PSLYec5m4=
github.com/stretchr/testify v1.7.1/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg=
github.com/stretchr/testify v1.8.0/go.mod h1:yNjHg4UonilssWZ8iaSj1OCr/vHnekPRkoO+kdMU+MU=
github.com/stretchr/testify v1.8.4/go.mod h1:sz/lmYIOXD/1dqDmKjjqLyZ2RngseejIcXlSw2iwfAo=
github.com/stretchr/testify v1.10.0/go.mod h1:r2ic/lqez/lEtzL7wO/rwa5dbSLXVDPFyf8C91i36aY=
github.com/stretchr/testify v1.11.1 h1:7s2iGBzp5EwR7/aIZr8ao5+dra3wiQyKjjFuvgVKu7U=
github.com/stretchr/testify v1.11.1/go.mod h1:wZwfW3scLgRK+23gO65QZefKpKQRnfz6sD981Nm4B6U=
github.com/sunfish-shogi/bufseekio v0.0.0-20210207115823-a4185644b365/go.mod h1:dEzdXgvImkQ3WLI+0KQpmEx8T/C/ma9KeS3AfmU899I=
github.com/twitchyliquid64/golang-asm v0.15.1 h1:SU5vSMR7hnwNxj24w34ZyCi/FmDZTkS4MhqMhdFk5YI=
github.com/twitchyliquid64/golang-asm v0.15.1/go.mod h1:a1lVb/DtPvCB8fslRZhAngC2+aY1QWCk3Cedj/Gdt08=
github.com/ugorji/go/codec v1.3.1 h1:waO7eEiFDwidsBN6agj1vJQ4AG7lh2yqXyOXqhgQuyY=
github.com/ugorji/go/codec v1.3.1/go.mod h1:pRBVtBSKl77K30Bv8R2P+cLSGaTtex6fsA2Wjqmfxj4=
github.com/wlynxg/anet v0.0.5 h1:J3VJGi1gvo0JwZ/P1/Yc/8p63SoW98B5dHkYDmpgvvU=
github.com/wlynxg/anet v0.0.5/go.mod h1:eay5PRQr7fIVAMbTbchTnO9gG65Hg/uYGdc7mguHxoA=
github.com/xanzy/ssh-agent v0.3.3 h1:+/15pJfg/RsTxqYcX6fHqOXZwwMP+2VyYWJeWM2qQFM=
github.com/xanzy/ssh-agent v0.3.3/go.mod h1:6dzNDKs0J9rVPHPhaGCukekBHKqfl+L3KghI1Bc68Uw=
github.com/xo/terminfo v0.0.0-20220910002029-abceb7e1c41e h1:JVG44RsyaB9T2KIHavMF/ppJZNG9ZpyihvCd0w101no=
github.com/xo/terminfo v0.0.0-20220910002029-abceb7e1c41e/go.mod h1:RbqR21r5mrJuqunuUZ/Dhy/avygyECGrLceyNeo4LiM=
go.mongodb.org/mongo-driver/v2 v2.5.0 h1:yXUhImUjjAInNcpTcAlPHiT7bIXhshCTL3jVBkF3xaE=
go.mongodb.org/mongo-driver/v2 v2.5.0/go.mod h1:yOI9kBsufol30iFsl1slpdq1I0eHPzybRWdyYUs8K/0=
go.uber.org/mock v0.6.0 h1:hyF9dfmbgIX5EfOdasqLsWD6xqpNZlXblLB/Dbnwv3Y=
go.uber.org/mock v0.6.0/go.mod h1:KiVJ4BqZJaMj4svdfmHM0AUx4NJYO8ZNpPnZn1Z+BBU=
go.yaml.in/yaml/v3 v3.0.4 h1:tfq32ie2Jv2UxXFdLJdh3jXuOzWiL1fo0bu/FbuKpbc=
go.yaml.in/yaml/v3 v3.0.4/go.mod h1:DhzuOOF2ATzADvBadXxruRBLzYTpT36CKvDb3+aBEFg=
golang.org/x/arch v0.22.0 h1:c/Zle32i5ttqRXjdLyyHZESLD/bB90DCU1g9l/0YBDI=
golang.org/x/arch v0.22.0/go.mod h1:dNHoOeKiyja7GTvF9NJS1l3Z2yntpQNzgrjh1cU103A=
golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w=
golang.org/x/crypto v0.0.0-20191011191535-87dc89f01550/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI=
golang.org/x/crypto v0.0.0-20210220033148-5ea612d1eb83/go.mod h1:jdWPYTVW3xRLrWPugEBEK3UY2ZEsg3UU495nc5E+M+I=
golang.org/x/crypto v0.0.0-20211209193657-4570a0811e8b/go.mod h1:IxCIyHEi3zRg3s0A5j5BB6A9Jmi73HwBIUl50j+osU4=
golang.org/x/crypto v0.0.0-20220622213112-05595931fe9d/go.mod h1:IxCIyHEi3zRg3s0A5j5BB6A9Jmi73HwBIUl50j+osU4=
golang.org/x/crypto v0.49.0 h1:+Ng2ULVvLHnJ/ZFEq4KdcDd/cfjrrjjNSXNzxg0Y4U4=
golang.org/x/crypto v0.49.0/go.mod h1:ErX4dUh2UM+CFYiXZRTcMpEcN8b/1gxEuv3nODoYtCA=
golang.org/x/exp v0.0.0-20240719175910-8a7402abbf56 h1:2dVuKD2vS7b0QIHQbpyTISPd0LeHDbnYEryqj5Q1ug8=
golang.org/x/exp v0.0.0-20240719175910-8a7402abbf56/go.mod h1:M4RDyNAINzryxdtnbRXRL/OHtkFuWGRjvuhBJpk2IlY=
golang.org/x/lint v0.0.0-20200302205851-738671d3881b/go.mod h1:3xt1FjdF8hUf6vQPIChWIBhFzV8gjjsPE/fR3IyQdNY=
golang.org/x/mod v0.1.1-0.20191105210325-c90efee705ee/go.mod h1:QqPTAvyqsEbceGzBzNggFXnrqF1CaUcvgkdR5Ot7KZg=
golang.org/x/mod v0.34.0 h1:xIHgNUUnW6sYkcM5Jleh05DvLOtwc6RitGHbDk4akRI=
golang.org/x/mod v0.34.0/go.mod h1:ykgH52iCZe79kzLLMhyCUzhMci+nQj+0XkbXpNYtVjY=
golang.org/x/net v0.0.0-20190404232315-eb5bcb51f2a3/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg=
golang.org/x/net v0.0.0-20190620200207-3b0461eec859/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
golang.org/x/net v0.0.0-20211112202133-69e39bad7dc2/go.mod h1:9nx3DQGgdP8bBQD5qxJ1jj9UTztislL4KSBs9R2vV5Y=
golang.org/x/net v0.52.0 h1:He/TN1l0e4mmR3QqHMT2Xab3Aj3L9qjbhRm78/6jrW0=
golang.org/x/net v0.52.0/go.mod h1:R1MAz7uMZxVMualyPXb+VaqGSa3LIaUqk0eEt3w36Sw=
golang.org/x/sync v0.0.0-20190423024810-112230192c58/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
golang.org/x/sync v0.20.0 h1:e0PTpb7pjO8GAtTs2dQ6jYa5BWYlMuX047Dco/pItO4=
golang.org/x/sync v0.20.0/go.mod h1:9xrNwdLfx4jkKbNva9FpL6vEN7evnE43NNNJQ2LF3+0=
golang.org/x/sys v0.0.0-20190215142949-d0b11bdaac8a/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
golang.org/x/sys v0.0.0-20190412213103-97732733099d/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
golang.org/x/sys v0.0.0-20190726091711-fc99dfbffb4e/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
golang.org/x/sys v0.0.0-20191026070338-33540a1f6037/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
golang.org/x/sys v0.0.0-20201119102817-f84b799fce68/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
golang.org/x/sys v0.0.0-20210124154548-22da62e12c0c/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
golang.org/x/sys v0.0.0-20210228012217-479acdf4ea46/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
golang.org/x/sys v0.0.0-20210423082822-04245dca01da/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
golang.org/x/sys v0.0.0-20210615035016-665e8c7367d1/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
golang.org/x/sys v0.0.0-20220715151400-c0bba94af5f8/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
golang.org/x/sys v0.6.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
golang.org/x/sys v0.42.0 h1:omrd2nAlyT5ESRdCLYdm3+fMfNFE/+Rf4bDIQImRJeo=
golang.org/x/sys v0.42.0/go.mod h1:4GL1E5IUh+htKOUEOaiffhrAeqysfVGipDYzABqnCmw=
golang.org/x/term v0.0.0-20201117132131-f5c789dd3221/go.mod h1:Nr5EML6q2oocZ2LXRh80K7BxOlk5/8JxuGnuhpl+muw=
golang.org/x/term v0.0.0-20201126162022-7de9c90e9dd1/go.mod h1:bj7SfCRtBDWHUb9snDiAeCFNEtKQo2Wmx5Cou7ajbmo=
golang.org/x/term v0.0.0-20210927222741-03fcf44c2211/go.mod h1:jbD1KX2456YbFQfuXm/mYQcufACuNUgVhRMnK/tPxf8=
golang.org/x/term v0.41.0 h1:QCgPso/Q3RTJx2Th4bDLqML4W6iJiaXFq2/ftQF13YU=
golang.org/x/term v0.41.0/go.mod h1:3pfBgksrReYfZ5lvYM0kSO0LIkAl4Yl2bXOkKP7Ec2A=
golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=
golang.org/x/text v0.3.6/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ=
golang.org/x/text v0.35.0 h1:JOVx6vVDFokkpaq1AEptVzLTpDe9KGpj5tR4/X+ybL8=
golang.org/x/text v0.35.0/go.mod h1:khi/HExzZJ2pGnjenulevKNX1W67CUy0AsXcNubPGCA=
golang.org/x/time v0.12.0 h1:ScB/8o8olJvc+CQPWrK3fPZNfh7qgwCrY0zJmoEQLSE=
golang.org/x/time v0.12.0/go.mod h1:CDIdPxbZBQxdj6cxyCIdrNogrJKMJ7pr37NYpMcMDSg=
golang.org/x/tools v0.0.0-20180917221912-90fa682c2a6e/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=
golang.org/x/tools v0.0.0-20200130002326-2f3ba24bd6e7/go.mod h1:TB2adYChydJhpapKDTa4BR/hXlZSLoq2Wpct/0txZ28=
golang.org/x/tools v0.43.0 h1:12BdW9CeB3Z+J/I/wj34VMl8X+fEXBxVR90JeMX5E7s=
golang.org/x/tools v0.43.0/go.mod h1:uHkMso649BX2cZK6+RpuIPXS3ho2hZo4FVwfoy1vIk0=
golang.org/x/xerrors v0.0.0-20191011141410-1b5146add898/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
google.golang.org/protobuf v1.36.10 h1:AYd7cD/uASjIL6Q9LiTjz8JLcrh/88q5UObnmY3aOOE=
google.golang.org/protobuf v1.36.10/go.mod h1:HTf+CrKn2C3g5S8VImy6tdcUvCska2kB7j23XfzDpco=
gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
gopkg.in/check.v1 v1.0.0-20180628173108-788fd7840127/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
gopkg.in/check.v1 v1.0.0-20190902080502-41f04d3bba15/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c h1:Hei/4ADfdWqJk1ZMxUNpqntNwaWcugrBjAiHlqqRiVk=
gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c/go.mod h1:JHkPIbrfpd72SG/EVd6muEfDQjcINNoR0C8j2r3qZ4Q=
gopkg.in/src-d/go-billy.v4 v4.3.2 h1:0SQA1pRztfTFx2miS8sA97XvooFeNOmvUenF4o0EcVg=
gopkg.in/src-d/go-billy.v4 v4.3.2/go.mod h1:nDjArDMp+XMs1aFAESLRjfGSgfvoYN0hDfzEk0GjC98=
gopkg.in/warnings.v0 v0.1.2 h1:wFXVbFY8DY5/xOe1ECiWdKCzZlxgshcYVNkBHstARME=
gopkg.in/warnings.v0 v0.1.2/go.mod h1:jksf8JmL6Qr/oQM2OXTHunEvvTAsrWBLb6OOjuVWRNI=
gopkg.in/yaml.v2 v2.2.2/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
gopkg.in/yaml.v2 v2.2.8/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
gopkg.in/yaml.v2 v2.4.0/go.mod h1:RDklbk79AGWmwhnvt/jBztapEOGDOx6ZbXqjP6csGnQ=
gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA=
gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
================================================
FILE: internal/api/api.go
================================================
// Package api contains the API server.
package api //nolint:revive
import (
"net"
"net/http"
"reflect"
"sort"
"sync"
"time"
"github.com/gin-gonic/gin"
"github.com/bluenviron/mediamtx/internal/auth"
"github.com/bluenviron/mediamtx/internal/conf"
"github.com/bluenviron/mediamtx/internal/defs"
"github.com/bluenviron/mediamtx/internal/logger"
"github.com/bluenviron/mediamtx/internal/protocols/httpp"
"github.com/bluenviron/mediamtx/internal/recordstore"
)
func interfaceIsEmpty(i any) bool {
return reflect.ValueOf(i).Kind() != reflect.Pointer || reflect.ValueOf(i).IsNil()
}
func sortedKeys(paths map[string]*conf.Path) []string {
ret := make([]string, len(paths))
i := 0
for name := range paths {
ret[i] = name
i++
}
sort.Strings(ret)
return ret
}
func paramName(ctx *gin.Context) (string, bool) {
name := ctx.Param("name")
if len(name) < 2 || name[0] != '/' {
return "", false
}
return name[1:], true
}
func recordingsOfPath(
pathConf *conf.Path,
pathName string,
) *defs.APIRecording {
ret := &defs.APIRecording{
Name: pathName,
}
segments, _ := recordstore.FindSegments(pathConf, pathName, nil, nil)
ret.Segments = make([]defs.APIRecordingSegment, len(segments))
for i, seg := range segments {
ret.Segments[i] = defs.APIRecordingSegment{
Start: seg.Start,
}
}
return ret
}
type apiAuthManager interface {
Authenticate(req *auth.Request) (string, *auth.Error)
RefreshJWTJWKS()
}
type apiParent interface {
logger.Writer
APIConfigSet(conf *conf.Conf)
}
// API is an API server.
type API struct {
Version string
Started time.Time
Address string
DumpPackets bool
Encryption bool
ServerKey string
ServerCert string
AllowOrigins []string
TrustedProxies conf.IPNetworks
ReadTimeout conf.Duration
WriteTimeout conf.Duration
Conf *conf.Conf
AuthManager apiAuthManager
PathManager defs.APIPathManager
RTSPServer defs.APIRTSPServer
RTSPSServer defs.APIRTSPServer
RTMPServer defs.APIRTMPServer
RTMPSServer defs.APIRTMPServer
HLSServer defs.APIHLSServer
WebRTCServer defs.APIWebRTCServer
SRTServer defs.APISRTServer
Parent apiParent
httpServer *httpp.Server
mutex sync.RWMutex
}
// Initialize initializes API.
func (a *API) Initialize() error {
router := gin.New()
router.SetTrustedProxies(a.TrustedProxies.ToTrustedProxies()) //nolint:errcheck
router.Use(a.middlewarePreflightRequests)
router.Use(a.middlewareAuth)
group := router.Group("/v3")
group.GET("/info", a.onInfo)
group.POST("/auth/jwks/refresh", a.onAuthJwksRefresh)
group.GET("/config/global/get", a.onConfigGlobalGet)
group.PATCH("/config/global/patch", a.onConfigGlobalPatch)
group.GET("/config/pathdefaults/get", a.onConfigPathDefaultsGet)
group.PATCH("/config/pathdefaults/patch", a.onConfigPathDefaultsPatch)
group.GET("/config/paths/list", a.onConfigPathsList)
group.GET("/config/paths/get/*name", a.onConfigPathsGet)
group.POST("/config/paths/add/*name", a.onConfigPathsAdd)
group.PATCH("/config/paths/patch/*name", a.onConfigPathsPatch)
group.POST("/config/paths/replace/*name", a.onConfigPathsReplace)
group.DELETE("/config/paths/delete/*name", a.onConfigPathsDelete)
group.GET("/paths/list", a.onPathsList)
group.GET("/paths/get/*name", a.onPathsGet)
if !interfaceIsEmpty(a.HLSServer) {
group.GET("/hlsmuxers/list", a.onHLSMuxersList)
group.GET("/hlsmuxers/get/*name", a.onHLSMuxersGet)
}
if !interfaceIsEmpty(a.RTSPServer) {
group.GET("/rtspconns/list", a.onRTSPConnsList)
group.GET("/rtspconns/get/:id", a.onRTSPConnsGet)
group.GET("/rtspsessions/list", a.onRTSPSessionsList)
group.GET("/rtspsessions/get/:id", a.onRTSPSessionsGet)
group.POST("/rtspsessions/kick/:id", a.onRTSPSessionsKick)
}
if !interfaceIsEmpty(a.RTSPSServer) {
group.GET("/rtspsconns/list", a.onRTSPSConnsList)
group.GET("/rtspsconns/get/:id", a.onRTSPSConnsGet)
group.GET("/rtspssessions/list", a.onRTSPSSessionsList)
group.GET("/rtspssessions/get/:id", a.onRTSPSSessionsGet)
group.POST("/rtspssessions/kick/:id", a.onRTSPSSessionsKick)
}
if !interfaceIsEmpty(a.RTMPServer) {
group.GET("/rtmpconns/list", a.onRTMPConnsList)
group.GET("/rtmpconns/get/:id", a.onRTMPConnsGet)
group.POST("/rtmpconns/kick/:id", a.onRTMPConnsKick)
}
if !interfaceIsEmpty(a.RTMPSServer) {
group.GET("/rtmpsconns/list", a.onRTMPSConnsList)
group.GET("/rtmpsconns/get/:id", a.onRTMPSConnsGet)
group.POST("/rtmpsconns/kick/:id", a.onRTMPSConnsKick)
}
if !interfaceIsEmpty(a.WebRTCServer) {
group.GET("/webrtcsessions/list", a.onWebRTCSessionsList)
group.GET("/webrtcsessions/get/:id", a.onWebRTCSessionsGet)
group.POST("/webrtcsessions/kick/:id", a.onWebRTCSessionsKick)
}
if !interfaceIsEmpty(a.SRTServer) {
group.GET("/srtconns/list", a.onSRTConnsList)
group.GET("/srtconns/get/:id", a.onSRTConnsGet)
group.POST("/srtconns/kick/:id", a.onSRTConnsKick)
}
group.GET("/recordings/list", a.onRecordingsList)
group.GET("/recordings/get/*name", a.onRecordingsGet)
group.DELETE("/recordings/deletesegment", a.onRecordingDeleteSegment)
a.httpServer = &httpp.Server{
Address: a.Address,
AllowOrigins: a.AllowOrigins,
DumpPackets: a.DumpPackets,
DumpPacketsPrefix: "api_server_conn",
ReadTimeout: time.Duration(a.ReadTimeout),
WriteTimeout: time.Duration(a.WriteTimeout),
Encryption: a.Encryption,
ServerCert: a.ServerCert,
ServerKey: a.ServerKey,
Handler: router,
Parent: a,
}
err := a.httpServer.Initialize()
if err != nil {
return err
}
a.Log(logger.Info, "listener opened on "+a.Address)
return nil
}
// Close closes the API.
func (a *API) Close() {
a.Log(logger.Info, "listener is closing")
a.httpServer.Close()
}
// Log implements logger.Writer.
func (a *API) Log(level logger.Level, format string, args ...any) {
a.Parent.Log(level, "[API] "+format, args...)
}
func (a *API) writeError(ctx *gin.Context, status int, err error) {
// show error in logs
a.Log(logger.Error, err.Error())
// add error to response
ctx.JSON(status, &defs.APIError{
Status: defs.APIErrorStatusError,
Error: err.Error(),
})
}
func (a *API) writeOK(ctx *gin.Context) {
ctx.JSON(http.StatusOK, &defs.APIOK{Status: defs.APIOKStatusOK})
}
func (a *API) middlewarePreflightRequests(ctx *gin.Context) {
if ctx.Request.Method == http.MethodOptions &&
ctx.Request.Header.Get("Access-Control-Request-Method") != "" {
ctx.Header("Access-Control-Allow-Methods", "OPTIONS, GET, POST, PATCH, DELETE")
ctx.Header("Access-Control-Allow-Headers", "Authorization, Content-Type")
ctx.AbortWithStatus(http.StatusNoContent)
return
}
}
func (a *API) middlewareAuth(ctx *gin.Context) {
req := &auth.Request{
Action: conf.AuthActionAPI,
Query: ctx.Request.URL.RawQuery,
Credentials: httpp.Credentials(ctx.Request),
IP: net.ParseIP(ctx.ClientIP()),
}
_, err := a.AuthManager.Authenticate(req)
if err != nil {
if err.AskCredentials {
ctx.Header("WWW-Authenticate", `Basic realm="mediamtx"`)
ctx.AbortWithStatusJSON(http.StatusUnauthorized, &defs.APIError{
Status: defs.APIErrorStatusError,
Error: "authentication error",
})
return
}
a.Log(logger.Info, "connection %v failed to authenticate: %v", httpp.RemoteAddr(ctx), err.Wrapped)
// wait some seconds to delay brute force attacks
<-time.After(auth.PauseAfterError)
ctx.AbortWithStatusJSON(http.StatusUnauthorized, &defs.APIError{
Status: defs.APIErrorStatusError,
Error: "authentication error",
})
return
}
}
func (a *API) onInfo(ctx *gin.Context) {
ctx.JSON(http.StatusOK, &defs.APIInfo{
Version: a.Version,
Started: a.Started,
})
}
func (a *API) onAuthJwksRefresh(ctx *gin.Context) {
a.AuthManager.RefreshJWTJWKS()
a.writeOK(ctx)
}
// ReloadConf is called by core.
func (a *API) ReloadConf(conf *conf.Conf) {
a.mutex.Lock()
defer a.mutex.Unlock()
a.Conf = conf
}
================================================
FILE: internal/api/api_config_global.go
================================================
package api //nolint:revive
import (
"net/http"
"github.com/bluenviron/mediamtx/internal/conf"
"github.com/bluenviron/mediamtx/internal/conf/jsonwrapper"
"github.com/gin-gonic/gin"
)
func (a *API) onConfigGlobalGet(ctx *gin.Context) {
a.mutex.RLock()
c := a.Conf
a.mutex.RUnlock()
ctx.JSON(http.StatusOK, c.Global())
}
func (a *API) onConfigGlobalPatch(ctx *gin.Context) {
var c conf.OptionalGlobal
err := jsonwrapper.Decode(ctx.Request.Body, &c)
if err != nil {
a.writeError(ctx, http.StatusBadRequest, err)
return
}
a.mutex.Lock()
defer a.mutex.Unlock()
newConf := a.Conf.Clone()
newConf.PatchGlobal(&c)
err = newConf.Validate(nil)
if err != nil {
a.writeError(ctx, http.StatusBadRequest, err)
return
}
a.Conf = newConf
// since reloading the configuration can cause the shutdown of the API,
// call it in a goroutine
go a.Parent.APIConfigSet(newConf)
a.writeOK(ctx)
}
================================================
FILE: internal/api/api_config_global_test.go
================================================
package api //nolint:revive
import (
"bytes"
"encoding/json"
"net/http"
"testing"
"time"
"github.com/bluenviron/mediamtx/internal/auth"
"github.com/bluenviron/mediamtx/internal/conf"
"github.com/bluenviron/mediamtx/internal/test"
"github.com/stretchr/testify/require"
)
func TestConfigGlobalGet(t *testing.T) {
cnf := tempConf(t, "api: yes\n")
checked := false
api := API{
Address: "localhost:9997",
ReadTimeout: conf.Duration(10 * time.Second),
WriteTimeout: conf.Duration(10 * time.Second),
Conf: cnf,
AuthManager: &test.AuthManager{
AuthenticateImpl: func(req *auth.Request) (string, *auth.Error) {
require.Equal(t, conf.AuthActionAPI, req.Action)
require.Equal(t, "myuser", req.Credentials.User)
require.Equal(t, "mypass", req.Credentials.Pass)
checked = true
return req.Credentials.User, nil
},
},
Parent: &testParent{},
}
err := api.Initialize()
require.NoError(t, err)
defer api.Close()
tr := &http.Transport{}
defer tr.CloseIdleConnections()
hc := &http.Client{Transport: tr}
var out map[string]any
httpRequest(t, hc, http.MethodGet, "http://myuser:mypass@localhost:9997/v3/config/global/get", nil, &out)
require.Equal(t, true, out["api"])
require.True(t, checked)
}
func TestConfigGlobalPatch(t *testing.T) {
cnf := tempConf(t, "api: yes\n")
api := API{
Address: "localhost:9997",
ReadTimeout: conf.Duration(10 * time.Second),
WriteTimeout: conf.Duration(10 * time.Second),
Conf: cnf,
AuthManager: test.NilAuthManager,
Parent: &testParent{},
}
err := api.Initialize()
require.NoError(t, err)
defer api.Close()
tr := &http.Transport{}
defer tr.CloseIdleConnections()
hc := &http.Client{Transport: tr}
httpRequest(t, hc, http.MethodPatch, "http://localhost:9997/v3/config/global/patch",
map[string]any{
"rtmp": false,
"readTimeout": "7s",
"protocols": []string{"tcp"},
"readBufferCount": 4096, // test setting a deprecated parameter
}, nil)
time.Sleep(500 * time.Millisecond)
var out map[string]any
httpRequest(t, hc, http.MethodGet, "http://localhost:9997/v3/config/global/get", nil, &out)
require.Equal(t, false, out["rtmp"])
require.Equal(t, "7s", out["readTimeout"])
require.Equal(t, []any{"tcp"}, out["protocols"])
require.Equal(t, float64(4096), out["readBufferCount"])
}
func TestConfigGlobalPatchUnknownField(t *testing.T) { //nolint:dupl
cnf := tempConf(t, "api: yes\n")
api := API{
Address: "localhost:9997",
ReadTimeout: conf.Duration(10 * time.Second),
WriteTimeout: conf.Duration(10 * time.Second),
Conf: cnf,
AuthManager: test.NilAuthManager,
Parent: &testParent{},
}
err := api.Initialize()
require.NoError(t, err)
defer api.Close()
b := map[string]any{
"test": "asd",
}
byts, err := json.Marshal(b)
require.NoError(t, err)
tr := &http.Transport{}
defer tr.CloseIdleConnections()
hc := &http.Client{Transport: tr}
req, err := http.NewRequest(http.MethodPatch, "http://localhost:9997/v3/config/global/patch",
bytes.NewReader(byts))
require.NoError(t, err)
res, err := hc.Do(req)
require.NoError(t, err)
defer res.Body.Close()
require.Equal(t, http.StatusBadRequest, res.StatusCode)
checkError(t, res.Body, "json: unknown field \"test\"")
}
================================================
FILE: internal/api/api_config_pathdefaults.go
================================================
package api //nolint:revive
import (
"net/http"
"github.com/bluenviron/mediamtx/internal/conf"
"github.com/bluenviron/mediamtx/internal/conf/jsonwrapper"
"github.com/gin-gonic/gin"
)
func (a *API) onConfigPathDefaultsGet(ctx *gin.Context) {
a.mutex.RLock()
c := a.Conf
a.mutex.RUnlock()
ctx.JSON(http.StatusOK, c.PathDefaults)
}
func (a *API) onConfigPathDefaultsPatch(ctx *gin.Context) {
var p conf.OptionalPath
err := jsonwrapper.Decode(ctx.Request.Body, &p)
if err != nil {
a.writeError(ctx, http.StatusBadRequest, err)
return
}
a.mutex.Lock()
defer a.mutex.Unlock()
newConf := a.Conf.Clone()
newConf.PatchPathDefaults(&p)
err = newConf.Validate(nil)
if err != nil {
a.writeError(ctx, http.StatusBadRequest, err)
return
}
a.Conf = newConf
a.Parent.APIConfigSet(newConf)
a.writeOK(ctx)
}
================================================
FILE: internal/api/api_config_pathdefaults_test.go
================================================
package api //nolint:revive
import (
"net/http"
"testing"
"time"
"github.com/bluenviron/mediamtx/internal/conf"
"github.com/bluenviron/mediamtx/internal/test"
"github.com/stretchr/testify/require"
)
func TestConfigPathDefaultsGet(t *testing.T) {
cnf := tempConf(t, "api: yes\n")
api := API{
Address: "localhost:9997",
ReadTimeout: conf.Duration(10 * time.Second),
WriteTimeout: conf.Duration(10 * time.Second),
Conf: cnf,
AuthManager: test.NilAuthManager,
Parent: &testParent{},
}
err := api.Initialize()
require.NoError(t, err)
defer api.Close()
tr := &http.Transport{}
defer tr.CloseIdleConnections()
hc := &http.Client{Transport: tr}
var out map[string]any
httpRequest(t, hc, http.MethodGet, "http://localhost:9997/v3/config/pathdefaults/get", nil, &out)
require.Equal(t, "publisher", out["source"])
}
func TestConfigPathDefaultsPatch(t *testing.T) {
cnf := tempConf(t, "api: yes\n")
api := API{
Address: "localhost:9997",
ReadTimeout: conf.Duration(10 * time.Second),
WriteTimeout: conf.Duration(10 * time.Second),
Conf: cnf,
AuthManager: test.NilAuthManager,
Parent: &testParent{},
}
err := api.Initialize()
require.NoError(t, err)
defer api.Close()
tr := &http.Transport{}
defer tr.CloseIdleConnections()
hc := &http.Client{Transport: tr}
httpRequest(t, hc, http.MethodPatch, "http://localhost:9997/v3/config/pathdefaults/patch",
map[string]any{
"recordFormat": "fmp4",
}, nil)
time.Sleep(500 * time.Millisecond)
var out map[string]any
httpRequest(t, hc, http.MethodGet, "http://localhost:9997/v3/config/pathdefaults/get", nil, &out)
require.Equal(t, "fmp4", out["recordFormat"])
}
================================================
FILE: internal/api/api_config_paths.go
================================================
package api //nolint:revive
import (
"errors"
"fmt"
"net/http"
"github.com/bluenviron/mediamtx/internal/conf"
"github.com/bluenviron/mediamtx/internal/conf/jsonwrapper"
"github.com/bluenviron/mediamtx/internal/defs"
"github.com/gin-gonic/gin"
)
func (a *API) onConfigPathsList(ctx *gin.Context) {
a.mutex.RLock()
c := a.Conf
a.mutex.RUnlock()
data := &defs.APIPathConfList{
Items: make([]conf.Path, len(c.Paths)),
}
for i, key := range sortedKeys(c.Paths) {
data.Items[i] = *c.Paths[key]
}
data.ItemCount = len(data.Items)
pageCount, err := paginate(&data.Items, ctx.Query("itemsPerPage"), ctx.Query("page"))
if err != nil {
a.writeError(ctx, http.StatusBadRequest, err)
return
}
data.PageCount = pageCount
ctx.JSON(http.StatusOK, data)
}
func (a *API) onConfigPathsGet(ctx *gin.Context) {
confName, ok := paramName(ctx)
if !ok {
a.writeError(ctx, http.StatusBadRequest, fmt.Errorf("invalid name"))
return
}
a.mutex.RLock()
c := a.Conf
a.mutex.RUnlock()
p, ok := c.Paths[confName]
if !ok {
a.writeError(ctx, http.StatusNotFound, fmt.Errorf("path configuration not found"))
return
}
ctx.JSON(http.StatusOK, p)
}
func (a *API) onConfigPathsAdd(ctx *gin.Context) { //nolint:dupl
confName, ok := paramName(ctx)
if !ok {
a.writeError(ctx, http.StatusBadRequest, fmt.Errorf("invalid name"))
return
}
var p conf.OptionalPath
err := jsonwrapper.Decode(ctx.Request.Body, &p)
if err != nil {
a.writeError(ctx, http.StatusBadRequest, err)
return
}
a.mutex.Lock()
defer a.mutex.Unlock()
newConf := a.Conf.Clone()
err = newConf.AddPath(confName, &p)
if err != nil {
a.writeError(ctx, http.StatusBadRequest, err)
return
}
err = newConf.Validate(nil)
if err != nil {
a.writeError(ctx, http.StatusBadRequest, err)
return
}
a.Conf = newConf
a.Parent.APIConfigSet(newConf)
a.writeOK(ctx)
}
func (a *API) onConfigPathsPatch(ctx *gin.Context) { //nolint:dupl
confName, ok := paramName(ctx)
if !ok {
a.writeError(ctx, http.StatusBadRequest, fmt.Errorf("invalid name"))
return
}
var p conf.OptionalPath
err := jsonwrapper.Decode(ctx.Request.Body, &p)
if err != nil {
a.writeError(ctx, http.StatusBadRequest, err)
return
}
a.mutex.Lock()
defer a.mutex.Unlock()
newConf := a.Conf.Clone()
err = newConf.PatchPath(confName, &p)
if err != nil {
if errors.Is(err, conf.ErrPathNotFound) {
a.writeError(ctx, http.StatusNotFound, err)
} else {
a.writeError(ctx, http.StatusBadRequest, err)
}
return
}
err = newConf.Validate(nil)
if err != nil {
a.writeError(ctx, http.StatusBadRequest, err)
return
}
a.Conf = newConf
a.Parent.APIConfigSet(newConf)
a.writeOK(ctx)
}
func (a *API) onConfigPathsReplace(ctx *gin.Context) { //nolint:dupl
confName, ok := paramName(ctx)
if !ok {
a.writeError(ctx, http.StatusBadRequest, fmt.Errorf("invalid name"))
return
}
var p conf.OptionalPath
err := jsonwrapper.Decode(ctx.Request.Body, &p)
if err != nil {
a.writeError(ctx, http.StatusBadRequest, err)
return
}
a.mutex.Lock()
defer a.mutex.Unlock()
newConf := a.Conf.Clone()
err = newConf.ReplacePath(confName, &p)
if err != nil {
if errors.Is(err, conf.ErrPathNotFound) {
a.writeError(ctx, http.StatusNotFound, err)
} else {
a.writeError(ctx, http.StatusBadRequest, err)
}
return
}
err = newConf.Validate(nil)
if err != nil {
a.writeError(ctx, http.StatusBadRequest, err)
return
}
a.Conf = newConf
a.Parent.APIConfigSet(newConf)
a.writeOK(ctx)
}
func (a *API) onConfigPathsDelete(ctx *gin.Context) {
confName, ok := paramName(ctx)
if !ok {
a.writeError(ctx, http.StatusBadRequest, fmt.Errorf("invalid name"))
return
}
a.mutex.Lock()
defer a.mutex.Unlock()
newConf := a.Conf.Clone()
err := newConf.RemovePath(confName)
if err != nil {
if errors.Is(err, conf.ErrPathNotFound) {
a.writeError(ctx, http.StatusNotFound, err)
} else {
a.writeError(ctx, http.StatusBadRequest, err)
}
return
}
err = newConf.Validate(nil)
if err != nil {
a.writeError(ctx, http.StatusBadRequest, err)
return
}
a.Conf = newConf
a.Parent.APIConfigSet(newConf)
a.writeOK(ctx)
}
================================================
FILE: internal/api/api_config_paths_test.go
================================================
package api //nolint:revive
import (
"bytes"
"encoding/json"
"net/http"
"testing"
"time"
"github.com/bluenviron/mediamtx/internal/conf"
"github.com/bluenviron/mediamtx/internal/test"
"github.com/stretchr/testify/require"
)
func TestConfigPathsList(t *testing.T) {
cnf := tempConf(t, "api: yes\n"+
"paths:\n"+
" path1:\n"+
" readUser: myuser1\n"+
" readPass: mypass1\n"+
" path2:\n"+
" readUser: myuser2\n"+
" readPass: mypass2\n")
api := API{
Address: "localhost:9997",
ReadTimeout: conf.Duration(10 * time.Second),
WriteTimeout: conf.Duration(10 * time.Second),
Conf: cnf,
AuthManager: test.NilAuthManager,
Parent: &testParent{},
}
err := api.Initialize()
require.NoError(t, err)
defer api.Close()
type pathConfig map[string]any
type listRes struct {
ItemCount int `json:"itemCount"`
PageCount int `json:"pageCount"`
Items []pathConfig `json:"items"`
}
tr := &http.Transport{}
defer tr.CloseIdleConnections()
hc := &http.Client{Transport: tr}
var out listRes
httpRequest(t, hc, http.MethodGet, "http://localhost:9997/v3/config/paths/list", nil, &out)
require.Equal(t, 2, out.ItemCount)
require.Equal(t, 1, out.PageCount)
require.Equal(t, "path1", out.Items[0]["name"])
require.Equal(t, "myuser1", out.Items[0]["readUser"])
require.Equal(t, "mypass1", out.Items[0]["readPass"])
require.Equal(t, "path2", out.Items[1]["name"])
require.Equal(t, "myuser2", out.Items[1]["readUser"])
require.Equal(t, "mypass2", out.Items[1]["readPass"])
}
func TestConfigPathsGet(t *testing.T) {
cnf := tempConf(t, "api: yes\n"+
"paths:\n"+
" my/path:\n"+
" readUser: myuser\n"+
" readPass: mypass\n")
api := API{
Address: "localhost:9997",
ReadTimeout: conf.Duration(10 * time.Second),
WriteTimeout: conf.Duration(10 * time.Second),
Conf: cnf,
AuthManager: test.NilAuthManager,
Parent: &testParent{},
}
err := api.Initialize()
require.NoError(t, err)
defer api.Close()
tr := &http.Transport{}
defer tr.CloseIdleConnections()
hc := &http.Client{Transport: tr}
var out map[string]any
httpRequest(t, hc, http.MethodGet, "http://localhost:9997/v3/config/paths/get/my/path", nil, &out)
require.Equal(t, "my/path", out["name"])
require.Equal(t, "myuser", out["readUser"])
}
func TestConfigPathsAdd(t *testing.T) {
cnf := tempConf(t, "api: yes\n")
api := API{
Address: "localhost:9997",
ReadTimeout: conf.Duration(10 * time.Second),
WriteTimeout: conf.Duration(10 * time.Second),
Conf: cnf,
AuthManager: test.NilAuthManager,
Parent: &testParent{},
}
err := api.Initialize()
require.NoError(t, err)
defer api.Close()
tr := &http.Transport{}
defer tr.CloseIdleConnections()
hc := &http.Client{Transport: tr}
httpRequest(t, hc, http.MethodPost, "http://localhost:9997/v3/config/paths/add/my/path",
map[string]any{
"source": "rtsp://127.0.0.1:9999/mypath",
"sourceOnDemand": true,
"disablePublisherOverride": true, // test setting a deprecated parameter
"rpiCameraVFlip": true,
}, nil)
var out map[string]any
httpRequest(t, hc, http.MethodGet, "http://localhost:9997/v3/config/paths/get/my/path", nil, &out)
require.Equal(t, "rtsp://127.0.0.1:9999/mypath", out["source"])
require.Equal(t, true, out["sourceOnDemand"])
require.Equal(t, true, out["disablePublisherOverride"])
require.Equal(t, true, out["rpiCameraVFlip"])
}
func TestConfigPathsAddUnknownField(t *testing.T) { //nolint:dupl
cnf := tempConf(t, "api: yes\n")
api := API{
Address: "localhost:9997",
ReadTimeout: conf.Duration(10 * time.Second),
WriteTimeout: conf.Duration(10 * time.Second),
Conf: cnf,
AuthManager: test.NilAuthManager,
Parent: &testParent{},
}
err := api.Initialize()
require.NoError(t, err)
defer api.Close()
b := map[string]any{
"test": "asd",
}
byts, err := json.Marshal(b)
require.NoError(t, err)
tr := &http.Transport{}
defer tr.CloseIdleConnections()
hc := &http.Client{Transport: tr}
req, err := http.NewRequest(http.MethodPost,
"http://localhost:9997/v3/config/paths/add/my/path", bytes.NewReader(byts))
require.NoError(t, err)
res, err := hc.Do(req)
require.NoError(t, err)
defer res.Body.Close()
require.Equal(t, http.StatusBadRequest, res.StatusCode)
checkError(t, res.Body, "json: unknown field \"test\"")
}
func TestConfigPathsPatch(t *testing.T) { //nolint:dupl
cnf := tempConf(t, "api: yes\n")
api := API{
Address: "localhost:9997",
ReadTimeout: conf.Duration(10 * time.Second),
WriteTimeout: conf.Duration(10 * time.Second),
Conf: cnf,
AuthManager: test.NilAuthManager,
Parent: &testParent{},
}
err := api.Initialize()
require.NoError(t, err)
defer api.Close()
tr := &http.Transport{}
defer tr.CloseIdleConnections()
hc := &http.Client{Transport: tr}
httpRequest(t, hc, http.MethodPost, "http://localhost:9997/v3/config/paths/add/my/path",
map[string]any{
"source": "rtsp://127.0.0.1:9999/mypath",
"sourceOnDemand": true,
"disablePublisherOverride": true, // test setting a deprecated parameter
"rpiCameraVFlip": true,
}, nil)
httpRequest(t, hc, http.MethodPatch, "http://localhost:9997/v3/config/paths/patch/my/path",
map[string]any{
"source": "rtsp://127.0.0.1:9998/mypath",
"sourceOnDemand": true,
}, nil)
var out map[string]any
httpRequest(t, hc, http.MethodGet, "http://localhost:9997/v3/config/paths/get/my/path", nil, &out)
require.Equal(t, "rtsp://127.0.0.1:9998/mypath", out["source"])
require.Equal(t, true, out["sourceOnDemand"])
require.Equal(t, true, out["disablePublisherOverride"])
require.Equal(t, true, out["rpiCameraVFlip"])
}
func TestConfigPathsReplace(t *testing.T) { //nolint:dupl
cnf := tempConf(t, "api: yes\n")
api := API{
Address: "localhost:9997",
ReadTimeout: conf.Duration(10 * time.Second),
WriteTimeout: conf.Duration(10 * time.Second),
Conf: cnf,
AuthManager: test.NilAuthManager,
Parent: &testParent{},
}
err := api.Initialize()
require.NoError(t, err)
defer api.Close()
tr := &http.Transport{}
defer tr.CloseIdleConnections()
hc := &http.Client{Transport: tr}
httpRequest(t, hc, http.MethodPost, "http://localhost:9997/v3/config/paths/add/my/path",
map[string]any{
"source": "rtsp://127.0.0.1:9999/mypath",
"sourceOnDemand": true,
"disablePublisherOverride": true, // test setting a deprecated parameter
"rpiCameraVFlip": true,
}, nil)
httpRequest(t, hc, http.MethodPost, "http://localhost:9997/v3/config/paths/replace/my/path",
map[string]any{
"source": "rtsp://127.0.0.1:9998/mypath",
"sourceOnDemand": true,
}, nil)
var out map[string]any
httpRequest(t, hc, http.MethodGet, "http://localhost:9997/v3/config/paths/get/my/path", nil, &out)
require.Equal(t, "rtsp://127.0.0.1:9998/mypath", out["source"])
require.Equal(t, true, out["sourceOnDemand"])
require.Equal(t, nil, out["disablePublisherOverride"])
require.Equal(t, false, out["rpiCameraVFlip"])
}
func TestConfigPathsReplaceNonExisting(t *testing.T) { //nolint:dupl
cnf := tempConf(t, "api: yes\n")
api := API{
Address: "localhost:9997",
ReadTimeout: conf.Duration(10 * time.Second),
WriteTimeout: conf.Duration(10 * time.Second),
Conf: cnf,
AuthManager: test.NilAuthManager,
Parent: &testParent{},
}
err := api.Initialize()
require.NoError(t, err)
defer api.Close()
tr := &http.Transport{}
defer tr.CloseIdleConnections()
hc := &http.Client{Transport: tr}
httpRequest(t, hc, http.MethodPost, "http://localhost:9997/v3/config/paths/replace/my/path",
map[string]any{
"source": "rtsp://127.0.0.1:9998/mypath",
"sourceOnDemand": true,
}, nil)
var out map[string]any
httpRequest(t, hc, http.MethodGet, "http://localhost:9997/v3/config/paths/get/my/path", nil, &out)
require.Equal(t, "rtsp://127.0.0.1:9998/mypath", out["source"])
require.Equal(t, true, out["sourceOnDemand"])
require.Equal(t, nil, out["disablePublisherOverride"])
require.Equal(t, false, out["rpiCameraVFlip"])
}
func TestConfigPathsDelete(t *testing.T) {
cnf := tempConf(t, "api: yes\n")
api := API{
Address: "localhost:9997",
ReadTimeout: conf.Duration(10 * time.Second),
WriteTimeout: conf.Duration(10 * time.Second),
Conf: cnf,
AuthManager: test.NilAuthManager,
Parent: &testParent{},
}
err := api.Initialize()
require.NoError(t, err)
defer api.Close()
tr := &http.Transport{}
defer tr.CloseIdleConnections()
hc := &http.Client{Transport: tr}
httpRequest(t, hc, http.MethodPost, "http://localhost:9997/v3/config/paths/add/my/path",
map[string]any{
"source": "rtsp://127.0.0.1:9999/mypath",
"sourceOnDemand": true,
}, nil)
httpRequest(t, hc, http.MethodDelete, "http://localhost:9997/v3/config/paths/delete/my/path", nil, nil)
req, err := http.NewRequest(http.MethodGet, "http://localhost:9997/v3/config/paths/get/my/path", nil)
require.NoError(t, err)
res, err := hc.Do(req)
require.NoError(t, err)
defer res.Body.Close()
require.Equal(t, http.StatusNotFound, res.StatusCode)
checkError(t, res.Body, "path configuration not found")
}
================================================
FILE: internal/api/api_hls.go
================================================
//nolint:dupl
package api //nolint:revive
import (
"errors"
"fmt"
"net/http"
"github.com/bluenviron/mediamtx/internal/servers/hls"
"github.com/gin-gonic/gin"
)
func (a *API) onHLSMuxersList(ctx *gin.Context) {
data, err := a.HLSServer.APIMuxersList()
if err != nil {
a.writeError(ctx, http.StatusInternalServerError, err)
return
}
data.ItemCount = len(data.Items)
pageCount, err := paginate(&data.Items, ctx.Query("itemsPerPage"), ctx.Query("page"))
if err != nil {
a.writeError(ctx, http.StatusBadRequest, err)
return
}
data.PageCount = pageCount
ctx.JSON(http.StatusOK, data)
}
func (a *API) onHLSMuxersGet(ctx *gin.Context) {
pathName, ok := paramName(ctx)
if !ok {
a.writeError(ctx, http.StatusBadRequest, fmt.Errorf("invalid name"))
return
}
data, err := a.HLSServer.APIMuxersGet(pathName)
if err != nil {
if errors.Is(err, hls.ErrMuxerNotFound) {
a.writeError(ctx, http.StatusNotFound, err)
} else {
a.writeError(ctx, http.StatusInternalServerError, err)
}
return
}
ctx.JSON(http.StatusOK, data)
}
================================================
FILE: internal/api/api_hls_test.go
================================================
package api //nolint:revive
import (
"net/http"
"testing"
"time"
"github.com/bluenviron/mediamtx/internal/conf"
"github.com/bluenviron/mediamtx/internal/defs"
"github.com/bluenviron/mediamtx/internal/servers/hls"
"github.com/bluenviron/mediamtx/internal/test"
"github.com/stretchr/testify/require"
)
type testHLSServer struct {
muxers map[string]*defs.APIHLSMuxer
}
func (s *testHLSServer) APIMuxersList() (*defs.APIHLSMuxerList, error) {
items := make([]defs.APIHLSMuxer, 0, len(s.muxers))
for _, muxer := range s.muxers {
items = append(items, *muxer)
}
return &defs.APIHLSMuxerList{Items: items}, nil
}
func (s *testHLSServer) APIMuxersGet(name string) (*defs.APIHLSMuxer, error) {
muxer, ok := s.muxers[name]
if !ok {
return nil, hls.ErrMuxerNotFound
}
return muxer, nil
}
func TestHLSMuxersList(t *testing.T) {
now := time.Now()
hlsServer := &testHLSServer{
muxers: map[string]*defs.APIHLSMuxer{
"test1": {
Path: "test1",
Created: now,
LastRequest: now.Add(5 * time.Second),
OutboundBytes: 1234,
OutboundFramesDiscarded: 10,
BytesSent: 1234,
},
"test2": {
Path: "test2",
Created: now.Add(time.Minute),
LastRequest: now.Add(time.Minute + 10*time.Second),
OutboundBytes: 5678,
OutboundFramesDiscarded: 20,
BytesSent: 5678,
},
},
}
api := API{
Address: "localhost:9997",
ReadTimeout: conf.Duration(10 * time.Second),
WriteTimeout: conf.Duration(10 * time.Second),
AuthManager: test.NilAuthManager,
HLSServer: hlsServer,
Parent: &testParent{},
}
err := api.Initialize()
require.NoError(t, err)
defer api.Close()
tr := &http.Transport{}
defer tr.CloseIdleConnections()
hc := &http.Client{Transport: tr}
var out defs.APIHLSMuxerList
httpRequest(t, hc, http.MethodGet, "http://localhost:9997/v3/hlsmuxers/list", nil, &out)
require.Equal(t, 2, out.ItemCount)
require.Equal(t, 1, out.PageCount)
require.Len(t, out.Items, 2)
}
func TestHLSMuxersGet(t *testing.T) {
now := time.Now()
hlsServer := &testHLSServer{
muxers: map[string]*defs.APIHLSMuxer{
"mypath": {
Path: "mypath",
Created: now,
LastRequest: now.Add(5 * time.Second),
OutboundBytes: 9999,
OutboundFramesDiscarded: 12,
BytesSent: 9999,
},
},
}
api := API{
Address: "localhost:9997",
ReadTimeout: conf.Duration(10 * time.Second),
WriteTimeout: conf.Duration(10 * time.Second),
AuthManager: test.NilAuthManager,
HLSServer: hlsServer,
Parent: &testParent{},
}
err := api.Initialize()
require.NoError(t, err)
defer api.Close()
tr := &http.Transport{}
defer tr.CloseIdleConnections()
hc := &http.Client{Transport: tr}
var out defs.APIHLSMuxer
httpRequest(t, hc, http.MethodGet, "http://localhost:9997/v3/hlsmuxers/get/mypath", nil, &out)
require.Equal(t, "mypath", out.Path)
require.Equal(t, uint64(9999), out.OutboundBytes)
require.Equal(t, uint64(12), out.OutboundFramesDiscarded)
require.Equal(t, uint64(9999), out.BytesSent)
}
================================================
FILE: internal/api/api_paths.go
================================================
//nolint:dupl
package api //nolint:revive
import (
"errors"
"fmt"
"net/http"
"github.com/bluenviron/mediamtx/internal/conf"
"github.com/gin-gonic/gin"
)
func (a *API) onPathsList(ctx *gin.Context) {
data, err := a.PathManager.APIPathsList()
if err != nil {
a.writeError(ctx, http.StatusInternalServerError, err)
return
}
data.ItemCount = len(data.Items)
pageCount, err := paginate(&data.Items, ctx.Query("itemsPerPage"), ctx.Query("page"))
if err != nil {
a.writeError(ctx, http.StatusBadRequest, err)
return
}
data.PageCount = pageCount
ctx.JSON(http.StatusOK, data)
}
func (a *API) onPathsGet(ctx *gin.Context) {
pathName, ok := paramName(ctx)
if !ok {
a.writeError(ctx, http.StatusBadRequest, fmt.Errorf("invalid name"))
return
}
data, err := a.PathManager.APIPathsGet(pathName)
if err != nil {
if errors.Is(err, conf.ErrPathNotFound) {
a.writeError(ctx, http.StatusNotFound, err)
} else {
a.writeError(ctx, http.StatusInternalServerError, err)
}
return
}
ctx.JSON(http.StatusOK, data)
}
================================================
FILE: internal/api/api_paths_test.go
================================================
package api //nolint:revive
import (
"net/http"
"testing"
"time"
"github.com/bluenviron/mediamtx/internal/conf"
"github.com/bluenviron/mediamtx/internal/defs"
"github.com/bluenviron/mediamtx/internal/test"
"github.com/stretchr/testify/require"
)
type testPathManager struct {
paths map[string]*defs.APIPath
}
func (m *testPathManager) APIPathsList() (*defs.APIPathList, error) {
items := make([]defs.APIPath, 0, len(m.paths))
for _, path := range m.paths {
items = append(items, *path)
}
return &defs.APIPathList{Items: items}, nil
}
func (m *testPathManager) APIPathsGet(name string) (*defs.APIPath, error) {
path, ok := m.paths[name]
if !ok {
return nil, conf.ErrPathNotFound
}
return path, nil
}
func TestPathsList(t *testing.T) {
now := time.Now()
pathManager := &testPathManager{
paths: map[string]*defs.APIPath{
"test1": {
Name: "test1",
ConfName: "test1",
Source: &defs.APIPathSource{Type: defs.APIPathSourceTypeRTSPSession, ID: "pub1"},
Ready: true,
ReadyTime: &now,
Tracks: []defs.APIPathTrackCodec{defs.APIPathTrackCodecH264, defs.APIPathTrackCodecOpus},
InboundBytes: 1000,
OutboundBytes: 2000,
InboundFramesInError: 3,
BytesReceived: 1000,
BytesSent: 2000,
Readers: []defs.APIPathReader{
{Type: defs.APIPathReaderTypeRTSPSession, ID: "reader1"},
},
},
"test2": {
Name: "test2",
ConfName: "test2",
Ready: false,
Tracks: []defs.APIPathTrackCodec{},
InboundBytes: 500,
OutboundBytes: 100,
InboundFramesInError: 1,
BytesReceived: 500,
BytesSent: 100,
Readers: []defs.APIPathReader{},
},
},
}
api := API{
Address: "localhost:9997",
ReadTimeout: conf.Duration(10 * time.Second),
WriteTimeout: conf.Duration(10 * time.Second),
AuthManager: test.NilAuthManager,
PathManager: pathManager,
Parent: &testParent{},
}
err := api.Initialize()
require.NoError(t, err)
defer api.Close()
tr := &http.Transport{}
defer tr.CloseIdleConnections()
hc := &http.Client{Transport: tr}
var out defs.APIPathList
httpRequest(t, hc, http.MethodGet, "http://localhost:9997/v3/paths/list", nil, &out)
require.Equal(t, 2, out.ItemCount)
require.Equal(t, 1, out.PageCount)
require.Len(t, out.Items, 2)
}
func TestPathsGet(t *testing.T) {
now := time.Now()
pathManager := &testPathManager{
paths: map[string]*defs.APIPath{
"mystream": {
Name: "mystream",
ConfName: "mystream",
Source: &defs.APIPathSource{Type: defs.APIPathSourceTypeRTSPSession, ID: "session123"},
Ready: true,
ReadyTime: &now,
Tracks: []defs.APIPathTrackCodec{defs.APIPathTrackCodecH264, defs.APIPathTrackCodecOpus},
InboundBytes: 123456,
OutboundBytes: 789012,
InboundFramesInError: 12,
BytesReceived: 123456,
BytesSent: 789012,
Readers: []defs.APIPathReader{
{Type: defs.APIPathReaderTypeHLSMuxer, ID: "muxer1"},
{Type: defs.APIPathReaderTypeWebRTCSession, ID: "session456"},
},
},
},
}
api := API{
Address: "localhost:9997",
ReadTimeout: conf.Duration(10 * time.Second),
WriteTimeout: conf.Duration(10 * time.Second),
AuthManager: test.NilAuthManager,
PathManager: pathManager,
Parent: &testParent{},
}
err := api.Initialize()
require.NoError(t, err)
defer api.Close()
tr := &http.Transport{}
defer tr.CloseIdleConnections()
hc := &http.Client{Transport: tr}
var out defs.APIPath
httpRequest(t, hc, http.MethodGet, "http://localhost:9997/v3/paths/get/mystream", nil, &out)
require.Equal(t, "mystream", out.Name)
require.Equal(t, "mystream", out.ConfName)
require.True(t, out.Ready)
require.NotNil(t, out.Source)
require.Equal(t, defs.APIPathSourceTypeRTSPSession, out.Source.Type)
require.Len(t, out.Tracks, 2)
require.Len(t, out.Readers, 2)
require.Equal(t, uint64(123456), out.InboundBytes)
require.Equal(t, uint64(789012), out.OutboundBytes)
require.Equal(t, uint64(12), out.InboundFramesInError)
require.Equal(t, uint64(123456), out.BytesReceived)
require.Equal(t, uint64(789012), out.BytesSent)
}
================================================
FILE: internal/api/api_recordings.go
================================================
package api //nolint:revive
import (
"fmt"
"net/http"
"os"
"strings"
"time"
"github.com/bluenviron/mediamtx/internal/conf"
"github.com/bluenviron/mediamtx/internal/defs"
"github.com/bluenviron/mediamtx/internal/recordstore"
"github.com/gin-gonic/gin"
)
func (a *API) onRecordingsList(ctx *gin.Context) {
a.mutex.RLock()
c := a.Conf
a.mutex.RUnlock()
pathNames := recordstore.FindAllPathsWithSegments(c.Paths)
data := defs.APIRecordingList{}
data.ItemCount = len(pathNames)
pageCount, err := paginate(&pathNames, ctx.Query("itemsPerPage"), ctx.Query("page"))
if err != nil {
a.writeError(ctx, http.StatusBadRequest, err)
return
}
data.PageCount = pageCount
data.Items = make([]defs.APIRecording, len(pathNames))
for i, pathName := range pathNames {
pathConf, _, _ := conf.FindPathConf(c.Paths, pathName)
data.Items[i] = *recordingsOfPath(pathConf, pathName)
}
ctx.JSON(http.StatusOK, data)
}
func (a *API) onRecordingsGet(ctx *gin.Context) {
pathName, ok := paramName(ctx)
if !ok {
a.writeError(ctx, http.StatusBadRequest, fmt.Errorf("invalid name"))
return
}
a.mutex.RLock()
c := a.Conf
a.mutex.RUnlock()
pathConf, _, err := conf.FindPathConf(c.Paths, pathName)
if err != nil {
a.writeError(ctx, http.StatusBadRequest, err)
return
}
ctx.JSON(http.StatusOK, recordingsOfPath(pathConf, pathName))
}
func (a *API) onRecordingDeleteSegment(ctx *gin.Context) {
pathName := ctx.Query("path")
start, err := time.Parse(time.RFC3339, ctx.Query("start"))
if err != nil {
a.writeError(ctx, http.StatusBadRequest, fmt.Errorf("invalid 'start' parameter: %w", err))
return
}
a.mutex.RLock()
c := a.Conf
a.mutex.RUnlock()
pathConf, _, err := conf.FindPathConf(c.Paths, pathName)
if err != nil {
a.writeError(ctx, http.StatusBadRequest, err)
return
}
pathFormat := recordstore.PathAddExtension(
strings.ReplaceAll(pathConf.RecordPath, "%path", pathName),
pathConf.RecordFormat,
)
segmentPath := recordstore.Path{
Start: start,
}.Encode(pathFormat)
err = os.Remove(segmentPath)
if err != nil {
a.writeError(ctx, http.StatusBadRequest, err)
return
}
a.writeOK(ctx)
}
================================================
FILE: internal/api/api_recordings_test.go
================================================
package api //nolint:revive
import (
"net/http"
"net/url"
"os"
"path/filepath"
"testing"
"time"
"github.com/bluenviron/mediamtx/internal/conf"
"github.com/bluenviron/mediamtx/internal/test"
"github.com/stretchr/testify/require"
)
func TestRecordingsList(t *testing.T) {
dir, err := os.MkdirTemp("", "mediamtx-playback")
require.NoError(t, err)
defer os.RemoveAll(dir)
cnf := tempConf(t, "pathDefaults:\n"+
" recordPath: "+filepath.Join(dir, "%path/%Y-%m-%d_%H-%M-%S-%f")+"\n"+
"paths:\n"+
" mypath1:\n"+
" all_others:\n")
api := API{
Address: "localhost:9997",
ReadTimeout: conf.Duration(10 * time.Second),
WriteTimeout: conf.Duration(10 * time.Second),
Conf: cnf,
AuthManager: test.NilAuthManager,
Parent: &testParent{},
}
err = api.Initialize()
require.NoError(t, err)
defer api.Close()
err = os.Mkdir(filepath.Join(dir, "mypath1"), 0o755)
require.NoError(t, err)
err = os.Mkdir(filepath.Join(dir, "mypath2"), 0o755)
require.NoError(t, err)
err = os.WriteFile(filepath.Join(dir, "mypath1", "2008-11-07_11-22-00-500000.mp4"), []byte(""), 0o644)
require.NoError(t, err)
err = os.WriteFile(filepath.Join(dir, "mypath1", "2009-11-07_11-22-00-900000.mp4"), []byte(""), 0o644)
require.NoError(t, err)
err = os.WriteFile(filepath.Join(dir, "mypath2", "2009-11-07_11-22-00-900000.mp4"), []byte(""), 0o644)
require.NoError(t, err)
tr := &http.Transport{}
defer tr.CloseIdleConnections()
hc := &http.Client{Transport: tr}
var out any
httpRequest(t, hc, http.MethodGet, "http://localhost:9997/v3/recordings/list", nil, &out)
require.Equal(t, map[string]any{
"itemCount": float64(2),
"pageCount": float64(1),
"items": []any{
map[string]any{
"name": "mypath1",
"segments": []any{
map[string]any{
"start": time.Date(2008, 11, 7, 11, 22, 0, 500000000, time.Local).Format(time.RFC3339Nano),
},
map[string]any{
"start": time.Date(2009, 11, 7, 11, 22, 0, 900000000, time.Local).Format(time.RFC3339Nano),
},
},
},
map[string]any{
"name": "mypath2",
"segments": []any{
map[string]any{
"start": time.Date(2009, 11, 7, 11, 22, 0, 900000000, time.Local).Format(time.RFC3339Nano),
},
},
},
},
}, out)
}
func TestRecordingsGet(t *testing.T) {
dir, err := os.MkdirTemp("", "mediamtx-playback")
require.NoError(t, err)
defer os.RemoveAll(dir)
cnf := tempConf(t, "pathDefaults:\n"+
" recordPath: "+filepath.Join(dir, "%path/%Y-%m-%d_%H-%M-%S-%f")+"\n"+
"paths:\n"+
" all_others:\n")
api := API{
Address: "localhost:9997",
ReadTimeout: conf.Duration(10 * time.Second),
WriteTimeout: conf.Duration(10 * time.Second),
Conf: cnf,
AuthManager: test.NilAuthManager,
Parent: &testParent{},
}
err = api.Initialize()
require.NoError(t, err)
defer api.Close()
err = os.Mkdir(filepath.Join(dir, "mypath1"), 0o755)
require.NoError(t, err)
err = os.WriteFile(filepath.Join(dir, "mypath1", "2008-11-07_11-22-00-000000.mp4"), []byte(""), 0o644)
require.NoError(t, err)
err = os.WriteFile(filepath.Join(dir, "mypath1", "2009-11-07_11-22-00-900000.mp4"), []byte(""), 0o644)
require.NoError(t, err)
tr := &http.Transport{}
defer tr.CloseIdleConnections()
hc := &http.Client{Transport: tr}
var out any
httpRequest(t, hc, http.MethodGet, "http://localhost:9997/v3/recordings/get/mypath1", nil, &out)
require.Equal(t, map[string]any{
"name": "mypath1",
"segments": []any{
map[string]any{
"start": time.Date(2008, 11, 7, 11, 22, 0, 0, time.Local).Format(time.RFC3339Nano),
},
map[string]any{
"start": time.Date(2009, 11, 7, 11, 22, 0, 900000000, time.Local).Format(time.RFC3339Nano),
},
},
}, out)
}
func TestRecordingsDeleteSegment(t *testing.T) {
dir, err := os.MkdirTemp("", "mediamtx-playback")
require.NoError(t, err)
defer os.RemoveAll(dir)
cnf := tempConf(t, "pathDefaults:\n"+
" recordPath: "+filepath.Join(dir, "%path/%Y-%m-%d_%H-%M-%S-%f")+"\n"+
"paths:\n"+
" all_others:\n")
api := API{
Address: "localhost:9997",
ReadTimeout: conf.Duration(10 * time.Second),
WriteTimeout: conf.Duration(10 * time.Second),
Conf: cnf,
AuthManager: test.NilAuthManager,
Parent: &testParent{},
}
err = api.Initialize()
require.NoError(t, err)
defer api.Close()
err = os.Mkdir(filepath.Join(dir, "mypath1"), 0o755)
require.NoError(t, err)
err = os.WriteFile(filepath.Join(dir, "mypath1", "2008-11-07_11-22-00-900000.mp4"), []byte(""), 0o644)
require.NoError(t, err)
tr := &http.Transport{}
defer tr.CloseIdleConnections()
hc := &http.Client{Transport: tr}
u, err := url.Parse("http://localhost:9997/v3/recordings/deletesegment")
require.NoError(t, err)
v := url.Values{}
v.Set("path", "mypath1")
v.Set("start", time.Date(2008, 11, 7, 11, 22, 0, 900000000, time.Local).Format(time.RFC3339Nano))
u.RawQuery = v.Encode()
httpRequest(t, hc, http.MethodDelete, u.String(), nil, nil)
}
================================================
FILE: internal/api/api_rtmp.go
================================================
package api //nolint:revive
import (
"errors"
"net/http"
"github.com/bluenviron/mediamtx/internal/servers/rtmp"
"github.com/gin-gonic/gin"
"github.com/google/uuid"
)
func (a *API) onRTMPConnsList(ctx *gin.Context) {
data, err := a.RTMPServer.APIConnsList()
if err != nil {
a.writeError(ctx, http.StatusInternalServerError, err)
return
}
data.ItemCount = len(data.Items)
pageCount, err := paginate(&data.Items, ctx.Query("itemsPerPage"), ctx.Query("page"))
if err != nil {
a.writeError(ctx, http.StatusBadRequest, err)
return
}
data.PageCount = pageCount
ctx.JSON(http.StatusOK, data)
}
func (a *API) onRTMPConnsGet(ctx *gin.Context) {
uuid, err := uuid.Parse(ctx.Param("id"))
if err != nil {
a.writeError(ctx, http.StatusBadRequest, err)
return
}
data, err := a.RTMPServer.APIConnsGet(uuid)
if err != nil {
if errors.Is(err, rtmp.ErrConnNotFound) {
a.writeError(ctx, http.StatusNotFound, err)
} else {
a.writeError(ctx, http.StatusInternalServerError, err)
}
return
}
ctx.JSON(http.StatusOK, data)
}
func (a *API) onRTMPConnsKick(ctx *gin.Context) {
uuid, err := uuid.Parse(ctx.Param("id"))
if err != nil {
a.writeError(ctx, http.StatusBadRequest, err)
return
}
err = a.RTMPServer.APIConnsKick(uuid)
if err != nil {
if errors.Is(err, rtmp.ErrConnNotFound) {
a.writeError(ctx, http.StatusNotFound, err)
} else {
a.writeError(ctx, http.StatusInternalServerError, err)
}
return
}
a.writeOK(ctx)
}
func (a *API) onRTMPSConnsList(ctx *gin.Context) {
data, err := a.RTMPSServer.APIConnsList()
if err != nil {
a.writeError(ctx, http.StatusInternalServerError, err)
return
}
data.ItemCount = len(data.Items)
pageCount, err := paginate(&data.Items, ctx.Query("itemsPerPage"), ctx.Query("page"))
if err != nil {
a.writeError(ctx, http.StatusBadRequest, err)
return
}
data.PageCount = pageCount
ctx.JSON(http.StatusOK, data)
}
func (a *API) onRTMPSConnsGet(ctx *gin.Context) {
uuid, err := uuid.Parse(ctx.Param("id"))
if err != nil {
a.writeError(ctx, http.StatusBadRequest, err)
return
}
data, err := a.RTMPSServer.APIConnsGet(uuid)
if err != nil {
if errors.Is(err, rtmp.ErrConnNotFound) {
a.writeError(ctx, http.StatusNotFound, err)
} else {
a.writeError(ctx, http.StatusInternalServerError, err)
}
return
}
ctx.JSON(http.StatusOK, data)
}
func (a *API) onRTMPSConnsKick(ctx *gin.Context) {
uuid, err := uuid.Parse(ctx.Param("id"))
if err != nil {
a.writeError(ctx, http.StatusBadRequest, err)
return
}
err = a.RTMPSServer.APIConnsKick(uuid)
if err != nil {
if errors.Is(err, rtmp.ErrConnNotFound) {
a.writeError(ctx, http.StatusNotFound, err)
} else {
a.writeError(ctx, http.StatusInternalServerError, err)
}
return
}
a.writeOK(ctx)
}
================================================
FILE: internal/api/api_rtmp_test.go
================================================
package api //nolint:revive
import (
"fmt"
"net/http"
"testing"
"time"
"github.com/bluenviron/mediamtx/internal/conf"
"github.com/bluenviron/mediamtx/internal/defs"
"github.com/bluenviron/mediamtx/internal/servers/rtmp"
"github.com/bluenviron/mediamtx/internal/test"
"github.com/google/uuid"
"github.com/stretchr/testify/require"
)
type testRTMPServer struct {
conns map[uuid.UUID]*defs.APIRTMPConn
}
func (s *testRTMPServer) APIConnsList() (*defs.APIRTMPConnList, error) {
items := make([]defs.APIRTMPConn, 0, len(s.conns))
for _, conn := range s.conns {
items = append(items, *conn)
}
return &defs.APIRTMPConnList{Items: items}, nil
}
func (s *testRTMPServer) APIConnsGet(id uuid.UUID) (*defs.APIRTMPConn, error) {
conn, ok := s.conns[id]
if !ok {
return nil, rtmp.ErrConnNotFound
}
return conn, nil
}
func (s *testRTMPServer) APIConnsKick(id uuid.UUID) error {
_, ok := s.conns[id]
if !ok {
return rtmp.ErrConnNotFound
}
return nil
}
func TestRTMPConnsList(t *testing.T) {
for _, ca := range []struct {
name string
endpoint string
isSecure bool
}{
{
name: "rtmp",
endpoint: "rtmpconns",
isSecure: false,
},
{
name: "rtmps",
endpoint: "rtmpsconns",
isSecure: true,
},
} {
t.Run(ca.name, func(t *testing.T) {
id1 := uuid.New()
id2 := uuid.New()
now := time.Now()
rtmpServer := &testRTMPServer{
conns: map[uuid.UUID]*defs.APIRTMPConn{
id1: {
ID: id1,
Created: now,
RemoteAddr: "192.168.1.1:5000",
State: defs.APIRTMPConnStatePublish,
Path: "stream1",
Query: "token=abc",
InboundBytes: 1000,
OutboundBytes: 2000,
OutboundFramesDiscarded: 11,
BytesReceived: 1000,
BytesSent: 2000,
},
id2: {
ID: id2,
Created: now.Add(time.Minute),
RemoteAddr: "192.168.1.2:5001",
State: defs.APIRTMPConnStateRead,
Path: "stream2",
Query: "",
InboundBytes: 500,
OutboundBytes: 1500,
OutboundFramesDiscarded: 22,
BytesReceived: 500,
BytesSent: 1500,
},
},
}
api := API{
Address: "localhost:9997",
ReadTimeout: conf.Duration(10 * time.Second),
WriteTimeout: conf.Duration(10 * time.Second),
AuthManager: test.NilAuthManager,
Parent: &testParent{},
}
if ca.isSecure {
api.RTMPSServer = rtmpServer
} else {
api.RTMPServer = rtmpServer
}
err := api.Initialize()
require.NoError(t, err)
defer api.Close()
tr := &http.Transport{}
defer tr.CloseIdleConnections()
hc := &http.Client{Transport: tr}
var out defs.APIRTMPConnList
httpRequest(t, hc, http.MethodGet, fmt.Sprintf("http://localhost:9997/v3/%s/list", ca.endpoint), nil, &out)
require.Equal(t, 2, out.ItemCount)
require.Equal(t, 1, out.PageCount)
require.Len(t, out.Items, 2)
})
}
}
func TestRTMPConnsGet(t *testing.T) {
for _, ca := range []struct {
name string
endpoint string
path string
isSecure bool
}{
{
name: "rtmp",
endpoint: "rtmpconns",
path: "mystream",
isSecure: false,
},
{
name: "rtmps",
endpoint: "rtmpsconns",
path: "secure-stream",
isSecure: true,
},
} {
t.Run(ca.name, func(t *testing.T) {
id := uuid.New()
now := time.Now()
rtmpServer := &testRTMPServer{
conns: map[uuid.UUID]*defs.APIRTMPConn{
id: {
ID: id,
Created: now,
RemoteAddr: "192.168.1.100:5000",
State: defs.APIRTMPConnStatePublish,
Path: ca.path,
Query: "key=value",
InboundBytes: 999999,
OutboundBytes: 888888,
OutboundFramesDiscarded: 33,
BytesReceived: 999999,
BytesSent: 888888,
},
},
}
api := API{
Address: "localhost:9997",
ReadTimeout: conf.Duration(10 * time.Second),
WriteTimeout: conf.Duration(10 * time.Second),
AuthManager: test.NilAuthManager,
Parent: &testParent{},
}
if ca.isSecure {
api.RTMPSServer = rtmpServer
} else {
api.RTMPServer = rtmpServer
}
err := api.Initialize()
require.NoError(t, err)
defer api.Close()
tr := &http.Transport{}
defer tr.CloseIdleConnections()
hc := &http.Client{Transport: tr}
var out defs.APIRTMPConn
httpRequest(t, hc, http.MethodGet, fmt.Sprintf("http://localhost:9997/v3/%s/get/%s", ca.endpoint, id), nil, &out)
require.Equal(t, id, out.ID)
require.Equal(t, "192.168.1.100:5000", out.RemoteAddr)
require.Equal(t, defs.APIRTMPConnStatePublish, out.State)
require.Equal(t, ca.path, out.Path)
require.Equal(t, uint64(999999), out.InboundBytes)
require.Equal(t, uint64(888888), out.OutboundBytes)
require.Equal(t, uint64(33), out.OutboundFramesDiscarded)
require.Equal(t, uint64(999999), out.BytesReceived)
})
}
}
func TestRTMPConnsKick(t *testing.T) {
for _, ca := range []struct {
name string
endpoint string
path string
isSecure bool
}{
{
name: "rtmp",
endpoint: "rtmpconns",
path: "mystream",
isSecure: false,
},
{
name: "rtmps",
endpoint: "rtmpsconns",
path: "secure-stream",
isSecure: true,
},
} {
t.Run(ca.name, func(t *testing.T) {
id := uuid.New()
now := time.Now()
rtmpServer := &testRTMPServer{
conns: map[uuid.UUID]*defs.APIRTMPConn{
id: {
ID: id,
Created: now,
RemoteAddr: "192.168.1.100:5000",
State: defs.APIRTMPConnStatePublish,
Path: ca.path,
Query: "",
BytesReceived: 1000,
BytesSent: 2000,
},
},
}
api := API{
Address: "localhost:9997",
ReadTimeout: conf.Duration(10 * time.Second),
WriteTimeout: conf.Duration(10 * time.Second),
AuthManager: test.NilAuthManager,
Parent: &testParent{},
}
if ca.isSecure {
api.RTMPSServer = rtmpServer
} else {
api.RTMPServer = rtmpServer
}
err := api.Initialize()
require.NoError(t, err)
defer api.Close()
tr := &http.Transport{}
defer tr.CloseIdleConnections()
hc := &http.Client{Transport: tr}
httpRequest(t, hc, http.MethodPost, fmt.Sprintf("http://localhost:9997/v3/%s/kick/%s", ca.endpoint, id), nil, nil)
})
}
}
================================================
FILE: internal/api/api_rtsp.go
================================================
package api //nolint:revive
import (
"errors"
"net/http"
"github.com/bluenviron/mediamtx/internal/servers/rtsp"
"github.com/gin-gonic/gin"
"github.com/google/uuid"
)
func (a *API) onRTSPConnsList(ctx *gin.Context) {
data, err := a.RTSPServer.APIConnsList()
if err != nil {
a.writeError(ctx, http.StatusInternalServerError, err)
return
}
data.ItemCount = len(data.Items)
pageCount, err := paginate(&data.Items, ctx.Query("itemsPerPage"), ctx.Query("page"))
if err != nil {
a.writeError(ctx, http.StatusBadRequest, err)
return
}
data.PageCount = pageCount
ctx.JSON(http.StatusOK, data)
}
func (a *API) onRTSPConnsGet(ctx *gin.Context) {
uuid, err := uuid.Parse(ctx.Param("id"))
if err != nil {
a.writeError(ctx, http.StatusBadRequest, err)
return
}
data, err := a.RTSPServer.APIConnsGet(uuid)
if err != nil {
if errors.Is(err, rtsp.ErrConnNotFound) {
a.writeError(ctx, http.StatusNotFound, err)
} else {
a.writeError(ctx, http.StatusInternalServerError, err)
}
return
}
ctx.JSON(http.StatusOK, data)
}
func (a *API) onRTSPSessionsList(ctx *gin.Context) {
data, err := a.RTSPServer.APISessionsList()
if err != nil {
a.writeError(ctx, http.StatusInternalServerError, err)
return
}
data.ItemCount = len(data.Items)
pageCount, err := paginate(&data.Items, ctx.Query("itemsPerPage"), ctx.Query("page"))
if err != nil {
a.writeError(ctx, http.StatusBadRequest, err)
return
}
data.PageCount = pageCount
ctx.JSON(http.StatusOK, data)
}
func (a *API) onRTSPSessionsGet(ctx *gin.Context) {
uuid, err := uuid.Parse(ctx.Param("id"))
if err != nil {
a.writeError(ctx, http.StatusBadRequest, err)
return
}
data, err := a.RTSPServer.APISessionsGet(uuid)
if err != nil {
if errors.Is(err, rtsp.ErrSessionNotFound) {
a.writeError(ctx, http.StatusNotFound, err)
} else {
a.writeError(ctx, http.StatusInternalServerError, err)
}
return
}
ctx.JSON(http.StatusOK, data)
}
func (a *API) onRTSPSessionsKick(ctx *gin.Context) {
uuid, err := uuid.Parse(ctx.Param("id"))
if err != nil {
a.writeError(ctx, http.StatusBadRequest, err)
return
}
err = a.RTSPServer.APISessionsKick(uuid)
if err != nil {
if errors.Is(err, rtsp.ErrSessionNotFound) {
a.writeError(ctx, http.StatusNotFound, err)
} else {
a.writeError(ctx, http.StatusInternalServerError, err)
}
return
}
a.writeOK(ctx)
}
func (a *API) onRTSPSConnsList(ctx *gin.Context) {
data, err := a.RTSPSServer.APIConnsList()
if err != nil {
a.writeError(ctx, http.StatusInternalServerError, err)
return
}
data.ItemCount = len(data.Items)
pageCount, err := paginate(&data.Items, ctx.Query("itemsPerPage"), ctx.Query("page"))
if err != nil {
a.writeError(ctx, http.StatusBadRequest, err)
return
}
data.PageCount = pageCount
ctx.JSON(http.StatusOK, data)
}
func (a *API) onRTSPSConnsGet(ctx *gin.Context) {
uuid, err := uuid.Parse(ctx.Param("id"))
if err != nil {
a.writeError(ctx, http.StatusBadRequest, err)
return
}
data, err := a.RTSPSServer.APIConnsGet(uuid)
if err != nil {
if errors.Is(err, rtsp.ErrConnNotFound) {
a.writeError(ctx, http.StatusNotFound, err)
} else {
a.writeError(ctx, http.StatusInternalServerError, err)
}
return
}
ctx.JSON(http.StatusOK, data)
}
func (a *API) onRTSPSSessionsList(ctx *gin.Context) {
data, err := a.RTSPSServer.APISessionsList()
if err != nil {
a.writeError(ctx, http.StatusInternalServerError, err)
return
}
data.ItemCount = len(data.Items)
pageCount, err := paginate(&data.Items, ctx.Query("itemsPerPage"), ctx.Query("page"))
if err != nil {
a.writeError(ctx, http.StatusBadRequest, err)
return
}
data.PageCount = pageCount
ctx.JSON(http.StatusOK, data)
}
func (a *API) onRTSPSSessionsGet(ctx *gin.Context) {
uuid, err := uuid.Parse(ctx.Param("id"))
if err != nil {
a.writeError(ctx, http.StatusBadRequest, err)
return
}
data, err := a.RTSPSServer.APISessionsGet(uuid)
if err != nil {
if errors.Is(err, rtsp.ErrSessionNotFound) {
a.writeError(ctx, http.StatusNotFound, err)
} else {
a.writeError(ctx, http.StatusInternalServerError, err)
}
return
}
ctx.JSON(http.StatusOK, data)
}
func (a *API) onRTSPSSessionsKick(ctx *gin.Context) {
uuid, err := uuid.Parse(ctx.Param("id"))
if err != nil {
a.writeError(ctx, http.StatusBadRequest, err)
return
}
err = a.RTSPSServer.APISessionsKick(uuid)
if err != nil {
if errors.Is(err, rtsp.ErrSessionNotFound) {
a.writeError(ctx, http.StatusNotFound, err)
} else {
a.writeError(ctx, http.StatusInternalServerError, err)
}
return
}
a.writeOK(ctx)
}
================================================
FILE: internal/api/api_rtsp_test.go
================================================
package api //nolint:revive
import (
"encoding/json"
"fmt"
"net/http"
"testing"
"time"
"github.com/bluenviron/mediamtx/internal/conf"
"github.com/bluenviron/mediamtx/internal/defs"
"github.com/bluenviron/mediamtx/internal/servers/rtsp"
"github.com/bluenviron/mediamtx/internal/test"
"github.com/google/uuid"
"github.com/stretchr/testify/require"
)
type testRTSPServer struct {
conns map[uuid.UUID]*defs.APIRTSPConn
sessions map[uuid.UUID]*defs.APIRTSPSession
}
func (s *testRTSPServer) APIConnsList() (*defs.APIRTSPConnsList, error) {
items := make([]defs.APIRTSPConn, 0, len(s.conns))
for _, conn := range s.conns {
items = append(items, *conn)
}
return &defs.APIRTSPConnsList{Items: items}, nil
}
func (s *testRTSPServer) APIConnsGet(id uuid.UUID) (*defs.APIRTSPConn, error) {
conn, ok := s.conns[id]
if !ok {
return nil, rtsp.ErrConnNotFound
}
return conn, nil
}
func (s *testRTSPServer) APISessionsList() (*defs.APIRTSPSessionList, error) {
items := make([]defs.APIRTSPSession, 0, len(s.sessions))
for _, session := range s.sessions {
items = append(items, *session)
}
return &defs.APIRTSPSessionList{Items: items}, nil
}
func (s *testRTSPServer) APISessionsGet(id uuid.UUID) (*defs.APIRTSPSession, error) {
session, ok := s.sessions[id]
if !ok {
return nil, rtsp.ErrSessionNotFound
}
return session, nil
}
func (s *testRTSPServer) APISessionsKick(id uuid.UUID) error {
_, ok := s.sessions[id]
if !ok {
return rtsp.ErrSessionNotFound
}
return nil
}
func TestRTSPConnsList(t *testing.T) {
for _, ca := range []struct {
name string
endpoint string
secure bool
}{
{
name: "rtsp",
endpoint: "rtspconns",
secure: false,
},
{
name: "rtsps",
endpoint: "rtspsconns",
secure: true,
},
} {
t.Run(ca.name, func(t *testing.T) {
id1 := uuid.New()
id2 := uuid.New()
sessionID := uuid.New()
now := time.Now()
rtspServer := &testRTSPServer{
conns: map[uuid.UUID]*defs.APIRTSPConn{
id1: {
ID: id1,
Created: now,
RemoteAddr: "192.168.1.1:5000",
InboundBytes: 1000,
OutboundBytes: 2000,
BytesReceived: 1000,
BytesSent: 2000,
Session: &sessionID,
Tunnel: "",
},
id2: {
ID: id2,
Created: now.Add(time.Minute),
RemoteAddr: "192.168.1.2:5001",
InboundBytes: 500,
OutboundBytes: 1500,
BytesReceived: 500,
BytesSent: 1500,
Session: nil,
Tunnel: "http",
},
},
}
api := API{
Address: "localhost:9997",
ReadTimeout: conf.Duration(10 * time.Second),
WriteTimeout: conf.Duration(10 * time.Second),
AuthManager: test.NilAuthManager,
Parent: &testParent{},
}
if ca.secure {
api.RTSPSServer = rtspServer
} else {
api.RTSPServer = rtspServer
}
err := api.Initialize()
require.NoError(t, err)
defer api.Close()
tr := &http.Transport{}
defer tr.CloseIdleConnections()
hc := &http.Client{Transport: tr}
req, err := http.NewRequest(http.MethodGet,
fmt.Sprintf("http://localhost:9997/v3/%s/list", ca.endpoint), nil)
require.NoError(t, err)
res, err := hc.Do(req)
require.NoError(t, err)
defer res.Body.Close()
require.Equal(t, http.StatusOK, res.StatusCode)
var out defs.APIRTSPConnsList
err = json.NewDecoder(res.Body).Decode(&out)
require.NoError(t, err)
require.Equal(t, 2, out.ItemCount)
require.Equal(t, 1, out.PageCount)
require.Len(t, out.Items, 2)
})
}
}
func TestRTSPConnsGet(t *testing.T) {
for _, ca := range []struct {
name string
endpoint string
secure bool
}{
{
name: "rtsp",
endpoint: "rtspconns",
secure: false,
},
{
name: "rtsps",
endpoint: "rtspsconns",
secure: true,
},
} {
t.Run(ca.name, func(t *testing.T) {
id := uuid.New()
sessionID := uuid.New()
now := time.Now()
rtspServer := &testRTSPServer{
conns: map[uuid.UUID]*defs.APIRTSPConn{
id: {
ID: id,
Created: now,
RemoteAddr: "192.168.1.100:5000",
InboundBytes: 999999,
OutboundBytes: 888888,
BytesReceived: 999999,
BytesSent: 888888,
Session: &sessionID,
Tunnel: "",
},
},
}
api := API{
Address: "localhost:9997",
ReadTimeout: conf.Duration(10 * time.Second),
WriteTimeout: conf.Duration(10 * time.Second),
AuthManager: test.NilAuthManager,
Parent: &testParent{},
}
if ca.secure {
api.RTSPSServer = rtspServer
} else {
api.RTSPServer = rtspServer
}
err := api.Initialize()
require.NoError(t, err)
defer api.Close()
tr := &http.Transport{}
defer tr.CloseIdleConnections()
hc := &http.Client{Transport: tr}
req, err := http.NewRequest(http.MethodGet,
fmt.Sprintf("http://localhost:9997/v3/%s/get/%s", ca.endpoint, id), nil)
require.NoError(t, err)
res, err := hc.Do(req)
require.NoError(t, err)
defer res.Body.Close()
require.Equal(t, http.StatusOK, res.StatusCode)
var out defs.APIRTSPConn
err = json.NewDecoder(res.Body).Decode(&out)
require.NoError(t, err)
require.Equal(t, id, out.ID)
require.Equal(t, "192.168.1.100:5000", out.RemoteAddr)
require.Equal(t, uint64(999999), out.InboundBytes)
require.Equal(t, uint64(888888), out.OutboundBytes)
require.Equal(t, uint64(999999), out.BytesReceived)
require.NotNil(t, out.Session)
require.Equal(t, sessionID, *out.Session)
})
}
}
func TestRTSPSessionsList(t *testing.T) {
for _, ca := range []struct {
name string
endpoint string
secure bool
}{
{
name: "rtsp",
endpoint: "rtspsessions",
secure: false,
},
{
name: "rtsps",
endpoint: "rtspssessions",
secure: true,
},
} {
t.Run(ca.name, func(t *testing.T) {
id1 := uuid.New()
id2 := uuid.New()
now := time.Now()
transport := "UDP"
profile := "AVP"
rtspServer := &testRTSPServer{
sessions: map[uuid.UUID]*defs.APIRTSPSession{
id1: {
ID: id1,
Created: now,
RemoteAddr: "192.168.1.1:5000",
State: defs.APIRTSPSessionStatePublish,
Path: "stream1",
Query: "token=abc",
Transport: &transport,
Profile: &profile,
InboundBytes: 1000,
InboundRTPPackets: 100,
InboundRTPPacketsLost: 5,
InboundRTPPacketsInError: 2,
InboundRTPPacketsJitter: 0.5,
InboundRTCPPackets: 10,
InboundRTCPPacketsInError: 1,
OutboundBytes: 2000,
OutboundRTPPackets: 200,
OutboundRTPPacketsReportedLost: 7,
OutboundRTCPPackets: 15,
BytesReceived: 1000,
BytesSent: 2000,
RTPPacketsReceived: 100,
RTPPacketsSent: 200,
RTPPacketsLost: 5,
RTPPacketsInError: 2,
RTPPacketsJitter: 0.5,
RTCPPacketsReceived: 10,
RTCPPacketsSent: 15,
RTCPPacketsInError: 1,
},
id2: {
ID: id2,
Created: now.Add(time.Minute),
RemoteAddr: "192.168.1.2:5001",
State: defs.APIRTSPSessionStateRead,
Path: "stream2",
Query: "",
Transport: nil,
Profile: nil,
InboundBytes: 500,
InboundRTPPackets: 50,
InboundRTPPacketsLost: 0,
InboundRTPPacketsInError: 0,
InboundRTPPacketsJitter: 0.1,
InboundRTCPPackets: 5,
InboundRTCPPacketsInError: 0,
OutboundBytes: 1500,
OutboundRTPPackets: 150,
OutboundRTPPacketsReportedLost: 0,
OutboundRTCPPackets: 10,
BytesReceived: 500,
BytesSent: 1500,
RTPPacketsReceived: 50,
RTPPacketsSent: 150,
RTPPacketsLost: 0,
RTPPacketsInError: 0,
RTPPacketsJitter: 0.1,
RTCPPacketsReceived: 5,
RTCPPacketsSent: 10,
RTCPPacketsInError: 0,
},
},
}
api := API{
Address: "localhost:9997",
ReadTimeout: conf.Duration(10 * time.Second),
WriteTimeout: conf.Duration(10 * time.Second),
AuthManager: test.NilAuthManager,
Parent: &testParent{},
}
if ca.secure {
api.RTSPSServer = rtspServer
} else {
api.RTSPServer = rtspServer
}
err := api.Initialize()
require.NoError(t, err)
defer api.Close()
tr := &http.Transport{}
defer tr.CloseIdleConnections()
hc := &http.Client{Transport: tr}
req, err := http.NewRequest(http.MethodGet,
fmt.Sprintf("http://localhost:9997/v3/%s/list", ca.endpoint), nil)
require.NoError(t, err)
res, err := hc.Do(req)
require.NoError(t, err)
defer res.Body.Close()
require.Equal(t, http.StatusOK, res.StatusCode)
var out defs.APIRTSPSessionList
err = json.NewDecoder(res.Body).Decode(&out)
require.NoError(t, err)
require.Equal(t, 2, out.ItemCount)
require.Equal(t, 1, out.PageCount)
require.Len(t, out.Items, 2)
})
}
}
func TestRTSPSessionsGet(t *testing.T) {
for _, ca := range []struct {
name string
endpoint string
secure bool
}{
{
name: "rtsp",
endpoint: "rtspsessions",
secure: false,
},
{
name: "rtsps",
endpoint: "rtspssessions",
secure: true,
},
} {
t.Run(ca.name, func(t *testing.T) {
id := uuid.New()
now := time.Now()
transport := "UDP"
profile := "AVP"
rtspServer := &testRTSPServer{
sessions: map[uuid.UUID]*defs.APIRTSPSession{
id: {
ID: id,
Created: now,
RemoteAddr: "192.168.1.100:5000",
State: defs.APIRTSPSessionStatePublish,
Path: "mystream",
Query: "key=value",
Transport: &transport,
Profile: &profile,
InboundBytes: 999999,
InboundRTPPackets: 10000,
InboundRTPPacketsLost: 50,
InboundRTPPacketsInError: 10,
InboundRTPPacketsJitter: 1.5,
InboundRTCPPackets: 100,
InboundRTCPPacketsInError: 5,
OutboundBytes: 888888,
OutboundRTPPackets: 20000,
OutboundRTPPacketsReportedLost: 25,
OutboundRTCPPackets: 200,
BytesReceived: 999999,
BytesSent: 888888,
RTPPacketsReceived: 10000,
RTPPacketsSent: 20000,
RTPPacketsLost: 50,
RTPPacketsInError: 10,
RTPPacketsJitter: 1.5,
RTCPPacketsReceived: 100,
RTCPPacketsSent: 200,
RTCPPacketsInError: 5,
},
},
}
api := API{
Address: "localhost:9997",
ReadTimeout: conf.Duration(10 * time.Second),
WriteTimeout: conf.Duration(10 * time.Second),
AuthManager: test.NilAuthManager,
Parent: &testParent{},
}
if ca.secure {
api.RTSPSServer = rtspServer
} else {
api.RTSPServer = rtspServer
}
err := api.Initialize()
require.NoError(t, err)
defer api.Close()
tr := &http.Transport{}
defer tr.CloseIdleConnections()
hc := &http.Client{Transport: tr}
req, err := http.NewRequest(http.MethodGet,
fmt.Sprintf("http://localhost:9997/v3/%s/get/%s", ca.endpoint, id), nil)
require.NoError(t, err)
res, err := hc.Do(req)
require.NoError(t, err)
defer res.Body.Close()
require.Equal(t, http.StatusOK, res.StatusCode)
var out defs.APIRTSPSession
err = json.NewDecoder(res.Body).Decode(&out)
require.NoError(t, err)
require.Equal(t, id, out.ID)
require.Equal(t, "192.168.1.100:5000", out.RemoteAddr)
require.Equal(t, defs.APIRTSPSessionStatePublish, out.State)
require.Equal(t, "mystream", out.Path)
require.Equal(t, uint64(999999), out.InboundBytes)
require.Equal(t, uint64(888888), out.OutboundBytes)
require.Equal(t, uint64(10000), out.InboundRTPPackets)
require.Equal(t, uint64(20000), out.OutboundRTPPackets)
require.Equal(t, uint64(25), out.OutboundRTPPacketsReportedLost)
require.Equal(t, uint64(999999), out.BytesReceived)
require.NotNil(t, out.Transport)
require.Equal(t, "UDP", *out.Transport)
})
}
}
func TestRTSPSessionsKick(t *testing.T) {
for _, ca := range []struct {
name string
endpoint string
secure bool
}{
{
name: "rtsp",
endpoint: "rtspsessions",
secure: false,
},
{
name: "rtsps",
endpoint: "rtspssessions",
secure: true,
},
} {
t.Run(ca.name, func(t *testing.T) {
id := uuid.New()
now := time.Now()
transport := "UDP"
profile := "AVP"
rtspServer := &testRTSPServer{
sessions: map[uuid.UUID]*defs.APIRTSPSession{
id: {
ID: id,
Created: now,
RemoteAddr: "192.168.1.100:5000",
State: defs.APIRTSPSessionStatePublish,
Path: "mystream",
Query: "",
Transport: &transport,
Profile: &profile,
BytesReceived: 1000,
BytesSent: 2000,
RTPPacketsReceived: 100,
RTPPacketsSent: 200,
RTPPacketsLost: 0,
RTPPacketsInError: 0,
RTPPacketsJitter: 0.5,
RTCPPacketsReceived: 10,
RTCPPacketsSent: 15,
RTCPPacketsInError: 0,
},
},
}
api := API{
Address: "localhost:9997",
ReadTimeout: conf.Duration(10 * time.Second),
WriteTimeout: conf.Duration(10 * time.Second),
AuthManager: test.NilAuthManager,
Parent: &testParent{},
}
if ca.secure {
api.RTSPSServer = rtspServer
} else {
api.RTSPServer = rtspServer
}
err := api.Initialize()
require.NoError(t, err)
defer api.Close()
tr := &http.Transport{}
defer tr.CloseIdleConnections()
hc := &http.Client{Transport: tr}
req, err := http.NewRequest(http.MethodPost,
fmt.Sprintf("http://localhost:9997/v3/%s/kick/%s", ca.endpoint, id), nil)
require.NoError(t, err)
res, err := hc.Do(req)
require.NoError(t, err)
defer res.Body.Close()
require.Equal(t, http.StatusOK, res.StatusCode)
checkOK(t, res.Body)
})
}
}
================================================
FILE: internal/api/api_srt.go
================================================
//nolint:dupl
package api //nolint:revive
import (
"errors"
"net/http"
"github.com/bluenviron/mediamtx/internal/servers/srt"
"github.com/gin-gonic/gin"
"github.com/google/uuid"
)
func (a *API) onSRTConnsList(ctx *gin.Context) {
data, err := a.SRTServer.APIConnsList()
if err != nil {
a.writeError(ctx, http.StatusInternalServerError, err)
return
}
data.ItemCount = len(data.Items)
pageCount, err := paginate(&data.Items, ctx.Query("itemsPerPage"), ctx.Query("page"))
if err != nil {
a.writeError(ctx, http.StatusBadRequest, err)
return
}
data.PageCount = pageCount
ctx.JSON(http.StatusOK, data)
}
func (a *API) onSRTConnsGet(ctx *gin.Context) {
uuid, err := uuid.Parse(ctx.Param("id"))
if err != nil {
a.writeError(ctx, http.StatusBadRequest, err)
return
}
data, err := a.SRTServer.APIConnsGet(uuid)
if err != nil {
if errors.Is(err, srt.ErrConnNotFound) {
a.writeError(ctx, http.StatusNotFound, err)
} else {
a.writeError(ctx, http.StatusInternalServerError, err)
}
return
}
ctx.JSON(http.StatusOK, data)
}
func (a *API) onSRTConnsKick(ctx *gin.Context) {
uuid, err := uuid.Parse(ctx.Param("id"))
if err != nil {
a.writeError(ctx, http.StatusBadRequest, err)
return
}
err = a.SRTServer.APIConnsKick(uuid)
if err != nil {
if errors.Is(err, srt.ErrConnNotFound) {
a.writeError(ctx, http.StatusNotFound, err)
} else {
a.writeError(ctx, http.StatusInternalServerError, err)
}
return
}
a.writeOK(ctx)
}
================================================
FILE: internal/api/api_srt_test.go
================================================
package api //nolint:revive
import (
"fmt"
"net/http"
"testing"
"time"
"github.com/bluenviron/mediamtx/internal/conf"
"github.com/bluenviron/mediamtx/internal/defs"
"github.com/bluenviron/mediamtx/internal/servers/srt"
"github.com/bluenviron/mediamtx/internal/test"
"github.com/google/uuid"
"github.com/stretchr/testify/require"
)
type testSRTServer struct {
conns map[uuid.UUID]*defs.APISRTConn
}
func (s *testSRTServer) APIConnsList() (*defs.APISRTConnList, error) {
items := make([]defs.APISRTConn, 0, len(s.conns))
for _, conn := range s.conns {
items = append(items, *conn)
}
return &defs.APISRTConnList{Items: items}, nil
}
func (s *testSRTServer) APIConnsGet(id uuid.UUID) (*defs.APISRTConn, error) {
conn, ok := s.conns[id]
if !ok {
return nil, srt.ErrConnNotFound
}
return conn, nil
}
func (s *testSRTServer) APIConnsKick(id uuid.UUID) error {
_, ok := s.conns[id]
if !ok {
return srt.ErrConnNotFound
}
return nil
}
func TestSRTConnsList(t *testing.T) {
id1 := uuid.New()
id2 := uuid.New()
now := time.Now()
srtServer := &testSRTServer{
conns: map[uuid.UUID]*defs.APISRTConn{
id1: {
ID: id1,
Created: now,
RemoteAddr: "192.168.1.1:5000",
State: defs.APISRTConnStatePublish,
Path: "stream1",
Query: "token=abc",
PacketsSent: 1000,
PacketsReceived: 2000,
PacketsSentUnique: 950,
PacketsReceivedUnique: 1950,
BytesReceived: 100000,
BytesSent: 200000,
OutboundFramesDiscarded: 5,
MsRTT: 10.5,
MbpsSendRate: 5.2,
MbpsReceiveRate: 4.8,
},
id2: {
ID: id2,
Created: now.Add(time.Minute),
RemoteAddr: "192.168.1.2:5001",
State: defs.APISRTConnStateRead,
Path: "stream2",
Query: "",
PacketsSent: 500,
PacketsReceived: 1500,
PacketsSentUnique: 480,
PacketsReceivedUnique: 1470,
BytesReceived: 50000,
BytesSent: 150000,
OutboundFramesDiscarded: 6,
MsRTT: 15.2,
MbpsSendRate: 3.5,
MbpsReceiveRate: 3.2,
},
},
}
api := API{
Address: "localhost:9997",
ReadTimeout: conf.Duration(10 * time.Second),
WriteTimeout: conf.Duration(10 * time.Second),
AuthManager: test.NilAuthManager,
SRTServer: srtServer,
Parent: &testParent{},
}
err := api.Initialize()
require.NoError(t, err)
defer api.Close()
tr := &http.Transport{}
defer tr.CloseIdleConnections()
hc := &http.Client{Transport: tr}
var out defs.APISRTConnList
httpRequest(t, hc, http.MethodGet, "http://localhost:9997/v3/srtconns/list", nil, &out)
require.Equal(t, 2, out.ItemCount)
require.Equal(t, 1, out.PageCount)
require.Len(t, out.Items, 2)
}
func TestSRTConnsGet(t *testing.T) {
id := uuid.New()
now := time.Now()
srtServer := &testSRTServer{
conns: map[uuid.UUID]*defs.APISRTConn{
id: {
ID: id,
Created: now,
RemoteAddr: "192.168.1.100:5000",
State: defs.APISRTConnStatePublish,
Path: "mystream",
Query: "key=value",
PacketsSent: 10000,
PacketsReceived: 20000,
PacketsSentUnique: 9900,
PacketsReceivedUnique: 19800,
PacketsSendLoss: 50,
PacketsReceivedLoss: 100,
PacketsRetrans: 60,
PacketsReceivedRetrans: 80,
PacketsSentACK: 500,
PacketsReceivedACK: 600,
PacketsSentNAK: 10,
PacketsReceivedNAK: 15,
PacketsSentKM: 2,
PacketsReceivedKM: 2,
UsSndDuration: 1000000,
PacketsReceivedBelated: 5,
PacketsSendDrop: 3,
PacketsReceivedDrop: 4,
PacketsReceivedUndecrypt: 0,
BytesReceived: 999999,
BytesSent: 888888,
BytesSentUnique: 880000,
BytesReceivedUnique: 990000,
BytesReceivedLoss: 5000,
BytesRetrans: 3000,
BytesReceivedRetrans: 4000,
BytesReceivedBelated: 200,
BytesSendDrop: 150,
BytesReceivedDrop: 180,
BytesReceivedUndecrypt: 0,
UsPacketsSendPeriod: 1000.5,
PacketsFlowWindow: 8192,
PacketsFlightSize: 256,
MsRTT: 25.5,
MbpsSendRate: 10.5,
MbpsReceiveRate: 9.8,
MbpsLinkCapacity: 100.0,
BytesAvailSendBuf: 65536,
BytesAvailReceiveBuf: 131072,
MbpsMaxBW: 50.0,
ByteMSS: 1500,
PacketsSendBuf: 128,
BytesSendBuf: 192000,
MsSendBuf: 1000,
MsSendTsbPdDelay: 120,
PacketsReceiveBuf: 256,
BytesReceiveBuf: 384000,
MsReceiveBuf: 2000,
MsReceiveTsbPdDelay: 120,
PacketsReorderTolerance: 10,
PacketsReceivedAvgBelatedTime: 50,
PacketsSendLossRate: 0.5,
PacketsReceivedLossRate: 0.6,
OutboundFramesDiscarded: 7,
},
},
}
api := API{
Address: "localhost:9997",
ReadTimeout: conf.Duration(10 * time.Second),
WriteTimeout: conf.Duration(10 * time.Second),
AuthManager: test.NilAuthManager,
SRTServer: srtServer,
Parent: &testParent{},
}
err := api.Initialize()
require.NoError(t, err)
defer api.Close()
tr := &http.Transport{}
defer tr.CloseIdleConnections()
hc := &http.Client{Transport: tr}
var out defs.APISRTConn
httpRequest(t, hc, http.MethodGet, fmt.Sprintf("http://localhost:9997/v3/srtconns/get/%s", id), nil, &out)
require.Equal(t, id, out.ID)
require.Equal(t, "192.168.1.100:5000", out.RemoteAddr)
require.Equal(t, defs.APISRTConnStatePublish, out.State)
require.Equal(t, "mystream", out.Path)
require.Equal(t, uint64(999999), out.BytesReceived)
require.Equal(t, uint64(888888), out.BytesSent)
require.Equal(t, uint64(7), out.OutboundFramesDiscarded)
require.Equal(t, 25.5, out.MsRTT)
require.Equal(t, 10.5, out.MbpsSendRate)
require.Equal(t, 9.8, out.MbpsReceiveRate)
}
func TestSRTConnsKick(t *testing.T) {
id := uuid.New()
now := time.Now()
srtServer := &testSRTServer{
conns: map[uuid.UUID]*defs.APISRTConn{
id: {
ID: id,
Created: now,
RemoteAddr: "192.168.1.100:5000",
State: defs.APISRTConnStatePublish,
Path: "mystream",
Query: "",
PacketsSent: 1000,
PacketsReceived: 2000,
PacketsSentUnique: 950,
PacketsReceivedUnique: 1950,
BytesReceived: 100000,
BytesSent: 200000,
MsRTT: 10.5,
MbpsSendRate: 5.2,
MbpsReceiveRate: 4.8,
},
},
}
api := API{
Address: "localhost:9997",
ReadTimeout: conf.Duration(10 * time.Second),
WriteTimeout: conf.Duration(10 * time.Second),
AuthManager: test.NilAuthManager,
SRTServer: srtServer,
Parent: &testParent{},
}
err := api.Initialize()
require.NoError(t, err)
defer api.Close()
tr := &http.Transport{}
defer tr.CloseIdleConnections()
hc := &http.Client{Transport: tr}
httpRequest(t, hc, http.MethodPost, fmt.Sprintf("http://localhost:9997/v3/srtconns/kick/%s", id), nil, nil)
}
================================================
FILE: internal/api/api_test.go
================================================
package api //nolint:revive
import (
"bytes"
"encoding/json"
"fmt"
"io"
"net/http"
"net/url"
"os"
"testing"
"time"
"github.com/bluenviron/mediamtx/internal/auth"
"github.com/bluenviron/mediamtx/internal/conf"
"github.com/bluenviron/mediamtx/internal/logger"
"github.com/bluenviron/mediamtx/internal/test"
"github.com/stretchr/testify/require"
)
type testParent struct {
log func(_ logger.Level, _ string, _ ...any)
}
func (p testParent) Log(l logger.Level, s string, a ...any) {
if p.log != nil {
p.log(l, s, a...)
}
}
func (testParent) APIConfigSet(_ *conf.Conf) {}
func tempConf(t *testing.T, cnt string) *conf.Conf {
fi, err := test.CreateTempFile([]byte(cnt))
require.NoError(t, err)
defer os.Remove(fi)
cnf, _, err := conf.Load(fi, nil, nil)
require.NoError(t, err)
return cnf
}
func httpRequest(t *testing.T, hc *http.Client, method string, ur string, in any, out any) {
buf := func() io.Reader {
if in == nil {
return nil
}
byts, err := json.Marshal(in)
require.NoError(t, err)
return bytes.NewBuffer(byts)
}()
req, err := http.NewRequest(method, ur, buf)
require.NoError(t, err)
res, err := hc.Do(req)
require.NoError(t, err)
defer res.Body.Close()
if res.StatusCode != http.StatusOK {
t.Errorf("bad status code: %d", res.StatusCode)
}
if out == nil {
checkOK(t, res.Body)
return
}
err = json.NewDecoder(res.Body).Decode(out)
require.NoError(t, err)
}
func checkError(t *testing.T, body io.Reader, msg string) {
var raw map[string]any
err := json.NewDecoder(body).Decode(&raw)
require.NoError(t, err)
require.Equal(t, map[string]any{"status": "error", "error": msg}, raw)
}
func checkOK(t *testing.T, body io.Reader) {
var raw map[string]any
err := json.NewDecoder(body).Decode(&raw)
require.NoError(t, err)
require.Equal(t, map[string]any{"status": "ok"}, raw)
}
func TestPreflightRequest(t *testing.T) {
api := API{
Address: "localhost:9997",
AllowOrigins: []string{"*"},
ReadTimeout: conf.Duration(10 * time.Second),
WriteTimeout: conf.Duration(10 * time.Second),
AuthManager: test.NilAuthManager,
Parent: &testParent{},
}
err := api.Initialize()
require.NoError(t, err)
defer api.Close()
tr := &http.Transport{}
defer tr.CloseIdleConnections()
hc := &http.Client{Transport: tr}
req, err := http.NewRequest(http.MethodOptions, "http://localhost:9997", nil)
require.NoError(t, err)
req.Header.Add("Access-Control-Request-Method", "GET")
res, err := hc.Do(req)
require.NoError(t, err)
defer res.Body.Close()
require.Equal(t, http.StatusNoContent, res.StatusCode)
byts, err := io.ReadAll(res.Body)
require.NoError(t, err)
require.Equal(t, "*", res.Header.Get("Access-Control-Allow-Origin"))
require.Equal(t, "true", res.Header.Get("Access-Control-Allow-Credentials"))
require.Equal(t, "OPTIONS, GET, POST, PATCH, DELETE", res.Header.Get("Access-Control-Allow-Methods"))
require.Equal(t, "Authorization, Content-Type", res.Header.Get("Access-Control-Allow-Headers"))
require.Equal(t, byts, []byte{})
}
func TestInfo(t *testing.T) {
cnf := tempConf(t, "api: yes\n")
api := API{
Version: "v1.2.3",
Started: time.Date(2008, 11, 7, 11, 22, 0, 0, time.Local),
Address: "localhost:9997",
ReadTimeout: conf.Duration(10 * time.Second),
WriteTimeout: conf.Duration(10 * time.Second),
Conf: cnf,
AuthManager: test.NilAuthManager,
Parent: &testParent{},
}
err := api.Initialize()
require.NoError(t, err)
defer api.Close()
tr := &http.Transport{}
defer tr.CloseIdleConnections()
hc := &http.Client{Transport: tr}
var out map[string]any
httpRequest(t, hc, http.MethodGet, "http://localhost:9997/v3/info", nil, &out)
require.Equal(t, map[string]any{
"started": time.Date(2008, 11, 7, 11, 22, 0, 0, time.Local).Format(time.RFC3339),
"version": "v1.2.3",
}, out)
}
func TestAuthJWKSRefresh(t *testing.T) {
ok := false
api := API{
Address: "localhost:9997",
ReadTimeout: conf.Duration(10 * time.Second),
WriteTimeout: conf.Duration(10 * time.Second),
AuthManager: &test.AuthManager{
AuthenticateImpl: func(_ *auth.Request) (string, *auth.Error) {
return "", nil
},
RefreshJWTJWKSImpl: func() {
ok = true
},
},
Parent: &testParent{},
}
err := api.Initialize()
require.NoError(t, err)
defer api.Close()
tr := &http.Transport{}
defer tr.CloseIdleConnections()
hc := &http.Client{Transport: tr}
u, err := url.Parse("http://localhost:9997/v3/auth/jwks/refresh")
require.NoError(t, err)
httpRequest(t, hc, http.MethodPost, u.String(), nil, nil)
require.True(t, ok)
}
func TestAuthError(t *testing.T) {
cnf := tempConf(t, "api: yes\n")
n := 0
api := API{
Address: "localhost:9997",
ReadTimeout: conf.Duration(10 * time.Second),
WriteTimeout: conf.Duration(10 * time.Second),
Conf: cnf,
AuthManager: &test.AuthManager{
AuthenticateImpl: func(req *auth.Request) (string, *auth.Error) {
if req.Credentials.User == "" {
return "", &auth.Error{AskCredentials: true, Wrapped: fmt.Errorf("auth error")}
}
return "", &auth.Error{Wrapped: fmt.Errorf("auth error")}
},
},
Parent: &testParent{
log: func(l logger.Level, s string, i ...any) {
if l == logger.Info {
if n == 1 {
require.Regexp(t, "failed to authenticate: auth error$", fmt.Sprintf(s, i...))
}
n++
}
},
},
}
err := api.Initialize()
require.NoError(t, err)
defer api.Close()
tr := &http.Transport{}
defer tr.CloseIdleConnections()
hc := &http.Client{Transport: tr}
res, err := hc.Get("http://localhost:9997/v3/config/global/get")
require.NoError(t, err)
defer res.Body.Close()
require.Equal(t, http.StatusUnauthorized, res.StatusCode)
require.Equal(t, `Basic realm="mediamtx"`, res.Header.Get("WWW-Authenticate"))
checkError(t, res.Body, "authentication error")
res, err = hc.Get("http://myuser:mypass@localhost:9997/v3/config/global/get")
require.NoError(t, err)
defer res.Body.Close()
require.Equal(t, http.StatusUnauthorized, res.StatusCode)
require.Equal(t, ``, res.Header.Get("WWW-Authenticate"))
checkError(t, res.Body, "authentication error")
require.Equal(t, 2, n)
}
================================================
FILE: internal/api/api_webrtc.go
================================================
//nolint:dupl
package api //nolint:revive
import (
"errors"
"net/http"
"github.com/bluenviron/mediamtx/internal/servers/webrtc"
"github.com/gin-gonic/gin"
"github.com/google/uuid"
)
func (a *API) onWebRTCSessionsList(ctx *gin.Context) {
data, err := a.WebRTCServer.APISessionsList()
if err != nil {
a.writeError(ctx, http.StatusInternalServerError, err)
return
}
data.ItemCount = len(data.Items)
pageCount, err := paginate(&data.Items, ctx.Query("itemsPerPage"), ctx.Query("page"))
if err != nil {
a.writeError(ctx, http.StatusBadRequest, err)
return
}
data.PageCount = pageCount
ctx.JSON(http.StatusOK, data)
}
func (a *API) onWebRTCSessionsGet(ctx *gin.Context) {
uuid, err := uuid.Parse(ctx.Param("id"))
if err != nil {
a.writeError(ctx, http.StatusBadRequest, err)
return
}
data, err := a.WebRTCServer.APISessionsGet(uuid)
if err != nil {
if errors.Is(err, webrtc.ErrSessionNotFound) {
a.writeError(ctx, http.StatusNotFound, err)
} else {
a.writeError(ctx, http.StatusInternalServerError, err)
}
return
}
ctx.JSON(http.StatusOK, data)
}
func (a *API) onWebRTCSessionsKick(ctx *gin.Context) {
uuid, err := uuid.Parse(ctx.Param("id"))
if err != nil {
a.writeError(ctx, http.StatusBadRequest, err)
return
}
err = a.WebRTCServer.APISessionsKick(uuid)
if err != nil {
if errors.Is(err, webrtc.ErrSessionNotFound) {
a.writeError(ctx, http.StatusNotFound, err)
} else {
a.writeError(ctx, http.StatusInternalServerError, err)
}
return
}
a.writeOK(ctx)
}
================================================
FILE: internal/api/api_webrtc_test.go
================================================
package api //nolint:revive
import (
"fmt"
"net/http"
"testing"
"time"
"github.com/bluenviron/mediamtx/internal/conf"
"github.com/bluenviron/mediamtx/internal/defs"
"github.com/bluenviron/mediamtx/internal/servers/webrtc"
"github.com/bluenviron/mediamtx/internal/test"
"github.com/google/uuid"
"github.com/stretchr/testify/require"
)
type testWebRTCServer struct {
sessions map[uuid.UUID]*defs.APIWebRTCSession
}
func (s *testWebRTCServer) APISessionsList() (*defs.APIWebRTCSessionList, error) {
items := make([]defs.APIWebRTCSession, 0, len(s.sessions))
for _, session := range s.sessions {
items = append(items, *session)
}
return &defs.APIWebRTCSessionList{Items: items}, nil
}
func (s *testWebRTCServer) APISessionsGet(id uuid.UUID) (*defs.APIWebRTCSession, error) {
session, ok := s.sessions[id]
if !ok {
return nil, webrtc.ErrSessionNotFound
}
return session, nil
}
func (s *testWebRTCServer) APISessionsKick(id uuid.UUID) error {
_, ok := s.sessions[id]
if !ok {
return webrtc.ErrSessionNotFound
}
return nil
}
func TestWebRTCSessionsList(t *testing.T) {
id1 := uuid.New()
id2 := uuid.New()
now := time.Now()
webrtcServer := &testWebRTCServer{
sessions: map[uuid.UUID]*defs.APIWebRTCSession{
id1: {
ID: id1,
Created: now,
RemoteAddr: "192.168.1.1:5000",
PeerConnectionEstablished: true,
LocalCandidate: "192.168.1.100:8000",
RemoteCandidate: "192.168.1.1:5000",
State: defs.APIWebRTCSessionStatePublish,
Path: "stream1",
Query: "token=abc",
InboundBytes: 1000,
InboundRTPPackets: 100,
InboundRTPPacketsLost: 5,
InboundRTPPacketsJitter: 0.5,
InboundRTCPPackets: 10,
OutboundBytes: 2000,
OutboundRTPPackets: 200,
OutboundRTCPPackets: 15,
OutboundFramesDiscarded: 11,
BytesReceived: 1000,
BytesSent: 2000,
RTPPacketsReceived: 100,
RTPPacketsSent: 200,
RTPPacketsLost: 5,
RTPPacketsJitter: 0.5,
RTCPPacketsReceived: 10,
RTCPPacketsSent: 15,
},
id2: {
ID: id2,
Created: now.Add(time.Minute),
RemoteAddr: "192.168.1.2:5001",
PeerConnectionEstablished: true,
LocalCandidate: "192.168.1.100:8001",
RemoteCandidate: "192.168.1.2:5001",
State: defs.APIWebRTCSessionStateRead,
Path: "stream2",
Query: "",
InboundBytes: 500,
InboundRTPPackets: 50,
InboundRTPPacketsLost: 0,
InboundRTPPacketsJitter: 0.1,
InboundRTCPPackets: 5,
OutboundBytes: 1500,
OutboundRTPPackets: 150,
OutboundRTCPPackets: 10,
OutboundFramesDiscarded: 22,
BytesReceived: 500,
BytesSent: 1500,
RTPPacketsReceived: 50,
RTPPacketsSent: 150,
RTPPacketsLost: 0,
RTPPacketsJitter: 0.1,
RTCPPacketsReceived: 5,
RTCPPacketsSent: 10,
},
},
}
api := API{
Address: "localhost:9997",
ReadTimeout: conf.Duration(10 * time.Second),
WriteTimeout: conf.Duration(10 * time.Second),
AuthManager: test.NilAuthManager,
WebRTCServer: webrtcServer,
Parent: &testParent{},
}
err := api.Initialize()
require.NoError(t, err)
defer api.Close()
tr := &http.Transport{}
defer tr.CloseIdleConnections()
hc := &http.Client{Transport: tr}
var out defs.APIWebRTCSessionList
httpRequest(t, hc, http.MethodGet, "http://localhost:9997/v3/webrtcsessions/list", nil, &out)
require.Equal(t, 2, out.ItemCount)
require.Equal(t, 1, out.PageCount)
require.Len(t, out.Items, 2)
}
func TestWebRTCSessionsGet(t *testing.T) {
id := uuid.New()
now := time.Now()
webrtcServer := &testWebRTCServer{
sessions: map[uuid.UUID]*defs.APIWebRTCSession{
id: {
ID: id,
Created: now,
RemoteAddr: "192.168.1.100:5000",
PeerConnectionEstablished: true,
LocalCandidate: "192.168.1.200:8000",
RemoteCandidate: "192.168.1.100:5000",
State: defs.APIWebRTCSessionStatePublish,
Path: "mystream",
Query: "key=value",
InboundBytes: 999999,
InboundRTPPackets: 10000,
InboundRTPPacketsLost: 50,
InboundRTPPacketsJitter: 1.5,
InboundRTCPPackets: 100,
OutboundBytes: 888888,
OutboundRTPPackets: 20000,
OutboundRTCPPackets: 200,
OutboundFramesDiscarded: 33,
BytesReceived: 999999,
BytesSent: 888888,
RTPPacketsReceived: 10000,
RTPPacketsSent: 20000,
RTPPacketsLost: 50,
RTPPacketsJitter: 1.5,
RTCPPacketsReceived: 100,
RTCPPacketsSent: 200,
},
},
}
api := API{
Address: "localhost:9997",
ReadTimeout: conf.Duration(10 * time.Second),
WriteTimeout: conf.Duration(10 * time.Second),
AuthManager: test.NilAuthManager,
WebRTCServer: webrtcServer,
Parent: &testParent{},
}
err := api.Initialize()
require.NoError(t, err)
defer api.Close()
tr := &http.Transport{}
defer tr.CloseIdleConnections()
hc := &http.Client{Transport: tr}
var out defs.APIWebRTCSession
httpRequest(t, hc, http.MethodGet, fmt.Sprintf("http://localhost:9997/v3/webrtcsessions/get/%s", id), nil, &out)
require.Equal(t, id, out.ID)
require.Equal(t, "192.168.1.100:5000", out.RemoteAddr)
require.Equal(t, defs.APIWebRTCSessionStatePublish, out.State)
require.Equal(t, "mystream", out.Path)
require.True(t, out.PeerConnectionEstablished)
require.Equal(t, "192.168.1.200:8000", out.LocalCandidate)
require.Equal(t, "192.168.1.100:5000", out.RemoteCandidate)
require.Equal(t, uint64(999999), out.InboundBytes)
require.Equal(t, uint64(888888), out.OutboundBytes)
require.Equal(t, uint64(10000), out.InboundRTPPackets)
require.Equal(t, uint64(20000), out.OutboundRTPPackets)
require.Equal(t, uint64(33), out.OutboundFramesDiscarded)
require.Equal(t, uint64(999999), out.BytesReceived)
require.Equal(t, uint64(888888), out.BytesSent)
require.Equal(t, uint64(10000), out.RTPPacketsReceived)
require.Equal(t, uint64(20000), out.RTPPacketsSent)
require.Equal(t, uint64(50), out.RTPPacketsLost)
require.Equal(t, 1.5, out.RTPPacketsJitter)
}
func TestWebRTCSessionsKick(t *testing.T) {
id := uuid.New()
now := time.Now()
webrtcServer := &testWebRTCServer{
sessions: map[uuid.UUID]*defs.APIWebRTCSession{
id: {
ID: id,
Created: now,
RemoteAddr: "192.168.1.100:5000",
PeerConnectionEstablished: true,
LocalCandidate: "192.168.1.200:8000",
RemoteCandidate: "192.168.1.100:5000",
State: defs.APIWebRTCSessionStatePublish,
Path: "mystream",
Query: "",
InboundBytes: 1000,
InboundRTPPackets: 100,
InboundRTPPacketsLost: 0,
InboundRTPPacketsJitter: 0.5,
InboundRTCPPackets: 10,
OutboundBytes: 2000,
OutboundRTPPackets: 200,
OutboundRTCPPackets: 15,
BytesReceived: 1000,
BytesSent: 2000,
RTPPacketsReceived: 100,
RTPPacketsSent: 200,
RTPPacketsLost: 0,
RTPPacketsJitter: 0.5,
RTCPPacketsReceived: 10,
RTCPPacketsSent: 15,
},
},
}
api := API{
Address: "localhost:9997",
ReadTimeout: conf.Duration(10 * time.Second),
WriteTimeout: conf.Duration(10 * time.Second),
AuthManager: test.NilAuthManager,
WebRTCServer: webrtcServer,
Parent: &testParent{},
}
err := api.Initialize()
require.NoError(t, err)
defer api.Close()
tr := &http.Transport{}
defer tr.CloseIdleConnections()
hc := &http.Client{Transport: tr}
httpRequest(t, hc, http.MethodPost, fmt.Sprintf("http://localhost:9997/v3/webrtcsessions/kick/%s", id), nil, nil)
}
================================================
FILE: internal/api/paginate.go
================================================
package api //nolint:revive
import (
"fmt"
"reflect"
"strconv"
)
func paginate2(itemsPtr any, itemsPerPage int, page int) int {
ritems := reflect.ValueOf(itemsPtr).Elem()
itemsLen := ritems.Len()
if itemsLen == 0 {
return 0
}
pageCount := (itemsLen / itemsPerPage)
if (itemsLen % itemsPerPage) != 0 {
pageCount++
}
minVal := min(page*itemsPerPage, itemsLen)
maxVal := min((page+1)*itemsPerPage, itemsLen)
ritems.Set(ritems.Slice(minVal, maxVal))
return pageCount
}
func paginate(itemsPtr any, itemsPerPageStr string, pageStr string) (int, error) {
itemsPerPage := 100
if itemsPerPageStr != "" {
tmp, err := strconv.ParseUint(itemsPerPageStr, 10, 31)
if err != nil {
return 0, err
}
itemsPerPage = int(tmp)
if itemsPerPage == 0 {
return 0, fmt.Errorf("invalid items per page")
}
}
page := 0
if pageStr != "" {
tmp, err := strconv.ParseUint(pageStr, 10, 31)
if err != nil {
return 0, err
}
page = int(tmp)
}
return paginate2(itemsPtr, itemsPerPage, page), nil
}
================================================
FILE: internal/api/paginate_test.go
================================================
package api //nolint:revive
import (
"testing"
"github.com/stretchr/testify/require"
)
func TestPaginate(t *testing.T) {
func() {
items := make([]int, 5)
for i := range 5 {
items[i] = i
}
pageCount, err := paginate(&items, "1", "1")
require.NoError(t, err)
require.Equal(t, 5, pageCount)
require.Equal(t, []int{1}, items)
}()
func() {
items := make([]int, 5)
for i := range 5 {
items[i] = i
}
pageCount, err := paginate(&items, "3", "2")
require.NoError(t, err)
require.Equal(t, 2, pageCount)
require.Equal(t, []int{}, items)
}()
func() {
items := make([]int, 6)
for i := range 6 {
items[i] = i
}
pageCount, err := paginate(&items, "4", "1")
require.NoError(t, err)
require.Equal(t, 2, pageCount)
require.Equal(t, []int{4, 5}, items)
}()
func() {
items := make([]int, 0)
pageCount, err := paginate(&items, "1", "0")
require.NoError(t, err)
require.Equal(t, 0, pageCount)
require.Equal(t, []int{}, items)
}()
}
func FuzzPaginate(f *testing.F) {
f.Fuzz(func(_ *testing.T, str1 string, str2 string) {
items := make([]int, 6)
for i := range 6 {
items[i] = i
}
paginate(&items, str1, str2) //nolint:errcheck
})
}
================================================
FILE: internal/api/testdata/fuzz/FuzzPaginate/23731da0f18d31d0
================================================
go test fuzz v1
string("A")
string("0")
================================================
FILE: internal/api/testdata/fuzz/FuzzPaginate/34523a772174e26e
================================================
go test fuzz v1
string("1")
string("A")
================================================
FILE: internal/api/testdata/fuzz/FuzzPaginate/85649d45641911d0
================================================
go test fuzz v1
string("0")
string("")
================================================
FILE: internal/auth/credentials.go
================================================
package auth
// Credentials is a set of credentials (either user+pass or a token).
type Credentials struct {
User string
Pass string
Token string
}
================================================
FILE: internal/auth/error.go
================================================
package auth
// Error is an authentication error.
type Error struct {
Wrapped error
AskCredentials bool
}
// Error implements the error interface.
func (e Error) Error() string {
return "authentication failed: " + e.Wrapped.Error()
}
================================================
FILE: internal/auth/jwt_claims.go
================================================
package auth
import (
"encoding/json"
"fmt"
"github.com/bluenviron/mediamtx/internal/conf"
"github.com/bluenviron/mediamtx/internal/conf/jsonwrapper"
"github.com/golang-jwt/jwt/v5"
)
type jwtClaims struct {
jwt.RegisteredClaims
permissionsKey string
permissions []conf.AuthInternalUserPermission
}
func (c *jwtClaims) UnmarshalJSON(b []byte) error {
err := json.Unmarshal(b, &c.RegisteredClaims)
if err != nil {
return err
}
var claimMap map[string]json.RawMessage
err = json.Unmarshal(b, &claimMap)
if err != nil {
return err
}
rawPermissions, ok := claimMap[c.permissionsKey]
if !ok {
return fmt.Errorf("claim '%s' not found inside JWT", c.permissionsKey)
}
err = jsonwrapper.Unmarshal(rawPermissions, &c.permissions)
if err != nil {
var str string
err = json.Unmarshal(rawPermissions, &str)
if err != nil {
return err
}
err = jsonwrapper.Unmarshal([]byte(str), &c.permissions)
if err != nil {
return err
}
}
return nil
}
================================================
FILE: internal/auth/manager.go
================================================
// Package auth contains the authentication system.
package auth
import (
"bytes"
"encoding/json"
"fmt"
"io"
"net/http"
"net/url"
"regexp"
"strings"
"sync"
"time"
"github.com/MicahParks/keyfunc/v3"
"github.com/bluenviron/mediamtx/internal/conf"
"github.com/bluenviron/mediamtx/internal/protocols/tls"
"github.com/golang-jwt/jwt/v5"
"github.com/google/uuid"
)
const (
// PauseAfterError is the pause to apply after an authentication failure.
PauseAfterError = 2 * time.Second
jwksRefreshPeriod = 60 * 60 * time.Second
)
func isHTTP(req *Request) bool {
return req.Protocol == ProtocolHLS || req.Protocol == ProtocolWebRTC ||
req.Action == conf.AuthActionPlayback ||
req.Action == conf.AuthActionAPI ||
req.Action == conf.AuthActionMetrics ||
req.Action == conf.AuthActionPprof
}
func matchesPermission(perms []conf.AuthInternalUserPermission, req *Request) bool {
for _, perm := range perms {
if perm.Action == req.Action {
if perm.Action == conf.AuthActionPublish ||
perm.Action == conf.AuthActionRead ||
perm.Action == conf.AuthActionPlayback {
switch {
case perm.Path == "":
return true
case strings.HasPrefix(perm.Path, "~"):
regexp, err := regexp.Compile(perm.Path[1:])
if err == nil && regexp.MatchString(req.Path) {
return true
}
case perm.Path == req.Path:
return true
}
} else {
return true
}
}
}
return false
}
// Manager is the authentication manager.
type Manager struct {
Method conf.AuthMethod
InternalUsers []conf.AuthInternalUser
HTTPAddress string
HTTPFingerprint string
HTTPExclude []conf.AuthInternalUserPermission
JWTJWKS string
JWTJWKSFingerprint string
JWTClaimKey string
JWTExclude []conf.AuthInternalUserPermission
JWTInHTTPQuery bool
JWTIssuer string
JWTAudience string
ReadTimeout time.Duration
mutex sync.RWMutex
jwksLastRefresh time.Time
jwtKeyFunc keyfunc.Keyfunc
}
// ReloadInternalUsers reloads InternalUsers.
func (m *Manager) ReloadInternalUsers(u []conf.AuthInternalUser) {
m.mutex.Lock()
defer m.mutex.Unlock()
m.InternalUsers = u
}
// Authenticate authenticates a request.
// It returns the user name.
func (m *Manager) Authenticate(req *Request) (string, *Error) {
var user string
var err error
switch m.Method {
case conf.AuthMethodInternal:
user, err = m.authenticateInternal(req)
case conf.AuthMethodHTTP:
user, err = m.authenticateHTTP(req)
default:
user, err = m.authenticateJWT(req)
}
if err != nil {
return "", &Error{
Wrapped: err,
AskCredentials: (req.Credentials.User == "" && req.Credentials.Pass == "" && req.Credentials.Token == ""),
}
}
return user, nil
}
func (m *Manager) authenticateInternal(req *Request) (string, error) {
m.mutex.RLock()
defer m.mutex.RUnlock()
for _, u := range m.InternalUsers {
if ok := m.authenticateWithUser(req, &u); ok {
return req.Credentials.User, nil
}
}
return "", fmt.Errorf("authentication failed")
}
func (m *Manager) authenticateWithUser(
req *Request,
u *conf.AuthInternalUser,
) bool {
if len(u.IPs) != 0 && !u.IPs.Contains(req.IP) {
return false
}
if !matchesPermission(u.Permissions, req) {
return false
}
if u.User != "any" {
if req.CustomVerifyFunc != nil {
if ok := req.CustomVerifyFunc(string(u.User), string(u.Pass)); !ok {
return false
}
} else {
if !u.User.Check(req.Credentials.User) || !u.Pass.Check(req.Credentials.Pass) {
return false
}
}
}
return true
}
func (m *Manager) authenticateHTTP(req *Request) (string, error) {
if matchesPermission(m.HTTPExclude, req) {
return "", nil
}
enc, _ := json.Marshal(struct {
IP string `json:"ip"`
User string `json:"user"`
Password string `json:"password"`
Token string `json:"token"`
Action string `json:"action"`
Path string `json:"path"`
Protocol string `json:"protocol"`
ID *uuid.UUID `json:"id"`
Query string `json:"query"`
}{
IP: req.IP.String(),
User: req.Credentials.User,
Password: req.Credentials.Pass,
Token: req.Credentials.Token,
Action: string(req.Action),
Path: req.Path,
Protocol: string(req.Protocol),
ID: req.ID,
Query: req.Query,
})
u, err := url.Parse(m.HTTPAddress)
if err != nil {
return "", err
}
tr := &http.Transport{
TLSClientConfig: tls.MakeConfig(u.Hostname(), m.HTTPFingerprint),
}
defer tr.CloseIdleConnections()
httpClient := &http.Client{
Timeout: m.ReadTimeout,
Transport: tr,
}
res, err := httpClient.Post(m.HTTPAddress, "application/json", bytes.NewReader(enc))
if err != nil {
return "", fmt.Errorf("HTTP request failed: %w", err)
}
defer res.Body.Close()
if res.StatusCode < 200 || res.StatusCode > 299 {
if resBody, err2 := io.ReadAll(res.Body); err2 == nil && len(resBody) != 0 {
return "", fmt.Errorf("server replied with code %d: %s", res.StatusCode, string(resBody))
}
return "", fmt.Errorf("server replied with code %d", res.StatusCode)
}
return req.Credentials.User, nil
}
func (m *Manager) authenticateJWT(req *Request) (string, error) {
if matchesPermission(m.JWTExclude, req) {
return "", nil
}
keyfunc, err := m.pullJWTJWKS()
if err != nil {
return "", err
}
var encodedJWT string
switch {
case req.Credentials.Token != "":
encodedJWT = req.Credentials.Token
case req.Credentials.Pass != "":
encodedJWT = req.Credentials.Pass
// always allow passing JWT through query parameters with RTSP and RTMP since there's no alternative.
case req.Protocol == ProtocolRTSP || req.Protocol == ProtocolRTMP || (isHTTP(req) && m.JWTInHTTPQuery):
var v url.Values
v, err = url.ParseQuery(req.Query)
if err != nil {
return "", err
}
if len(v["jwt"]) != 1 || len(v["jwt"][0]) == 0 {
return "", fmt.Errorf("JWT not provided")
}
encodedJWT = v["jwt"][0]
default:
return "", fmt.Errorf("JWT not provided")
}
var opts []jwt.ParserOption
if m.JWTIssuer != "" {
opts = append(opts, jwt.WithIssuer(m.JWTIssuer))
}
if m.JWTAudience != "" {
opts = append(opts, jwt.WithAudience(m.JWTAudience))
}
var cc jwtClaims
cc.permissionsKey = m.JWTClaimKey
_, err = jwt.ParseWithClaims(encodedJWT, &cc, keyfunc, opts...)
if err != nil {
return "", err
}
if !matchesPermission(cc.permissions, req) {
return "", fmt.Errorf("user doesn't have permission to perform action")
}
return cc.Subject, nil
}
func (m *Manager) pullJWTJWKS() (jwt.Keyfunc, error) {
now := time.Now()
m.mutex.Lock()
defer m.mutex.Unlock()
if now.Sub(m.jwksLastRefresh) >= jwksRefreshPeriod {
u, err := url.Parse(m.JWTJWKS)
if err != nil {
return nil, err
}
tr := &http.Transport{
TLSClientConfig: tls.MakeConfig(u.Hostname(), m.JWTJWKSFingerprint),
}
defer tr.CloseIdleConnections()
httpClient := &http.Client{
Timeout: (m.ReadTimeout),
Transport: tr,
}
res, err := httpClient.Get(m.JWTJWKS)
if err != nil {
return nil, err
}
defer res.Body.Close()
var raw json.RawMessage
err = json.NewDecoder(res.Body).Decode(&raw)
if err != nil {
return nil, err
}
tmp, err := keyfunc.NewJWKSetJSON(raw)
if err != nil {
return nil, err
}
m.jwtKeyFunc = tmp
m.jwksLastRefresh = now
}
return m.jwtKeyFunc.Keyfunc, nil
}
// RefreshJWTJWKS refreshes the JWT JWKS.
func (m *Manager) RefreshJWTJWKS() {
m.mutex.Lock()
defer m.mutex.Unlock()
m.jwksLastRefresh = time.Time{}
}
================================================
FILE: internal/auth/manager_test.go
================================================
package auth
import (
"context"
"crypto/rand"
"crypto/rsa"
"crypto/tls"
"encoding/json"
"net"
"net/http"
"testing"
"time"
"github.com/MicahParks/jwkset"
"github.com/bluenviron/mediamtx/internal/conf"
"github.com/golang-jwt/jwt/v5"
"github.com/stretchr/testify/require"
)
var testTLSCertPub = []byte(`-----BEGIN CERTIFICATE-----
MIIDazCCAlOgAwIBAgIUXw1hEC3LFpTsllv7D3ARJyEq7sIwDQYJKoZIhvcNAQEL
BQAwRTELMAkGA1UEBhMCQVUxEzARBgNVBAgMClNvbWUtU3RhdGUxITAfBgNVBAoM
GEludGVybmV0IFdpZGdpdHMgUHR5IEx0ZDAeFw0yMDEyMTMxNzQ0NThaFw0zMDEy
MTExNzQ0NThaMEUxCzAJBgNVBAYTAkFVMRMwEQYDVQQIDApTb21lLVN0YXRlMSEw
HwYDVQQKDBhJbnRlcm5ldCBXaWRnaXRzIFB0eSBMdGQwggEiMA0GCSqGSIb3DQEB
AQUAA4IBDwAwggEKAoIBAQDG8DyyS51810GsGwgWr5rjJK7OE1kTTLSNEEKax8Bj
zOyiaz8rA2JGl2VUEpi2UjDr9Cm7nd+YIEVs91IIBOb7LGqObBh1kGF3u5aZxLkv
NJE+HrLVvUhaDobK2NU+Wibqc/EI3DfUkt1rSINvv9flwTFu1qHeuLWhoySzDKEp
OzYxpFhwjVSokZIjT4Red3OtFz7gl2E6OAWe2qoh5CwLYVdMWtKR0Xuw3BkDPk9I
qkQKx3fqv97LPEzhyZYjDT5WvGrgZ1WDAN3booxXF3oA1H3GHQc4m/vcLatOtb8e
nI59gMQLEbnp08cl873bAuNuM95EZieXTHNbwUnq5iybAgMBAAGjUzBRMB0GA1Ud
DgQWBBQBKhJh8eWu0a4au9X/2fKhkFX2vjAfBgNVHSMEGDAWgBQBKhJh8eWu0a4a
u9X/2fKhkFX2vjAPBgNVHRMBAf8EBTADAQH/MA0GCSqGSIb3DQEBCwUAA4IBAQBj
3aCW0YPKukYgVK9cwN0IbVy/D0C1UPT4nupJcy/E0iC7MXPZ9D/SZxYQoAkdptdO
xfI+RXkpQZLdODNx9uvV+cHyZHZyjtE5ENu/i5Rer2cWI/mSLZm5lUQyx+0KZ2Yu
tEI1bsebDK30msa8QSTn0WidW9XhFnl3gRi4wRdimcQapOWYVs7ih+nAlSvng7NI
XpAyRs8PIEbpDDBMWnldrX4TP6EWYUi49gCp8OUDRREKX3l6Ls1vZ02F34yHIt/7
7IV/XSKG096bhW+icKBWV0IpcEsgTzPK1J1hMxgjhzIMxGboAeUU+kidthOob6Sd
XQxaORfgM//NzX9LhUPk
-----END CERTIFICATE-----
`)
var testTLSCertKey = []byte(`-----BEGIN RSA PRIVATE KEY-----
MIIEogIBAAKCAQEAxvA8skudfNdBrBsIFq+a4ySuzhNZE0y0jRBCmsfAY8zsoms/
KwNiRpdlVBKYtlIw6/Qpu53fmCBFbPdSCATm+yxqjmwYdZBhd7uWmcS5LzSRPh6y
1b1IWg6GytjVPlom6nPxCNw31JLda0iDb7/X5cExbtah3ri1oaMkswyhKTs2MaRY
cI1UqJGSI0+EXndzrRc+4JdhOjgFntqqIeQsC2FXTFrSkdF7sNwZAz5PSKpECsd3
6r/eyzxM4cmWIw0+Vrxq4GdVgwDd26KMVxd6ANR9xh0HOJv73C2rTrW/HpyOfYDE
CxG56dPHJfO92wLjbjPeRGYnl0xzW8FJ6uYsmwIDAQABAoIBACi0BKcyQ3HElSJC
kaAao+Uvnzh4yvPg8Nwf5JDIp/uDdTMyIEWLtrLczRWrjGVZYbsVROinP5VfnPTT
kYwkfKINj2u+gC6lsNuPnRuvHXikF8eO/mYvCTur1zZvsQnF5kp4GGwIqr+qoPUP
bB0UMndG1PdpoMryHe+JcrvTrLHDmCeH10TqOwMsQMLHYLkowvxwJWsmTY7/Qr5S
Wm3PPpOcW2i0uyPVuyuv4yD1368fqnqJ8QFsQp1K6QtYsNnJ71Hut1/IoxK/e6hj
5Z+byKtHVtmcLnABuoOT7BhleJNFBksX9sh83jid4tMBgci+zXNeGmgqo2EmaWAb
agQslkECgYEA8B1rzjOHVQx/vwSzDa4XOrpoHQRfyElrGNz9JVBvnoC7AorezBXQ
M9WTHQIFTGMjzD8pb+YJGi3gj93VN51r0SmJRxBaBRh1ZZI9kFiFzngYev8POgD3
ygmlS3kTHCNxCK/CJkB+/jMBgtPj5ygDpCWVcTSuWlQFphePkW7jaaECgYEA1Blz
ulqgAyJHZaqgcbcCsI2q6m527hVr9pjzNjIVmkwu38yS9RTCgdlbEVVDnS0hoifl
+jVMEGXjF3xjyMvL50BKbQUH+KAa+V4n1WGlnZOxX9TMny8MBjEuSX2+362vQ3BX
4vOlX00gvoc+sY+lrzvfx/OdPCHQGVYzoKCxhLsCgYA07HcviuIAV/HsO2/vyvhp
xF5gTu+BqNUHNOZDDDid+ge+Jre2yfQLCL8VPLXIQW3Jff53IH/PGl+NtjphuLvj
7UDJvgvpZZuymIojP6+2c3gJ3CASC9aR3JBnUzdoE1O9s2eaoMqc4scpe+SWtZYf
3vzSZ+cqF6zrD/Rf/M35IQKBgHTU4E6ShPm09CcoaeC5sp2WK8OevZw/6IyZi78a
r5Oiy18zzO97U/k6xVMy6F+38ILl/2Rn31JZDVJujniY6eSkIVsUHmPxrWoXV1HO
y++U32uuSFiXDcSLarfIsE992MEJLSAynbF1Rsgsr3gXbGiuToJRyxbIeVy7gwzD
94TpAoGAY4/PejWQj9psZfAhyk5dRGra++gYRQ/gK1IIc1g+Dd2/BxbT/RHr05GK
6vwrfjsoRyMWteC1SsNs/CurjfQ/jqCfHNP5XPvxgd5Ec8sRJIiV7V5RTuWJsPu1
+3K6cnKEyg+0ekYmLertRFIY6SwWmY1fyKgTvxudMcsBY7dC4xs=
-----END RSA PRIVATE KEY-----
`)
func mustParseCIDR(v string) conf.IPNetwork {
_, ne, err := net.ParseCIDR(v)
if err != nil {
panic(err)
}
if ipv4 := ne.IP.To4(); ipv4 != nil {
return conf.IPNetwork{IP: ipv4, Mask: ne.Mask[len(ne.Mask)-4 : len(ne.Mask)]}
}
return conf.IPNetwork(*ne)
}
func TestAuthInternal(t *testing.T) {
for _, outcome := range []string{
"ok",
"wrong user",
"wrong pass",
"wrong ip",
"wrong action",
"wrong path",
} {
for _, encryption := range []string{
"plain",
"sha256",
"argon2",
} {
t.Run(outcome+" "+encryption, func(t *testing.T) {
m := Manager{
Method: conf.AuthMethodInternal,
InternalUsers: []conf.AuthInternalUser{
{
IPs: conf.IPNetworks{mustParseCIDR("127.1.1.1/32")},
Permissions: []conf.AuthInternalUserPermission{{
Action: conf.AuthActionPublish,
Path: "mypath",
}},
},
},
}
switch encryption {
case "plain":
m.InternalUsers[0].User = conf.Credential("testuser")
m.InternalUsers[0].Pass = conf.Credential("testpass")
case "sha256":
m.InternalUsers[0].User = conf.Credential("sha256:rl3rgi4NcZkpAEcacZnQ2VuOfJ0FxAqCRaKB/SwdZoQ=")
m.InternalUsers[0].Pass = conf.Credential("sha256:E9JJ8stBJ7QM+nV4ZoUCeHk/gU3tPFh/5YieiJp6n2w=")
case "argon2":
m.InternalUsers[0].User = conf.Credential(
"argon2:$argon2id$v=19$m=4096,t=3,p=1$MTIzNDU2Nzg$Ux/LWeTgJQPyfMMJo1myR64+o8rALHoPmlE1i/TR+58")
m.InternalUsers[0].Pass = conf.Credential(
"argon2:$argon2i$v=19$m=4096,t=3,p=1$MTIzNDU2Nzg$/mrZ42TiTv1mcPnpMUera5oi0SFYbbyueAbdx5sUvWo")
}
var req *Request
switch outcome {
case "ok":
req = &Request{
Action: conf.AuthActionPublish,
Path: "mypath",
Credentials: &Credentials{
User: "testuser",
Pass: "testpass",
},
IP: net.ParseIP("127.1.1.1"),
}
case "wrong user":
req = &Request{
Action: conf.AuthActionPublish,
Path: "mypath",
Credentials: &Credentials{
User: "wrong",
Pass: "testpass",
},
IP: net.ParseIP("127.1.1.1"),
}
case "wrong pass":
req = &Request{
Action: conf.AuthActionPublish,
Path: "mypath",
Credentials: &Credentials{
User: "testuser",
Pass: "wrong",
},
IP: net.ParseIP("127.1.1.1"),
}
case "wrong ip":
req = &Request{
Action: conf.AuthActionPublish,
Path: "mypath",
Credentials: &Credentials{
User: "testuser",
Pass: "testpass",
},
IP: net.ParseIP("127.1.1.2"),
}
case "wrong action":
req = &Request{
Action: conf.AuthActionRead,
Path: "mypath",
Credentials: &Credentials{
User: "testuser",
Pass: "testpass",
},
IP: net.ParseIP("127.1.1.1"),
}
case "wrong path":
req = &Request{
Action: conf.AuthActionPublish,
Path: "wrong",
Credentials: &Credentials{
User: "testuser",
Pass: "testpass",
},
IP: net.ParseIP("127.1.1.1"),
}
}
// first request with empty credentials
_, err := m.Authenticate(&Request{
Action: req.Action,
Path: req.Path,
Credentials: &Credentials{},
IP: req.IP,
})
require.Equal(t, &Error{
Wrapped: err.Wrapped,
AskCredentials: true,
}, err)
// second request
user, err := m.Authenticate(req)
if outcome == "ok" {
require.Nil(t, err)
require.Equal(t, "testuser", user)
} else {
require.EqualError(t, err.Wrapped, "authentication failed")
require.False(t, err.AskCredentials)
}
})
}
}
}
func TestAuthInternalCustomVerifyFunc(t *testing.T) {
for _, ca := range []string{"ok", "invalid"} {
t.Run(ca, func(t *testing.T) {
m := Manager{
Method: conf.AuthMethodInternal,
InternalUsers: []conf.AuthInternalUser{
{
User: "myuser",
Pass: "mypass",
IPs: conf.IPNetworks{mustParseCIDR("127.1.1.1/32")},
Permissions: []conf.AuthInternalUserPermission{{
Action: conf.AuthActionPublish,
Path: "mypath",
}},
},
},
}
req1 := &Request{
Action: conf.AuthActionPublish,
Path: "mypath",
Credentials: &Credentials{
User: "myuser",
},
IP: net.ParseIP("127.1.1.1"),
CustomVerifyFunc: func(expectedUser, expectedPass string) bool {
require.Equal(t, "myuser", expectedUser)
require.Equal(t, "mypass", expectedPass)
return (ca == "ok")
},
}
user, err := m.Authenticate(req1)
if ca == "ok" {
require.Nil(t, err)
require.Equal(t, "myuser", user)
} else {
require.EqualError(t, err.Wrapped, "authentication failed")
}
})
}
}
func TestAuthHTTP(t *testing.T) {
for _, outcome := range []string{"ok", "fail"} {
t.Run(outcome, func(t *testing.T) {
firstReceived := false
httpServ := &http.Server{
Handler: http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
require.Equal(t, http.MethodPost, r.Method)
require.Equal(t, "/auth", r.URL.Path)
var in struct {
IP string `json:"ip"`
User string `json:"user"`
Password string `json:"password"`
Path string `json:"path"`
Protocol string `json:"protocol"`
ID string `json:"id"`
Action string `json:"action"`
Query string `json:"query"`
}
err := json.NewDecoder(r.Body).Decode(&in)
require.NoError(t, err)
if in.IP != "127.0.0.1" ||
in.User != "testpublisher" ||
in.Password != "testpass" ||
in.Path != "teststream" ||
in.Protocol != "rtsp" ||
(firstReceived && in.ID == "") ||
in.Action != "publish" ||
(in.Query != "user=testreader&pass=testpass¶m=value" &&
in.Query != "user=testpublisher&pass=testpass¶m=value" &&
in.Query != "param=value") {
w.WriteHeader(http.StatusBadRequest)
return
}
firstReceived = true
}),
}
ln, err := net.Listen("tcp", "127.0.0.1:9120")
require.NoError(t, err)
go httpServ.Serve(ln)
defer httpServ.Shutdown(context.Background())
m := Manager{
Method: conf.AuthMethodHTTP,
HTTPAddress: "http://127.0.0.1:9120/auth",
}
var req *Request
if outcome == "ok" {
req = &Request{
Action: conf.AuthActionPublish,
Path: "teststream",
Query: "param=value",
Protocol: ProtocolRTSP,
Credentials: &Credentials{
User: "testpublisher",
Pass: "testpass",
},
IP: net.ParseIP("127.0.0.1"),
}
} else {
req = &Request{
Action: conf.AuthActionPublish,
Path: "teststream",
Query: "param=value",
Protocol: ProtocolRTSP,
Credentials: &Credentials{
User: "invalid",
Pass: "testpass",
},
IP: net.ParseIP("127.0.0.1"),
}
}
// first request with empty credentials
_, err2 := m.Authenticate(&Request{
Action: req.Action,
Path: req.Path,
Credentials: &Credentials{},
IP: req.IP,
})
require.Equal(t, &Error{
Wrapped: err2.Wrapped,
AskCredentials: true,
}, err2)
// second request
user, err2 := m.Authenticate(req)
if outcome == "ok" {
require.Nil(t, err2)
require.Equal(t, "testpublisher", user)
} else {
require.EqualError(t, err2.Wrapped, "server replied with code 400")
require.False(t, err2.AskCredentials)
}
})
}
}
func TestAuthHTTPFingerprint(t *testing.T) {
httpServ := &http.Server{
Handler: http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
require.Equal(t, http.MethodPost, r.Method)
require.Equal(t, "/auth", r.URL.Path)
var in struct {
IP string `json:"ip"`
User string `json:"user"`
Password string `json:"password"`
Path string `json:"path"`
Protocol string `json:"protocol"`
ID string `json:"id"`
Action string `json:"action"`
Query string `json:"query"`
}
err := json.NewDecoder(r.Body).Decode(&in)
require.NoError(t, err)
if in.User != "testuser" || in.Password != "testpass" {
w.WriteHeader(http.StatusBadRequest)
return
}
}),
}
ln, err := net.Listen("tcp", "localhost:9121")
require.NoError(t, err)
cert, err := tls.X509KeyPair(testTLSCertPub, testTLSCertKey)
require.NoError(t, err)
httpServ.TLSConfig = &tls.Config{Certificates: []tls.Certificate{cert}}
go httpServ.ServeTLS(ln, "", "")
defer httpServ.Shutdown(context.Background())
m := Manager{
Method: conf.AuthMethodHTTP,
HTTPAddress: "https://localhost:9121/auth",
HTTPFingerprint: "33949e05fffb5ff3e8aa16f8213a6251b4d9363804ba53233c4da9a46d6f2739",
}
user, err2 := m.Authenticate(&Request{
Action: conf.AuthActionPublish,
Path: "teststream",
Protocol: ProtocolRTSP,
Credentials: &Credentials{
User: "testuser",
Pass: "testpass",
},
IP: net.ParseIP("127.0.0.1"),
})
require.Nil(t, err2)
require.Equal(t, "testuser", user)
}
func TestAuthHTTPExclude(t *testing.T) {
m := Manager{
Method: conf.AuthMethodHTTP,
HTTPAddress: "http://not-to-be-used:9120/auth",
HTTPExclude: []conf.AuthInternalUserPermission{{
Action: conf.AuthActionPublish,
}},
}
user, err := m.Authenticate(&Request{
Action: conf.AuthActionPublish,
Path: "teststream",
Query: "param=value",
Protocol: ProtocolRTSP,
Credentials: &Credentials{
User: "",
Pass: "",
},
IP: net.ParseIP("127.0.0.1"),
})
require.Nil(t, err)
require.Equal(t, "", user)
}
func TestAuthJWT(t *testing.T) {
for _, ca := range []string{"object", "string"} {
t.Run(ca, func(t *testing.T) {
// reference:
// https://github.com/MicahParks/jwkset/blob/master/examples/http_server/main.go
key, err := rsa.GenerateKey(rand.Reader, 1024)
require.NoError(t, err)
httpServ := &http.Server{
Handler: http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
jwk, err2 := jwkset.NewJWKFromKey(key, jwkset.JWKOptions{
Metadata: jwkset.JWKMetadataOptions{
KID: "test-key-id",
},
})
require.NoError(t, err2)
jwkSet := jwkset.NewMemoryStorage()
err2 = jwkSet.KeyWrite(context.Background(), jwk)
require.NoError(t, err2)
response, err2 := jwkSet.JSONPublic(r.Context())
if err2 != nil {
w.WriteHeader(http.StatusInternalServerError)
return
}
w.Header().Set("Content-Type", "application/json")
_, _ = w.Write(response)
}),
}
ln, err := net.Listen("tcp", "localhost:4567")
require.NoError(t, err)
go httpServ.Serve(ln)
defer httpServ.Shutdown(context.Background())
var req *Request
if ca == "object" {
type customClaims struct {
jwt.RegisteredClaims
MediaMTXPermissions string `json:"my_permission_key"`
}
var enc []byte
enc, err = json.Marshal([]conf.AuthInternalUserPermission{{
Action: conf.AuthActionPublish,
Path: "mypath",
}})
require.NoError(t, err)
claims := customClaims{
RegisteredClaims: jwt.RegisteredClaims{
ExpiresAt: jwt.NewNumericDate(time.Now().Add(24 * time.Hour)),
IssuedAt: jwt.NewNumericDate(time.Now()),
NotBefore: jwt.NewNumericDate(time.Now()),
Issuer: "test",
Subject: "somebody",
ID: "1",
},
MediaMTXPermissions: string(enc),
}
token := jwt.NewWithClaims(jwt.SigningMethodRS256, claims)
token.Header[jwkset.HeaderKID] = "test-key-id"
var ss string
ss, err = token.SignedString(key)
require.NoError(t, err)
req = &Request{
Action: conf.AuthActionPublish,
Path: "mypath",
Query: "param=value",
Protocol: ProtocolRTSP,
Credentials: &Credentials{
Token: ss,
},
IP: net.ParseIP("127.0.0.1"),
}
} else {
type customClaims struct {
jwt.RegisteredClaims
MediaMTXPermissions []conf.AuthInternalUserPermission `json:"my_permission_key"`
}
claims := customClaims{
RegisteredClaims: jwt.RegisteredClaims{
ExpiresAt: jwt.NewNumericDate(time.Now().Add(24 * time.Hour)),
IssuedAt: jwt.NewNumericDate(time.Now()),
NotBefore: jwt.NewNumericDate(time.Now()),
Issuer: "test",
Subject: "somebody",
ID: "1",
},
MediaMTXPermissions: []conf.AuthInternalUserPermission{{
Action: conf.AuthActionPublish,
Path: "mypath",
}},
}
token := jwt.NewWithClaims(jwt.SigningMethodRS256, claims)
token.Header[jwkset.HeaderKID] = "test-key-id"
var ss string
ss, err = token.SignedString(key)
require.NoError(t, err)
req = &Request{
Action: conf.AuthActionPublish,
Path: "mypath",
Protocol: ProtocolWebRTC,
Credentials: &Credentials{
Token: ss,
},
IP: net.ParseIP("127.0.0.1"),
}
}
m := Manager{
Method: conf.AuthMethodJWT,
JWTJWKS: "http://localhost:4567/jwks",
JWTClaimKey: "my_permission_key",
}
// first request with empty credentials
_, err2 := m.Authenticate(&Request{
Action: req.Action,
Path: req.Path,
Credentials: &Credentials{},
IP: req.IP,
})
require.Equal(t, &Error{
Wrapped: err2.Wrapped,
AskCredentials: true,
}, err2)
// second request
user, err2 := m.Authenticate(req)
require.Nil(t, err2)
require.Equal(t, "somebody", user)
})
}
}
func TestAuthJWTExclude(t *testing.T) {
m := Manager{
Method: conf.AuthMethodJWT,
JWTJWKS: "http://localhost:4567/jwks",
JWTClaimKey: "my_permission_key",
JWTExclude: []conf.AuthInternalUserPermission{{
Action: conf.AuthActionPublish,
}},
}
user, err := m.Authenticate(&Request{
Action: conf.AuthActionPublish,
Path: "teststream",
Query: "param=value",
Protocol: ProtocolRTSP,
IP: net.ParseIP("127.0.0.1"),
})
require.Nil(t, err)
require.Equal(t, "", user)
}
func TestAuthJWTIssuer(t *testing.T) {
key, err := rsa.GenerateKey(rand.Reader, 1024)
require.NoError(t, err)
httpServ := &http.Server{
Handler: http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
jwk, err2 := jwkset.NewJWKFromKey(key, jwkset.JWKOptions{
Metadata: jwkset.JWKMetadataOptions{
KID: "test-key-id",
},
})
require.NoError(t, err2)
jwkSet := jwkset.NewMemoryStorage()
err2 = jwkSet.KeyWrite(context.Background(), jwk)
require.NoError(t, err2)
response, err2 := jwkSet.JSONPublic(r.Context())
if err2 != nil {
w.WriteHeader(http.StatusInternalServerError)
return
}
w.Header().Set("Content-Type", "application/json")
_, _ = w.Write(response)
}),
}
ln, err := net.Listen("tcp", "localhost:4568")
require.NoError(t, err)
go httpServ.Serve(ln)
defer httpServ.Shutdown(context.Background())
for _, ca := range []struct {
name string
jwtIssuer string
tokenIss string
expectErr bool
}{
{
name: "matching",
jwtIssuer: "my-issuer",
tokenIss: "my-issuer",
expectErr: false,
},
{
name: "mismatched",
jwtIssuer: "my-issuer",
tokenIss: "wrong-issuer",
expectErr: true,
},
} {
t.Run(ca.name, func(t *testing.T) {
signToken := func(issuer string) string {
type customClaims struct {
jwt.RegisteredClaims
MediaMTXPermissions []conf.AuthInternalUserPermission `json:"my_permission_key"`
}
claims := customClaims{
RegisteredClaims: jwt.RegisteredClaims{
ExpiresAt: jwt.NewNumericDate(time.Now().Add(24 * time.Hour)),
IssuedAt: jwt.NewNumericDate(time.Now()),
NotBefore: jwt.NewNumericDate(time.Now()),
Issuer: issuer,
},
MediaMTXPermissions: []conf.AuthInternalUserPermission{{
Action: conf.AuthActionPublish,
Path: "mypath",
}},
}
token := jwt.NewWithClaims(jwt.SigningMethodRS256, claims)
token.Header[jwkset.HeaderKID] = "test-key-id"
var ss string
ss, err = token.SignedString(key)
require.NoError(t, err)
return ss
}
ss := signToken(ca.tokenIss)
m := Manager{
Method: conf.AuthMethodJWT,
JWTJWKS: "http://localhost:4568/jwks",
JWTClaimKey: "my_permission_key",
JWTIssuer: ca.jwtIssuer,
}
_, err := m.Authenticate(&Request{
Action: conf.AuthActionPublish,
Path: "mypath",
Protocol: ProtocolRTSP,
Credentials: &Credentials{
Token: ss,
},
IP: net.ParseIP("127.0.0.1"),
})
if ca.expectErr {
require.NotNil(t, err)
} else {
require.Nil(t, err)
}
})
}
}
func TestAuthJWTAudience(t *testing.T) {
key, err := rsa.GenerateKey(rand.Reader, 1024)
require.NoError(t, err)
httpServ := &http.Server{
Handler: http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
jwk, err2 := jwkset.NewJWKFromKey(key, jwkset.JWKOptions{
Metadata: jwkset.JWKMetadataOptions{
KID: "test-key-id",
},
})
require.NoError(t, err2)
jwkSet := jwkset.NewMemoryStorage()
err2 = jwkSet.KeyWrite(context.Background(), jwk)
require.NoError(t, err2)
response, err2 := jwkSet.JSONPublic(r.Context())
if err2 != nil {
w.WriteHeader(http.StatusInternalServerError)
return
}
w.Header().Set("Content-Type", "application/json")
_, _ = w.Write(response)
}),
}
ln, err := net.Listen("tcp", "localhost:4569")
require.NoError(t, err)
go httpServ.Serve(ln)
defer httpServ.Shutdown(context.Background())
for _, ca := range []struct {
name string
jwtAudience string
tokenAud jwt.ClaimStrings
expectErr bool
}{
{
name: "matching",
jwtAudience: "my-audience",
tokenAud: jwt.ClaimStrings{"my-audience"},
expectErr: false,
},
{
name: "mismatched",
jwtAudience: "my-audience",
tokenAud: jwt.ClaimStrings{"wrong-audience"},
expectErr: true,
},
{
name: "present in list",
jwtAudience: "my-audience",
tokenAud: jwt.ClaimStrings{"other", "my-audience"},
expectErr: false,
},
} {
t.Run(ca.name, func(t *testing.T) {
signToken := func(audience jwt.ClaimStrings) string {
type customClaims struct {
jwt.RegisteredClaims
MediaMTXPermissions []conf.AuthInternalUserPermission `json:"my_permission_key"`
}
claims := customClaims{
RegisteredClaims: jwt.RegisteredClaims{
ExpiresAt: jwt.NewNumericDate(time.Now().Add(24 * time.Hour)),
IssuedAt: jwt.NewNumericDate(time.Now()),
NotBefore: jwt.NewNumericDate(time.Now()),
Audience: audience,
},
MediaMTXPermissions: []conf.AuthInternalUserPermission{{
Action: conf.AuthActionPublish,
Path: "mypath",
}},
}
token := jwt.NewWithClaims(jwt.SigningMethodRS256, claims)
token.Header[jwkset.HeaderKID] = "test-key-id"
var ss string
ss, err = token.SignedString(key)
require.NoError(t, err)
return ss
}
ss := signToken(ca.tokenAud)
m := Manager{
Method: conf.AuthMethodJWT,
JWTJWKS: "http://localhost:4569/jwks",
JWTClaimKey: "my_permission_key",
JWTAudience: ca.jwtAudience,
}
_, err := m.Authenticate(&Request{
Action: conf.AuthActionPublish,
Path: "mypath",
Protocol: ProtocolRTSP,
Credentials: &Credentials{
Token: ss,
},
IP: net.ParseIP("127.0.0.1"),
})
if ca.expectErr {
require.NotNil(t, err)
} else {
require.Nil(t, err)
}
})
}
}
func TestAuthJWTRefresh(t *testing.T) {
// reference:
// https://github.com/MicahParks/jwkset/blob/master/examples/http_server/main.go
var key *rsa.PrivateKey
httpServ := &http.Server{
Handler: http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
jwk, err := jwkset.NewJWKFromKey(key, jwkset.JWKOptions{
Metadata: jwkset.JWKMetadataOptions{
KID: "test-key-id",
},
})
require.NoError(t, err)
jwkSet := jwkset.NewMemoryStorage()
err = jwkSet.KeyWrite(context.Background(), jwk)
require.NoError(t, err)
response, err2 := jwkSet.JSONPublic(r.Context())
if err2 != nil {
w.WriteHeader(http.StatusInternalServerError)
return
}
w.Header().Set("Content-Type", "application/json")
_, _ = w.Write(response)
}),
}
ln, err := net.Listen("tcp", "localhost:4567")
require.NoError(t, err)
go httpServ.Serve(ln)
defer httpServ.Shutdown(context.Background())
m := Manager{
Method: conf.AuthMethodJWT,
JWTJWKS: "http://localhost:4567/jwks",
JWTClaimKey: "my_permission_key",
}
for range 2 {
key, err = rsa.GenerateKey(rand.Reader, 1024)
require.NoError(t, err)
type customClaims struct {
jwt.RegisteredClaims
MediaMTXPermissions []conf.AuthInternalUserPermission `json:"my_permission_key"`
}
claims := customClaims{
RegisteredClaims: jwt.RegisteredClaims{
ExpiresAt: jwt.NewNumericDate(time.Now().Add(24 * time.Hour)),
IssuedAt: jwt.NewNumericDate(time.Now()),
NotBefore: jwt.NewNumericDate(time.Now()),
Issuer: "test",
Subject: "somebody",
ID: "1",
},
MediaMTXPermissions: []conf.AuthInternalUserPermission{{
Action: conf.AuthActionPublish,
Path: "mypath",
}},
}
token := jwt.NewWithClaims(jwt.SigningMethodRS256, claims)
token.Header[jwkset.HeaderKID] = "test-key-id"
var ss string
ss, err = token.SignedString(key)
require.NoError(t, err)
user, err2 := m.Authenticate(&Request{
Action: conf.AuthActionPublish,
Path: "mypath",
Query: "param=value",
Protocol: ProtocolRTSP,
Credentials: &Credentials{
Token: ss,
},
IP: net.ParseIP("127.0.0.1"),
})
require.Nil(t, err2)
require.Equal(t, "somebody", user)
m.RefreshJWTJWKS()
}
}
func TestAuthJWTFingerprint(t *testing.T) {
key, err := rsa.GenerateKey(rand.Reader, 1024)
require.NoError(t, err)
httpServ := &http.Server{
Handler: http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
jwk, err2 := jwkset.NewJWKFromKey(key, jwkset.JWKOptions{
Metadata: jwkset.JWKMetadataOptions{
KID: "test-key-id",
},
})
require.NoError(t, err2)
jwkSet := jwkset.NewMemoryStorage()
err2 = jwkSet.KeyWrite(context.Background(), jwk)
require.NoError(t, err2)
response, err2 := jwkSet.JSONPublic(r.Context())
if err2 != nil {
w.WriteHeader(http.StatusInternalServerError)
return
}
w.Header().Set("Content-Type", "application/json")
_, _ = w.Write(response)
}),
}
ln, err := net.Listen("tcp", "localhost:4568")
require.NoError(t, err)
cert, err := tls.X509KeyPair(testTLSCertPub, testTLSCertKey)
require.NoError(t, err)
httpServ.TLSConfig = &tls.Config{Certificates: []tls.Certificate{cert}}
go httpServ.ServeTLS(ln, "", "")
defer httpServ.Shutdown(context.Background())
type customClaims struct {
jwt.RegisteredClaims
MediaMTXPermissions []conf.AuthInternalUserPermission `json:"my_permission_key"`
}
claims := customClaims{
RegisteredClaims: jwt.RegisteredClaims{
ExpiresAt: jwt.NewNumericDate(time.Now().Add(24 * time.Hour)),
IssuedAt: jwt.NewNumericDate(time.Now()),
NotBefore: jwt.NewNumericDate(time.Now()),
Issuer: "test",
Subject: "somebody",
ID: "1",
},
MediaMTXPermissions: []conf.AuthInternalUserPermission{{
Action: conf.AuthActionPublish,
Path: "mypath",
}},
}
token := jwt.NewWithClaims(jwt.SigningMethodRS256, claims)
token.Header[jwkset.HeaderKID] = "test-key-id"
ss, err := token.SignedString(key)
require.NoError(t, err)
m := Manager{
Method: conf.AuthMethodJWT,
JWTJWKS: "https://localhost:4568/jwks",
JWTJWKSFingerprint: "33949e05fffb5ff3e8aa16f8213a6251b4d9363804ba53233c4da9a46d6f2739",
JWTClaimKey: "my_permission_key",
}
user, err2 := m.Authenticate(&Request{
Action: conf.AuthActionPublish,
Path: "mypath",
Protocol: ProtocolRTSP,
Credentials: &Credentials{
Token: ss,
},
IP: net.ParseIP("127.0.0.1"),
})
require.Nil(t, err2)
require.Equal(t, "somebody", user)
}
================================================
FILE: internal/auth/request.go
================================================
package auth
import (
"net"
"github.com/bluenviron/mediamtx/internal/conf"
"github.com/google/uuid"
)
// Protocol is a protocol.
type Protocol string
// protocols.
const (
ProtocolRTSP Protocol = "rtsp"
ProtocolRTMP Protocol = "rtmp"
ProtocolHLS Protocol = "hls"
ProtocolWebRTC Protocol = "webrtc"
ProtocolSRT Protocol = "srt"
)
// Request is an authentication request.
type Request struct {
Action conf.AuthAction
Path string // only for ActionPublish, ActionRead, ActionPlayback
Query string
Protocol Protocol // only for ActionPublish, ActionRead
ID *uuid.UUID // only for ActionPublish, ActionRead
Credentials *Credentials
IP net.IP
CustomVerifyFunc func(expectedUser string, expectedPass string) bool
}
================================================
FILE: internal/certloader/certloader.go
================================================
// Package certloader contains a certicate loader.
package certloader
import (
"crypto/tls"
"sync"
"github.com/bluenviron/mediamtx/internal/confwatcher"
"github.com/bluenviron/mediamtx/internal/logger"
)
// CertLoader is a certificate loader. It watches for changes to the certificate and key files.
type CertLoader struct {
CertPath string
KeyPath string
Parent logger.Writer
certWatcher, keyWatcher *confwatcher.ConfWatcher
cert *tls.Certificate
certMu sync.RWMutex
done chan struct{}
}
// Initialize initializes a CertLoader.
func (cl *CertLoader) Initialize() error {
cl.done = make(chan struct{})
cl.certWatcher = &confwatcher.ConfWatcher{FilePath: cl.CertPath}
err := cl.certWatcher.Initialize()
if err != nil {
return err
}
cl.keyWatcher = &confwatcher.ConfWatcher{FilePath: cl.KeyPath}
err = cl.keyWatcher.Initialize()
if err != nil {
cl.certWatcher.Close() //nolint:errcheck
return err
}
cert, err := tls.LoadX509KeyPair(cl.CertPath, cl.KeyPath)
if err != nil {
return err
}
cl.certMu.Lock()
cl.cert = &cert
cl.certMu.Unlock()
go cl.watch()
return nil
}
// Close closes a CertLoader and releases any underlying resources.
func (cl *CertLoader) Close() {
close(cl.done)
cl.certWatcher.Close() //nolint:errcheck
cl.keyWatcher.Close() //nolint:errcheck
cl.certMu.Lock()
defer cl.certMu.Unlock()
cl.cert = nil
}
// GetCertificate returns a function that returns the certificate for use in a tls.Config.
func (cl *CertLoader) GetCertificate() func(*tls.ClientHelloInfo) (*tls.Certificate, error) {
return func(_ *tls.ClientHelloInfo) (*tls.Certificate, error) {
cl.certMu.RLock()
defer cl.certMu.RUnlock()
return cl.cert, nil
}
}
func (cl *CertLoader) watch() {
for {
select {
case <-cl.certWatcher.Watch():
cert, err := tls.LoadX509KeyPair(cl.CertPath, cl.KeyPath)
if err != nil {
cl.Parent.Log(logger.Error, "certloader failed to load after change to %s: %s", cl.CertPath, err.Error())
continue
}
cl.certMu.Lock()
cl.cert = &cert
cl.certMu.Unlock()
cl.Parent.Log(logger.Info, "certificate reloaded after change to %s", cl.CertPath)
case <-cl.keyWatcher.Watch():
cert, err := tls.LoadX509KeyPair(cl.CertPath, cl.KeyPath)
if err != nil {
cl.Parent.Log(logger.Error, "certloader failed to load after change to %s: %s", cl.KeyPath, err.Error())
continue
}
cl.certMu.Lock()
cl.cert = &cert
cl.certMu.Unlock()
cl.Parent.Log(logger.Info, "certificate reloaded after change to %s", cl.KeyPath)
case <-cl.done:
return
}
}
}
================================================
FILE: internal/certloader/certloader_test.go
================================================
package certloader
import (
"crypto/tls"
"os"
"testing"
"time"
"github.com/bluenviron/mediamtx/internal/test"
"github.com/stretchr/testify/require"
)
func TestCertReload(t *testing.T) {
testData, err := tls.X509KeyPair(test.TLSCertPub, test.TLSCertKey)
require.NoError(t, err)
serverCertPath, err := test.CreateTempFile(test.TLSCertPub)
require.NoError(t, err)
defer os.Remove(serverCertPath)
serverKeyPath, err := test.CreateTempFile(test.TLSCertKey)
require.NoError(t, err)
defer os.Remove(serverKeyPath)
loader := &CertLoader{
CertPath: serverCertPath,
KeyPath: serverKeyPath,
Parent: test.NilLogger,
}
err = loader.Initialize()
require.NoError(t, err)
defer loader.Close()
getCert := loader.GetCertificate()
require.NotNil(t, getCert)
cert, err := getCert(nil)
require.NoError(t, err)
require.NotNil(t, cert)
require.Equal(t, &testData, cert)
testData, err = tls.X509KeyPair(test.TLSCertPubAlt, test.TLSCertKeyAlt)
require.NoError(t, err)
err = os.WriteFile(serverCertPath, test.TLSCertPubAlt, 0o644)
require.NoError(t, err)
err = os.WriteFile(serverKeyPath, test.TLSCertKeyAlt, 0o644)
require.NoError(t, err)
time.Sleep(1 * time.Second)
cert, err = getCert(nil)
require.NoError(t, err)
require.NotNil(t, cert)
require.Equal(t, &testData, cert)
}
================================================
FILE: internal/conf/always_available_track.go
================================================
package conf
import (
"fmt"
"github.com/bluenviron/mediamtx/internal/conf/jsonwrapper"
)
// AlwaysAvailableTrack is an item of alwaysAvailableTracks.
type AlwaysAvailableTrack struct {
Codec AlwaysAvailableTrackCodec `json:"codec"`
SampleRate int `json:"sampleRate"`
ChannelCount int `json:"channelCount"`
MULaw bool `json:"muLaw"`
}
// UnmarshalJSON implements json.Unmarshaler.
func (t *AlwaysAvailableTrack) UnmarshalJSON(b []byte) error {
type alias AlwaysAvailableTrack
err := jsonwrapper.Unmarshal(b, (*alias)(t))
if err != nil {
return err
}
switch t.Codec {
case CodecAV1, CodecVP9, CodecH265, CodecH264, CodecOpus:
if t.SampleRate != 0 {
return fmt.Errorf("sampleRate must not be specified for codec '%s'", t.Codec)
}
if t.ChannelCount != 0 {
return fmt.Errorf("channelCount must not be specified for codec '%s'", t.Codec)
}
case CodecMPEG4Audio, CodecG711, CodecLPCM:
if t.SampleRate == 0 {
return fmt.Errorf("sampleRate is mandatory for codec '%s'", t.Codec)
}
if t.ChannelCount == 0 {
return fmt.Errorf("channelCount is mandatory for codec '%s'", t.Codec)
}
default:
return fmt.Errorf("unsupported codec '%s'", t.Codec)
}
return nil
}
================================================
FILE: internal/conf/always_available_track_codec.go
================================================
package conf
import "github.com/bluenviron/mediamtx/internal/conf/jsonwrapper"
// AlwaysAvailableTrackCodec is a codec of AlwaysAvailableTrack.
type AlwaysAvailableTrackCodec string
// available codecs.
const (
CodecAV1 AlwaysAvailableTrackCodec = "AV1"
CodecVP9 AlwaysAvailableTrackCodec = "VP9"
CodecH265 AlwaysAvailableTrackCodec = "H265"
CodecH264 AlwaysAvailableTrackCodec = "H264"
CodecMPEG4Audio AlwaysAvailableTrackCodec = "MPEG4Audio"
CodecOpus AlwaysAvailableTrackCodec = "Opus"
CodecG711 AlwaysAvailableTrackCodec = "G711"
CodecLPCM AlwaysAvailableTrackCodec = "LPCM"
)
// UnmarshalEnv implements env.Unmarshaler.
func (d *AlwaysAvailableTrackCodec) UnmarshalEnv(_ string, v string) error {
return jsonwrapper.Unmarshal([]byte(`"`+v+`"`), d)
}
================================================
FILE: internal/conf/auth_action.go
================================================
package conf
import (
"fmt"
"github.com/bluenviron/mediamtx/internal/conf/jsonwrapper"
)
// AuthAction is an authentication action.
type AuthAction string
// auth actions
const (
AuthActionPublish AuthAction = "publish"
AuthActionRead AuthAction = "read"
AuthActionPlayback AuthAction = "playback"
AuthActionAPI AuthAction = "api"
AuthActionMetrics AuthAction = "metrics"
AuthActionPprof AuthAction = "pprof"
)
// UnmarshalJSON implements json.Unmarshaler.
func (d *AuthAction) UnmarshalJSON(b []byte) error {
var in string
if err := jsonwrapper.Unmarshal(b, &in); err != nil {
return err
}
switch in {
case string(AuthActionPublish),
string(AuthActionRead),
string(AuthActionPlayback),
string(AuthActionAPI),
string(AuthActionMetrics),
string(AuthActionPprof):
*d = AuthAction(in)
default:
return fmt.Errorf("invalid auth action: '%s'", in)
}
return nil
}
// UnmarshalEnv implements env.Unmarshaler.
func (d *AuthAction) UnmarshalEnv(_ string, v string) error {
return d.UnmarshalJSON([]byte(`"` + v + `"`))
}
================================================
FILE: internal/conf/auth_internal_user.go
================================================
package conf
// AuthInternalUser is an user.
type AuthInternalUser struct {
User Credential `json:"user"`
Pass Credential `json:"pass"`
IPs IPNetworks `json:"ips"`
Permissions []AuthInternalUserPermission `json:"permissions"`
}
================================================
FILE: internal/conf/auth_internal_user_permission.go
================================================
package conf
// AuthInternalUserPermission is a permission of a user.
type AuthInternalUserPermission struct {
Action AuthAction `json:"action"`
Path string `json:"path"`
}
================================================
FILE: internal/conf/auth_method.go
================================================
package conf
import (
"fmt"
"github.com/bluenviron/mediamtx/internal/conf/jsonwrapper"
)
// AuthMethod is an authentication method.
type AuthMethod string
// authentication methods.
const (
AuthMethodInternal AuthMethod = "internal"
AuthMethodHTTP AuthMethod = "http"
AuthMethodJWT AuthMethod = "jwt"
)
// UnmarshalJSON implements json.Unmarshaler.
func (d *AuthMethod) UnmarshalJSON(b []byte) error {
type alias AuthMethod
if err := jsonwrapper.Unmarshal(b, (*alias)(d)); err != nil {
return err
}
switch *d {
case AuthMethodInternal, AuthMethodHTTP, AuthMethodJWT:
default:
return fmt.Errorf("invalid authMethod: '%s'", *d)
}
return nil
}
// UnmarshalEnv implements env.Unmarshaler.
func (d *AuthMethod) UnmarshalEnv(_ string, v string) error {
return d.UnmarshalJSON([]byte(`"` + v + `"`))
}
================================================
FILE: internal/conf/conf.go
================================================
// Package conf contains the struct that holds the configuration of the software.
package conf
import (
"errors"
"fmt"
"net"
"os"
"reflect"
"slices"
"sort"
"strings"
"time"
"github.com/bluenviron/gohlslib/v2"
"github.com/bluenviron/gortsplib/v5"
"github.com/bluenviron/gortsplib/v5/pkg/auth"
"github.com/bluenviron/mediamtx/internal/conf/decrypt"
"github.com/bluenviron/mediamtx/internal/conf/env"
"github.com/bluenviron/mediamtx/internal/conf/yamlwrapper"
"github.com/bluenviron/mediamtx/internal/logger"
)
// ErrPathNotFound is returned when a path is not found.
var ErrPathNotFound = errors.New("path not found")
func sortedKeys(paths map[string]*OptionalPath) []string {
ret := make([]string, len(paths))
i := 0
for name := range paths {
ret[i] = name
i++
}
sort.Strings(ret)
return ret
}
func firstThatExists(paths []string) string {
for _, pa := range paths {
_, err := os.Stat(pa)
if err == nil {
return pa
}
}
return ""
}
func setAllNilSlicesToEmptyRecursive(rv reflect.Value) {
if rv.Kind() == reflect.Pointer {
rv = rv.Elem()
}
if rv.Kind() == reflect.Struct {
for i := range rv.NumField() {
field := rv.Field(i)
switch field.Kind() {
case reflect.Slice:
if field.IsNil() {
field.Set(reflect.MakeSlice(field.Type(), 0, 0))
} else {
for j := range field.Len() {
elem := field.Index(j)
if elem.Kind() == reflect.Pointer || elem.Kind() == reflect.Struct {
setAllNilSlicesToEmptyRecursive(elem)
}
}
}
case reflect.Pointer:
if !field.IsNil() {
setAllNilSlicesToEmptyRecursive(field)
}
case reflect.Struct:
setAllNilSlicesToEmptyRecursive(field.Addr())
case reflect.Map:
if !field.IsNil() {
for _, key := range field.MapKeys() {
mapValue := field.MapIndex(key)
if mapValue.Kind() == reflect.Pointer {
setAllNilSlicesToEmptyRecursive(mapValue)
}
}
}
}
}
}
}
func copyStructFields(dest any, source any) {
rvsource := reflect.ValueOf(source).Elem()
rvdest := reflect.ValueOf(dest)
nf := rvsource.NumField()
var zero reflect.Value
for i := range nf {
fnew := rvsource.Field(i)
f := rvdest.Elem().FieldByName(rvsource.Type().Field(i).Name)
if f == zero {
continue
}
if fnew.Kind() == reflect.Pointer {
if !fnew.IsNil() {
if f.Kind() == reflect.Pointer {
f.Set(fnew)
} else {
f.Set(fnew.Elem())
}
}
} else {
f.Set(fnew)
}
}
}
func mustParseCIDR(v string) IPNetwork {
_, ne, err := net.ParseCIDR(v)
if err != nil {
panic(err)
}
if ipv4 := ne.IP.To4(); ipv4 != nil {
return IPNetwork{IP: ipv4, Mask: ne.Mask[len(ne.Mask)-4 : len(ne.Mask)]}
}
return IPNetwork(*ne)
}
func anyPathHasDeprecatedCredentials(pathDefaults Path, paths map[string]*OptionalPath) bool {
if pathDefaults.PublishUser != nil ||
pathDefaults.PublishPass != nil ||
pathDefaults.PublishIPs != nil ||
pathDefaults.ReadUser != nil ||
pathDefaults.ReadPass != nil ||
pathDefaults.ReadIPs != nil {
return true
}
for _, pa := range paths {
if pa != nil {
rva := reflect.ValueOf(pa.Values).Elem()
if rva.FieldByName("PublishUser").Interface().(*Credential) != nil ||
rva.FieldByName("PublishPass").Interface().(*Credential) != nil ||
rva.FieldByName("PublishIPs").Interface().(*IPNetworks) != nil ||
rva.FieldByName("ReadUser").Interface().(*Credential) != nil ||
rva.FieldByName("ReadPass").Interface().(*Credential) != nil ||
rva.FieldByName("ReadIPs").Interface().(*IPNetworks) != nil {
return true
}
}
}
return false
}
func deepClone(rv reflect.Value) reflect.Value {
switch rv.Kind() {
case reflect.Pointer:
if rv.IsNil() {
return rv
}
newPtr := reflect.New(rv.Elem().Type())
newPtr.Elem().Set(deepClone(rv.Elem()))
return newPtr
case reflect.Struct:
newStruct := reflect.New(rv.Type()).Elem()
for i := range rv.NumField() {
field := rv.Field(i)
newField := newStruct.Field(i)
if newField.CanSet() {
newField.Set(deepClone(field))
}
}
return newStruct
case reflect.Slice:
if rv.IsNil() {
return reflect.Zero(rv.Type())
}
newSlice := reflect.MakeSlice(rv.Type(), rv.Len(), rv.Cap())
for i := range rv.Len() {
newSlice.Index(i).Set(deepClone(rv.Index(i)))
}
return newSlice
case reflect.Map:
if rv.IsNil() {
return reflect.Zero(rv.Type())
}
newMap := reflect.MakeMap(rv.Type())
for _, key := range rv.MapKeys() {
newMap.SetMapIndex(key, deepClone(rv.MapIndex(key)))
}
return newMap
default:
return rv
}
}
type nilLogger struct{}
func (nilLogger) Log(_ logger.Level, _ string, _ ...any) {
}
var defaultAuthInternalUsers = []AuthInternalUser{
{
User: "any",
Pass: "",
Permissions: []AuthInternalUserPermission{
{
Action: AuthActionPublish,
},
{
Action: AuthActionRead,
},
{
Action: AuthActionPlayback,
},
},
},
{
User: "any",
Pass: "",
IPs: IPNetworks{mustParseCIDR("127.0.0.1/32"), mustParseCIDR("::1/128")},
Permissions: []AuthInternalUserPermission{
{
Action: AuthActionAPI,
},
{
Action: AuthActionMetrics,
},
{
Action: AuthActionPprof,
},
},
},
}
// Conf is a configuration.
type Conf struct {
// General
LogLevel LogLevel `json:"logLevel"`
LogDestinations LogDestinations `json:"logDestinations"`
LogStructured bool `json:"logStructured"`
LogFile string `json:"logFile"`
SysLogPrefix string `json:"sysLogPrefix"`
DumpPackets bool `json:"dumpPackets"`
ReadTimeout Duration `json:"readTimeout"`
WriteTimeout Duration `json:"writeTimeout"`
ReadBufferCount *int `json:"readBufferCount,omitempty" deprecated:"true"`
WriteQueueSize int `json:"writeQueueSize"`
UDPMaxPayloadSize int `json:"udpMaxPayloadSize"`
UDPReadBufferSize uint `json:"udpReadBufferSize"`
RunOnConnect string `json:"runOnConnect"`
RunOnConnectRestart bool `json:"runOnConnectRestart"`
RunOnDisconnect string `json:"runOnDisconnect"`
// Authentication
AuthMethod AuthMethod `json:"authMethod"`
AuthInternalUsers []AuthInternalUser `json:"authInternalUsers"`
AuthHTTPAddress string `json:"authHTTPAddress"`
ExternalAuthenticationURL *string `json:"externalAuthenticationURL,omitempty" deprecated:"true"`
AuthHTTPFingerprint string `json:"authHTTPFingerprint"`
AuthHTTPExclude []AuthInternalUserPermission `json:"authHTTPExclude"`
AuthJWTJWKS string `json:"authJWTJWKS"`
AuthJWTJWKSFingerprint string `json:"authJWTJWKSFingerprint"`
AuthJWTClaimKey string `json:"authJWTClaimKey"`
AuthJWTExclude []AuthInternalUserPermission `json:"authJWTExclude"`
AuthJWTInHTTPQuery bool `json:"authJWTInHTTPQuery"`
AuthJWTIssuer string `json:"authJWTIssuer"`
AuthJWTAudience string `json:"authJWTAudience"`
// Control API
API bool `json:"api"`
APIAddress string `json:"apiAddress"`
APIEncryption bool `json:"apiEncryption"`
APIServerKey string `json:"apiServerKey"`
APIServerCert string `json:"apiServerCert"`
APIAllowOrigin *string `json:"apiAllowOrigin,omitempty" deprecated:"true"`
APIAllowOrigins []string `json:"apiAllowOrigins"`
APITrustedProxies IPNetworks `json:"apiTrustedProxies"`
// Metrics
Metrics bool `json:"metrics"`
MetricsAddress string `json:"metricsAddress"`
MetricsEncryption bool `json:"metricsEncryption"`
MetricsServerKey string `json:"metricsServerKey"`
MetricsServerCert string `json:"metricsServerCert"`
MetricsAllowOrigin *string `json:"metricsAllowOrigin,omitempty" deprecated:"true"`
MetricsAllowOrigins []string `json:"metricsAllowOrigins"`
MetricsTrustedProxies IPNetworks `json:"metricsTrustedProxies"`
// PPROF
PPROF bool `json:"pprof"`
PPROFAddress string `json:"pprofAddress"`
PPROFEncryption bool `json:"pprofEncryption"`
PPROFServerKey string `json:"pprofServerKey"`
PPROFServerCert string `json:"pprofServerCert"`
PPROFAllowOrigin *string `json:"pprofAllowOrigin,omitempty" deprecated:"true"`
PPROFAllowOrigins []string `json:"pprofAllowOrigins"`
PPROFTrustedProxies IPNetworks `json:"pprofTrustedProxies"`
// Playback
Playback bool `json:"playback"`
PlaybackAddress string `json:"playbackAddress"`
PlaybackEncryption bool `json:"playbackEncryption"`
PlaybackServerKey string `json:"playbackServerKey"`
PlaybackServerCert string `json:"playbackServerCert"`
PlaybackAllowOrigin *string `json:"playbackAllowOrigin,omitempty" deprecated:"true"`
PlaybackAllowOrigins []string `json:"playbackAllowOrigins"`
PlaybackTrustedProxies IPNetworks `json:"playbackTrustedProxies"`
// RTSP server
RTSP bool `json:"rtsp"`
RTSPDisable *bool `json:"rtspDisable,omitempty" deprecated:"true"`
Protocols *RTSPTransports `json:"protocols,omitempty" deprecated:"true"`
RTSPTransports RTSPTransports `json:"rtspTransports"`
Encryption *Encryption `json:"encryption,omitempty" deprecated:"true"`
RTSPEncryption Encryption `json:"rtspEncryption"`
RTSPAddress string `json:"rtspAddress"`
RTSPSAddress string `json:"rtspsAddress"`
RTPAddress string `json:"rtpAddress"`
RTCPAddress string `json:"rtcpAddress"`
MulticastIPRange string `json:"multicastIPRange"`
MulticastRTPPort int `json:"multicastRTPPort"`
MulticastRTCPPort int `json:"multicastRTCPPort"`
SRTPAddress string `json:"srtpAddress"`
SRTCPAddress string `json:"srtcpAddress"`
MulticastSRTPPort int `json:"multicastSRTPPort"`
MulticastSRTCPPort int `json:"multicastSRTCPPort"`
ServerKey *string `json:"serverKey,omitempty"`
ServerCert *string `json:"serverCert,omitempty"`
RTSPServerKey string `json:"rtspServerKey"`
RTSPServerCert string `json:"rtspServerCert"`
AuthMethods *RTSPAuthMethods `json:"authMethods,omitempty" deprecated:"true"`
RTSPAuthMethods RTSPAuthMethods `json:"rtspAuthMethods"`
RTSPUDPReadBufferSize *uint `json:"rtspUDPReadBufferSize,omitempty" deprecated:"true"`
// RTMP server
RTMP bool `json:"rtmp"`
RTMPDisable *bool `json:"rtmpDisable,omitempty" deprecated:"true"`
RTMPEncryption Encryption `json:"rtmpEncryption"`
RTMPAddress string `json:"rtmpAddress"`
RTMPSAddress string `json:"rtmpsAddress"`
RTMPServerKey string `json:"rtmpServerKey"`
RTMPServerCert string `json:"rtmpServerCert"`
// HLS server
HLS bool `json:"hls"`
HLSDisable *bool `json:"hlsDisable,omitempty" deprecated:"true"`
HLSAddress string `json:"hlsAddress"`
HLSEncryption bool `json:"hlsEncryption"`
HLSServerKey string `json:"hlsServerKey"`
HLSServerCert string `json:"hlsServerCert"`
HLSAllowOrigin *string `json:"hlsAllowOrigin,omitempty" deprecated:"true"`
HLSAllowOrigins []string `json:"hlsAllowOrigins"`
HLSTrustedProxies IPNetworks `json:"hlsTrustedProxies"`
HLSAlwaysRemux bool `json:"hlsAlwaysRemux"`
HLSVariant HLSVariant `json:"hlsVariant"`
HLSSegmentCount int `json:"hlsSegmentCount"`
HLSSegmentDuration Duration `json:"hlsSegmentDuration"`
HLSPartDuration Duration `json:"hlsPartDuration"`
HLSSegmentMaxSize StringSize `json:"hlsSegmentMaxSize"`
HLSDirectory string `json:"hlsDirectory"`
HLSMuxerCloseAfter Duration `json:"hlsMuxerCloseAfter"`
// WebRTC server
WebRTC bool `json:"webrtc"`
WebRTCDisable *bool `json:"webrtcDisable,omitempty" deprecated:"true"`
WebRTCAddress string `json:"webrtcAddress"`
WebRTCEncryption bool `json:"webrtcEncryption"`
WebRTCServerKey string `json:"webrtcServerKey"`
WebRTCServerCert string `json:"webrtcServerCert"`
WebRTCAllowOrigin *string `json:"webrtcAllowOrigin,omitempty" deprecated:"true"`
WebRTCAllowOrigins []string `json:"webrtcAllowOrigins"`
WebRTCTrustedProxies IPNetworks `json:"webrtcTrustedProxies"`
WebRTCLocalUDPAddress string `json:"webrtcLocalUDPAddress"`
WebRTCLocalTCPAddress string `json:"webrtcLocalTCPAddress"`
WebRTCIPsFromInterfaces bool `json:"webrtcIPsFromInterfaces"`
WebRTCIPsFromInterfacesList []string `json:"webrtcIPsFromInterfacesList"`
WebRTCAdditionalHosts []string `json:"webrtcAdditionalHosts"`
WebRTCICEServers2 []WebRTCICEServer `json:"webrtcICEServers2"`
WebRTCSTUNGatherTimeout Duration `json:"webrtcSTUNGatherTimeout"`
WebRTCHandshakeTimeout Duration `json:"webrtcHandshakeTimeout"`
WebRTCTrackGatherTimeout Duration `json:"webrtcTrackGatherTimeout"`
WebRTCICEUDPMuxAddress *string `json:"webrtcICEUDPMuxAddress,omitempty" deprecated:"true"`
WebRTCICETCPMuxAddress *string `json:"webrtcICETCPMuxAddress,omitempty" deprecated:"true"`
WebRTCICEHostNAT1To1IPs *[]string `json:"webrtcICEHostNAT1To1IPs,omitempty" deprecated:"true"`
WebRTCICEServers *[]string `json:"webrtcICEServers,omitempty" deprecated:"true"`
// SRT server
SRT bool `json:"srt"`
SRTAddress string `json:"srtAddress"`
// Record (deprecated)
Record *bool `json:"record,omitempty" deprecated:"true"`
RecordPath *string `json:"recordPath,omitempty" deprecated:"true"`
RecordFormat *RecordFormat `json:"recordFormat,omitempty" deprecated:"true"`
RecordPartDuration *Duration `json:"recordPartDuration,omitempty" deprecated:"true"`
RecordSegmentDuration *Duration `json:"recordSegmentDuration,omitempty" deprecated:"true"`
RecordDeleteAfter *Duration `json:"recordDeleteAfter,omitempty" deprecated:"true"`
// Path defaults
PathDefaults Path `json:"pathDefaults"`
// Paths
OptionalPaths map[string]*OptionalPath `json:"paths"`
Paths map[string]*Path `json:"-"` // filled by Validate()
}
func (conf *Conf) setDefaults() {
// General
conf.LogLevel = LogLevel(logger.Info)
conf.LogDestinations = LogDestinations{LogDestination(logger.DestinationStdout)}
conf.LogStructured = false
conf.LogFile = "mediamtx.log"
conf.SysLogPrefix = "mediamtx"
conf.ReadTimeout = 10 * Duration(time.Second)
conf.WriteTimeout = 10 * Duration(time.Second)
conf.WriteQueueSize = 512
conf.UDPMaxPayloadSize = 1452
// Authentication
conf.AuthMethod = AuthMethodInternal
conf.AuthInternalUsers = defaultAuthInternalUsers
conf.AuthHTTPExclude = []AuthInternalUserPermission{
{
Action: AuthActionAPI,
},
{
Action: AuthActionMetrics,
},
{
Action: AuthActionPprof,
},
}
conf.AuthJWTClaimKey = "mediamtx_permissions"
conf.AuthJWTInHTTPQuery = true
// Control API
conf.APIAddress = ":9997"
conf.APIServerKey = "server.key"
conf.APIServerCert = "server.crt"
conf.APIAllowOrigins = []string{"*"}
// Metrics
conf.MetricsAddress = ":9998"
conf.MetricsServerKey = "server.key"
conf.MetricsServerCert = "server.crt"
conf.MetricsAllowOrigins = []string{"*"}
// PPROF
conf.PPROFAddress = ":9999"
conf.PPROFServerKey = "server.key"
conf.PPROFServerCert = "server.crt"
conf.PPROFAllowOrigins = []string{"*"}
// Playback server
conf.PlaybackAddress = ":9996"
conf.PlaybackServerKey = "server.key"
conf.PlaybackServerCert = "server.crt"
conf.PlaybackAllowOrigins = []string{"*"}
// RTSP server
conf.RTSP = true
conf.RTSPEncryption = EncryptionNo
conf.RTSPTransports = RTSPTransports{
gortsplib.ProtocolUDP: {},
gortsplib.ProtocolUDPMulticast: {},
gortsplib.ProtocolTCP: {},
}
conf.RTSPAddress = ":8554"
conf.RTSPSAddress = ":8322"
conf.RTPAddress = ":8000"
conf.RTCPAddress = ":8001"
conf.MulticastIPRange = "224.1.0.0/16"
conf.MulticastRTPPort = 8002
conf.MulticastRTCPPort = 8003
conf.SRTPAddress = ":8004"
conf.SRTCPAddress = ":8005"
conf.MulticastSRTPPort = 8006
conf.MulticastSRTCPPort = 8007
conf.RTSPServerKey = "server.key"
conf.RTSPServerCert = "server.crt"
conf.RTSPAuthMethods = RTSPAuthMethods{RTSPAuthMethod(auth.VerifyMethodBasic)}
// RTMP server
conf.RTMP = true
conf.RTMPEncryption = EncryptionNo
conf.RTMPAddress = ":1935"
conf.RTMPSAddress = ":1936"
conf.RTMPServerKey = "server.key"
conf.RTMPServerCert = "server.crt"
// HLS
conf.HLS = true
conf.HLSAddress = ":8888"
conf.HLSServerKey = "server.key"
conf.HLSServerCert = "server.crt"
conf.HLSAllowOrigins = []string{"*"}
conf.HLSVariant = HLSVariant(gohlslib.MuxerVariantLowLatency)
conf.HLSSegmentCount = 7
conf.HLSSegmentDuration = 1 * Duration(time.Second)
conf.HLSPartDuration = 200 * Duration(time.Millisecond)
conf.HLSSegmentMaxSize = 50 * 1024 * 1024
conf.HLSMuxerCloseAfter = 60 * Duration(time.Second)
// WebRTC server
conf.WebRTC = true
conf.WebRTCAddress = ":8889"
conf.WebRTCServerKey = "server.key"
conf.WebRTCServerCert = "server.crt"
conf.WebRTCAllowOrigins = []string{"*"}
conf.WebRTCLocalUDPAddress = ":8189"
conf.WebRTCIPsFromInterfaces = true
conf.WebRTCSTUNGatherTimeout = 5 * Duration(time.Second)
conf.WebRTCHandshakeTimeout = 10 * Duration(time.Second)
conf.WebRTCTrackGatherTimeout = 2 * Duration(time.Second)
// SRT server
conf.SRT = true
conf.SRTAddress = ":8890"
conf.PathDefaults.setDefaults()
}
// Load loads a Conf.
func Load(fpath string, defaultConfPaths []string, l logger.Writer) (*Conf, string, error) {
conf := &Conf{}
conf.setDefaults()
fpath, err := conf.loadFromFile(fpath, defaultConfPaths)
if err != nil {
return nil, "", err
}
err = env.Load("RTSP", conf) // legacy prefix
if err != nil {
return nil, "", err
}
err = env.Load("MTX", conf)
if err != nil {
return nil, "", err
}
// disallow nil slices for ease of use and compatibility
setAllNilSlicesToEmptyRecursive(reflect.ValueOf(conf))
err = conf.Validate(l)
if err != nil {
return nil, "", err
}
return conf, fpath, nil
}
func (conf *Conf) loadFromFile(fpath string, defaultConfPaths []string) (string, error) {
if fpath == "" {
fpath = firstThatExists(defaultConfPaths)
// when the configuration file is not explicitly set,
// it is optional.
if fpath == "" {
return "", nil
}
}
byts, err := os.ReadFile(fpath)
if err != nil {
return "", err
}
if key, ok := os.LookupEnv("RTSP_CONFKEY"); ok { // legacy format
byts, err = decrypt.Decrypt(key, byts)
if err != nil {
return "", err
}
}
if key, ok := os.LookupEnv("MTX_CONFKEY"); ok {
byts, err = decrypt.Decrypt(key, byts)
if err != nil {
return "", err
}
}
err = yamlwrapper.Unmarshal(byts, conf)
if err != nil {
return "", err
}
return fpath, nil
}
// Clone clones the configuration.
func (conf Conf) Clone() *Conf {
cloned := deepClone(reflect.ValueOf(conf)).Interface().(Conf)
return &cloned
}
// Validate checks the configuration for errors, converts deprecated fields into new ones, fills dependent fields.
func (conf *Conf) Validate(l logger.Writer) error {
if l == nil {
l = &nilLogger{}
}
// General (deprecated params)
if conf.ReadBufferCount != nil {
l.Log(logger.Warn, "parameter 'readBufferCount' is deprecated and has been replaced with 'writeQueueSize'")
conf.WriteQueueSize = *conf.ReadBufferCount
}
// General
if conf.ReadTimeout <= 0 {
return fmt.Errorf("'readTimeout' must be greater than zero")
}
if conf.WriteTimeout <= 0 {
return fmt.Errorf("'writeTimeout' must be greater than zero")
}
if conf.WriteQueueSize <= 0 {
return fmt.Errorf("'writeQueueSize' must be greater than zero")
}
if (conf.WriteQueueSize & (conf.WriteQueueSize - 1)) != 0 {
return fmt.Errorf("'writeQueueSize' must be a power of two")
}
if conf.UDPMaxPayloadSize > 1472 {
return fmt.Errorf("'udpMaxPayloadSize' must be less than 1472")
}
// Authentication (deprecated params)
if conf.ExternalAuthenticationURL != nil {
l.Log(logger.Warn, "parameter 'externalAuthenticationURL' is deprecated "+
"and has been replaced with 'authMethod' and 'authHTTPAddress'")
conf.AuthMethod = AuthMethodHTTP
conf.AuthHTTPAddress = *conf.ExternalAuthenticationURL
}
deprecatedCredentialsMode := false
if anyPathHasDeprecatedCredentials(conf.PathDefaults, conf.OptionalPaths) {
l.Log(logger.Warn, "you are using one or more authentication-related deprecated parameters "+
"(publishUser, publishPass, publishIPs, readUser, readPass, readIPs). "+
"These have been replaced by 'authInternalUsers'")
if conf.AuthInternalUsers != nil && !reflect.DeepEqual(conf.AuthInternalUsers, defaultAuthInternalUsers) {
return fmt.Errorf("authInternalUsers and legacy credentials " +
"(publishUser, publishPass, publishIPs, readUser, readPass, readIPs) cannot be used together")
}
conf.AuthInternalUsers = []AuthInternalUser{
{
User: "any",
Permissions: []AuthInternalUserPermission{
{
Action: AuthActionPlayback,
},
},
},
{
User: "any",
IPs: IPNetworks{mustParseCIDR("127.0.0.1/32"), mustParseCIDR("::1/128")},
Permissions: []AuthInternalUserPermission{
{
Action: AuthActionAPI,
},
{
Action: AuthActionMetrics,
},
{
Action: AuthActionPprof,
},
},
},
}
deprecatedCredentialsMode = true
}
// Authentication
switch conf.AuthMethod {
case AuthMethodInternal:
for _, u := range conf.AuthInternalUsers {
// https://github.com/bluenviron/gortsplib/blob/55556f1ecfa2bd51b29fe14eddd70512a0361cbd/server_conn.go#L155-L156
if u.User == "" {
return fmt.Errorf("empty usernames are not supported")
}
if u.User == "any" && u.Pass != "" {
return fmt.Errorf("using a password with 'any' user is not supported")
}
}
case AuthMethodHTTP:
if conf.AuthHTTPAddress == "" {
return fmt.Errorf("'authHTTPAddress' is empty")
}
if conf.AuthHTTPAddress != "" &&
!strings.HasPrefix(conf.AuthHTTPAddress, "http://") &&
!strings.HasPrefix(conf.AuthHTTPAddress, "https://") {
return fmt.Errorf("'externalAuthenticationURL' must be a HTTP URL")
}
case AuthMethodJWT:
if conf.AuthJWTJWKS == "" {
return fmt.Errorf("'authJWTJWKS' is empty")
}
if conf.AuthJWTJWKS != "" &&
!strings.HasPrefix(conf.AuthJWTJWKS, "http://") &&
!strings.HasPrefix(conf.AuthJWTJWKS, "https://") {
return fmt.Errorf("'authJWTJWKS' must be a HTTP URL")
}
if conf.AuthJWTClaimKey == "" {
return fmt.Errorf("'authJWTClaimKey' is empty")
}
}
// Control API (deprecated params)
if conf.APIAllowOrigin != nil {
l.Log(logger.Warn, "parameter 'apiAllowOrigin' is deprecated and has been replaced with 'apiAllowOrigins'")
conf.APIAllowOrigins = []string{*conf.APIAllowOrigin}
}
// Control API
if conf.API {
if conf.APIAddress == "" {
return fmt.Errorf("'apiAddress' must be set when API is enabled")
}
}
// Metrics (deprecated params)
if conf.MetricsAllowOrigin != nil {
l.Log(logger.Warn, "parameter 'metricsAllowOrigin' is deprecated and has been replaced with 'metricsAllowOrigins'")
conf.MetricsAllowOrigins = []string{*conf.MetricsAllowOrigin}
}
// Metrics
if conf.Metrics {
if conf.MetricsAddress == "" {
return fmt.Errorf("'metricsAddress' must be set when metrics are enabled")
}
}
// PPROF (deprecated params)
if conf.PPROFAllowOrigin != nil {
l.Log(logger.Warn, "parameter 'pprofAllowOrigin' is deprecated and has been replaced with 'pprofAllowOrigins'")
conf.PPROFAllowOrigins = []string{*conf.PPROFAllowOrigin}
}
// PPROF
if conf.PPROF {
if conf.PPROFAddress == "" {
return fmt.Errorf("'pprofAddress' must be set when pprof is enabled")
}
}
// Playback (deprecated params)
if conf.PlaybackAllowOrigin != nil {
l.Log(logger.Warn, "parameter 'playbackAllowOrigin' is deprecated and has been replaced with 'playbackAllowOrigins'")
conf.PlaybackAllowOrigins = []string{*conf.PlaybackAllowOrigin}
}
// Playback
if conf.Playback {
if conf.PlaybackAddress == "" {
return fmt.Errorf("'playbackAddress' must be set when playback is enabled")
}
}
// RTSP server (deprecated params)
if conf.RTSPDisable != nil {
l.Log(logger.Warn, "parameter 'rtspDisabled' is deprecated and has been replaced with 'rtsp'")
conf.RTSP = !*conf.RTSPDisable
}
if conf.Protocols != nil {
l.Log(logger.Warn, "parameter 'protocols' is deprecated and has been replaced with 'rtspTransports'")
conf.RTSPTransports = *conf.Protocols
}
if conf.Encryption != nil {
l.Log(logger.Warn, "parameter 'encryption' is deprecated and has been replaced with 'rtspEncryption'")
conf.RTSPEncryption = *conf.Encryption
}
if conf.AuthMethods != nil {
l.Log(logger.Warn, "parameter 'authMethods' is deprecated and has been replaced with 'rtspAuthMethods'")
conf.RTSPAuthMethods = *conf.AuthMethods
}
if conf.ServerCert != nil {
l.Log(logger.Warn, "parameter 'serverCert' is deprecated and has been replaced with 'rtspServerCert'")
conf.RTSPServerCert = *conf.ServerCert
}
if conf.ServerKey != nil {
l.Log(logger.Warn, "parameter 'serverKey' is deprecated and has been replaced with 'rtspServerKey'")
conf.RTSPServerKey = *conf.ServerKey
}
// RTSP server
if conf.RTSP {
if conf.RTSPEncryption == EncryptionNo || conf.RTSPEncryption == EncryptionOptional {
if conf.RTSPAddress == "" {
return fmt.Errorf("'rtspAddress' must be set when RTSP is enabled and RTSP encryption is 'no' or 'optional'")
}
if _, ok := conf.RTSPTransports[gortsplib.ProtocolUDP]; ok {
if conf.RTPAddress == "" {
return fmt.Errorf("'rtpAddress' must be set when UDP is enabled and RTSP encryption is 'no' or 'optional'")
}
if conf.RTCPAddress == "" {
return fmt.Errorf("'rtcpAddress' must be set when UDP is enabled and RTSP encryption is 'no' or 'optional'")
}
}
if _, ok := conf.RTSPTransports[gortsplib.ProtocolUDPMulticast]; ok {
if conf.MulticastIPRange == "" {
return fmt.Errorf("'multicastIPRange' must be set when UDP multicast is enabled" +
" and RTSP encryption is 'no' or 'optional'")
}
if conf.MulticastRTPPort == 0 {
return fmt.Errorf("'multicastRTPPort' must be set when UDP multicast is enabled" +
" and RTSP encryption is 'no' or 'optional'")
}
if conf.MulticastRTCPPort == 0 {
return fmt.Errorf("'multicastRTCPPort' must be set when UDP multicast is enabled" +
" and RTSP encryption is 'no' or 'optional'")
}
}
}
if conf.RTSPEncryption == EncryptionOptional || conf.RTSPEncryption == EncryptionStrict {
if conf.RTSPSAddress == "" {
return fmt.Errorf("'rtspsAddress' must be set when RTSP is enabled and RTSP encryption is 'optional' or 'strict'")
}
if _, ok := conf.RTSPTransports[gortsplib.ProtocolUDP]; ok {
if conf.SRTPAddress == "" {
return fmt.Errorf("'srtpAddress' must be set when UDP is enabled" +
" and RTSP encryption is 'optional' or 'strict'")
}
if conf.SRTCPAddress == "" {
return fmt.Errorf("'srtcpAddress' must be set when UDP is enabled" +
" and RTSP encryption is 'optional' or 'strict'")
}
}
if _, ok := conf.RTSPTransports[gortsplib.ProtocolUDPMulticast]; ok {
if conf.MulticastIPRange == "" {
return fmt.Errorf("'multicastIPRange' must be set when UDP multicast is enabled" +
" and RTSP encryption is 'optional' or 'strict'")
}
if conf.MulticastSRTPPort == 0 {
return fmt.Errorf("'multicastSRTPPort' must be set when UDP multicast is enabled" +
" and RTSP encryption is 'optional' or 'strict'")
}
if conf.MulticastSRTCPPort == 0 {
return fmt.Errorf("'multicastSRTCPPort' must be set when UDP multicast is enabled" +
" and RTSP encryption is 'optional' or 'strict'")
}
}
}
if len(conf.RTSPAuthMethods) == 0 {
return fmt.Errorf("at least one 'rtspAuthMethods' must be provided")
}
if slices.Contains(conf.RTSPAuthMethods, RTSPAuthMethod(auth.VerifyMethodDigestMD5)) {
if conf.AuthMethod != AuthMethodInternal {
return fmt.Errorf("when RTSP digest is enabled, the only supported auth method is 'internal'")
}
for _, user := range conf.AuthInternalUsers {
if user.User.IsHashed() || user.Pass.IsHashed() {
return fmt.Errorf("when RTSP digest is enabled, hashed credentials cannot be used")
}
}
}
}
// RTMP (deprecated params)
if conf.RTMPDisable != nil {
l.Log(logger.Warn, "parameter 'rtmpDisabled' is deprecated and has been replaced with 'rtmp'")
conf.RTMP = !*conf.RTMPDisable
}
// RTMP
if conf.RTMP {
if conf.RTMPAddress == "" {
return fmt.Errorf("'rtmpAddress' must be set when RTMP is enabled")
}
}
// HLS (deprecated params)
if conf.HLSDisable != nil {
l.Log(logger.Warn, "parameter 'hlsDisable' is deprecated and has been replaced with 'hls'")
conf.HLS = !*conf.HLSDisable
}
if conf.HLSAllowOrigin != nil {
l.Log(logger.Warn, "parameter 'hlsAllowOrigin' is deprecated and has been replaced with 'hlsAllowOrigins'")
conf.HLSAllowOrigins = []string{*conf.HLSAllowOrigin}
}
// HLS
if conf.HLS {
if conf.HLSAddress == "" {
return fmt.Errorf("'hlsAddress' must be set when HLS is enabled")
}
}
// WebRTC (deprecated params)
if conf.WebRTCDisable != nil {
l.Log(logger.Warn, "parameter 'webrtcDisable' is deprecated and has been replaced with 'webrtc'")
conf.WebRTC = !*conf.WebRTCDisable
}
if conf.WebRTCICEUDPMuxAddress != nil {
l.Log(logger.Warn, "parameter 'webrtcICEUDPMuxAdderss' is deprecated "+
"and has been replaced with 'webrtcLocalUDPAddress'")
conf.WebRTCLocalUDPAddress = *conf.WebRTCICEUDPMuxAddress
}
if conf.WebRTCICETCPMuxAddress != nil {
l.Log(logger.Warn, "parameter 'webrtcICETCPMuxAddress' is deprecated "+
"and has been replaced with 'webrtcLocalTCPAddress'")
conf.WebRTCLocalTCPAddress = *conf.WebRTCICETCPMuxAddress
}
if conf.WebRTCICEHostNAT1To1IPs != nil {
l.Log(logger.Warn, "parameter 'webrtcICEHostNAT1To1IPs' is deprecated "+
"and has been replaced with 'webrtcAdditionalHosts'")
conf.WebRTCAdditionalHosts = *conf.WebRTCICEHostNAT1To1IPs
}
if conf.WebRTCICEServers != nil {
l.Log(logger.Warn, "parameter 'webrtcICEServers' is deprecated "+
"and has been replaced with 'webrtcICEServers2'")
for _, server := range *conf.WebRTCICEServers {
parts := strings.Split(server, ":")
if len(parts) == 5 {
conf.WebRTCICEServers2 = append(conf.WebRTCICEServers2, WebRTCICEServer{
URL: parts[0] + ":" + parts[3] + ":" + parts[4],
Username: parts[1],
Password: parts[2],
})
} else {
conf.WebRTCICEServers2 = append(conf.WebRTCICEServers2, WebRTCICEServer{
URL: server,
})
}
}
}
if conf.WebRTCAllowOrigin != nil {
l.Log(logger.Warn, "parameter 'webrtcAllowOrigin' is deprecated and has been replaced with 'webrtcAllowOrigins'")
conf.WebRTCAllowOrigins = []string{*conf.WebRTCAllowOrigin}
}
// WebRTC
if conf.WebRTC {
if conf.WebRTCAddress == "" {
return fmt.Errorf("'webrtcAddress' must be set when WebRTC is enabled")
}
for _, server := range conf.WebRTCICEServers2 {
if !strings.HasPrefix(server.URL, "stun:") &&
!strings.HasPrefix(server.URL, "turn:") &&
!strings.HasPrefix(server.URL, "turns:") {
return fmt.Errorf("invalid ICE server: '%s'", server.URL)
}
}
if conf.WebRTCLocalUDPAddress == "" &&
conf.WebRTCLocalTCPAddress == "" &&
len(conf.WebRTCICEServers2) == 0 {
return fmt.Errorf("at least one between 'webrtcLocalUDPAddress'," +
" 'webrtcLocalTCPAddress' or 'webrtcICEServers2' must be filled")
}
if conf.WebRTCLocalUDPAddress != "" || conf.WebRTCLocalTCPAddress != "" {
if !conf.WebRTCIPsFromInterfaces && len(conf.WebRTCAdditionalHosts) == 0 {
return fmt.Errorf("at least one between 'webrtcIPsFromInterfaces' or 'webrtcAdditionalHosts' must be filled")
}
}
}
// Record (deprecated)
if conf.Record != nil {
l.Log(logger.Warn, "parameter 'record' is deprecated "+
"and has been replaced with 'pathDefaults.record'")
conf.PathDefaults.Record = *conf.Record
}
if conf.RecordPath != nil {
l.Log(logger.Warn, "parameter 'recordPath' is deprecated "+
"and has been replaced with 'pathDefaults.recordPath'")
conf.PathDefaults.RecordPath = *conf.RecordPath
}
if conf.RecordFormat != nil {
l.Log(logger.Warn, "parameter 'recordFormat' is deprecated "+
"and has been replaced with 'pathDefaults.recordFormat'")
conf.PathDefaults.RecordFormat = *conf.RecordFormat
}
if conf.RecordPartDuration != nil {
l.Log(logger.Warn, "parameter 'recordPartDuration' is deprecated "+
"and has been replaced with 'pathDefaults.recordPartDuration'")
conf.PathDefaults.RecordPartDuration = *conf.RecordPartDuration
}
if conf.RecordSegmentDuration != nil {
l.Log(logger.Warn, "parameter 'recordSegmentDuration' is deprecated "+
"and has been replaced with 'pathDefaults.recordSegmentDuration'")
conf.PathDefaults.RecordSegmentDuration = *conf.RecordSegmentDuration
}
if conf.RecordDeleteAfter != nil {
l.Log(logger.Warn, "parameter 'recordDeleteAfter' is deprecated "+
"and has been replaced with 'pathDefaults.recordDeleteAfter'")
conf.PathDefaults.RecordDeleteAfter = *conf.RecordDeleteAfter
}
// paths
hasAllOthers := false
for name := range conf.OptionalPaths {
if name == "all" || name == "all_others" || name == "~^.*$" {
if hasAllOthers {
return fmt.Errorf("all_others, all and '~^.*$' are aliases")
}
hasAllOthers = true
}
}
conf.Paths = make(map[string]*Path)
for _, name := range sortedKeys(conf.OptionalPaths) {
optional := conf.OptionalPaths[name]
if optional == nil {
optional = &OptionalPath{
Values: newOptionalPathValues(),
}
conf.OptionalPaths[name] = optional
}
pconf := newPath(&conf.PathDefaults, optional)
conf.Paths[name] = pconf
}
for _, name := range sortedKeys(conf.OptionalPaths) {
err := conf.Paths[name].validate(conf, name, deprecatedCredentialsMode, l)
if err != nil {
return err
}
}
return nil
}
// Global returns the global part of Conf.
func (conf *Conf) Global() *Global {
g := &Global{
Values: newGlobalValues(),
}
copyStructFields(g.Values, conf)
return g
}
// PatchGlobal patches the global configuration.
func (conf *Conf) PatchGlobal(optional *OptionalGlobal) {
copyStructFields(conf, optional.Values)
}
// PatchPathDefaults patches path default settings.
func (conf *Conf) PatchPathDefaults(optional *OptionalPath) {
copyStructFields(&conf.PathDefaults, optional.Values)
}
// AddPath adds a path.
func (conf *Conf) AddPath(name string, p *OptionalPath) error {
if _, ok := conf.OptionalPaths[name]; ok {
return fmt.Errorf("path already exists")
}
if conf.OptionalPaths == nil {
conf.OptionalPaths = make(map[string]*OptionalPath)
}
conf.OptionalPaths[name] = p
return nil
}
// PatchPath patches a path.
func (conf *Conf) PatchPath(name string, optional2 *OptionalPath) error {
optional, ok := conf.OptionalPaths[name]
if !ok {
return ErrPathNotFound
}
copyStructFields(optional.Values, optional2.Values)
return nil
}
// ReplacePath replaces a path.
func (conf *Conf) ReplacePath(name string, optional2 *OptionalPath) error {
if conf.OptionalPaths == nil {
conf.OptionalPaths = make(map[string]*OptionalPath)
}
conf.OptionalPaths[name] = optional2
return nil
}
// RemovePath removes a path.
func (conf *Conf) RemovePath(name string) error {
if _, ok := conf.OptionalPaths[name]; !ok {
return ErrPathNotFound
}
delete(conf.OptionalPaths, name)
return nil
}
================================================
FILE: internal/conf/conf_test.go
================================================
package conf
import (
"crypto/rand"
"encoding/base64"
"io"
"os"
"testing"
"time"
"github.com/bluenviron/gortsplib/v5"
"github.com/stretchr/testify/require"
"golang.org/x/crypto/nacl/secretbox"
"github.com/bluenviron/mediamtx/internal/logger"
)
func createTempFile(byts []byte) (string, error) {
tmpf, err := os.CreateTemp(os.TempDir(), "rtsp-")
if err != nil {
return "", err
}
defer tmpf.Close()
_, err = tmpf.Write(byts)
if err != nil {
return "", err
}
return tmpf.Name(), nil
}
func TestConfFromFile(t *testing.T) {
func() {
tmpf, err := createTempFile([]byte("logLevel: debug\n" +
"paths:\n" +
" cam1:\n" +
" runOnDemandStartTimeout: 5s\n"))
require.NoError(t, err)
defer os.Remove(tmpf)
conf, confPath, err := Load(tmpf, nil, nil)
require.NoError(t, err)
require.Equal(t, tmpf, confPath)
require.Equal(t, LogLevel(logger.Debug), conf.LogLevel)
pa, ok := conf.Paths["cam1"]
require.Equal(t, true, ok)
require.Equal(t, &Path{
Name: "cam1",
Source: "publisher",
SourceOnDemandStartTimeout: 10 * Duration(time.Second),
SourceOnDemandCloseAfter: 10 * Duration(time.Second),
OverridePublisher: true,
AlwaysAvailableTracks: []AlwaysAvailableTrack{},
RecordPath: "./recordings/%path/%Y-%m-%d_%H-%M-%S-%f",
RecordFormat: RecordFormatFMP4,
RecordPartDuration: Duration(1 * time.Second),
RecordMaxPartSize: 50 * 1024 * 1024,
RecordSegmentDuration: 3600000000000,
RecordDeleteAfter: 86400000000000,
RTSPUDPSourcePortRange: []uint{10000, 65535},
WHEPSTUNGatherTimeout: 5 * Duration(time.Second),
WHEPHandshakeTimeout: 10 * Duration(time.Second),
WHEPTrackGatherTimeout: 2 * Duration(time.Second),
RPICameraWidth: 1920,
RPICameraHeight: 1080,
RPICameraContrast: 1,
RPICameraSaturation: 1,
RPICameraSharpness: 1,
RPICameraExposure: "normal",
RPICameraAWB: "auto",
RPICameraAWBGains: []float64{0, 0},
RPICameraDenoise: "off",
RPICameraMetering: "centre",
RPICameraFPS: 30,
RPICameraAfMode: "continuous",
RPICameraAfRange: "normal",
RPICameraAfSpeed: "normal",
RPICameraTextOverlay: "%Y-%m-%d %H:%M:%S - MediaMTX",
RPICameraCodec: "auto",
RPICameraIDRPeriod: 60,
RPICameraBitrate: 5000000,
RPICameraHardwareH264Profile: "main",
RPICameraHardwareH264Level: "4.1",
RPICameraSoftwareH264Profile: "baseline",
RPICameraSoftwareH264Level: "4.1",
RPICameraMJPEGQuality: 60,
RunOnDemandStartTimeout: 5 * Duration(time.Second),
RunOnDemandCloseAfter: 10 * Duration(time.Second),
}, pa)
}()
func() {
tmpf, err := createTempFile([]byte(``))
require.NoError(t, err)
defer os.Remove(tmpf)
_, _, err = Load(tmpf, nil, nil)
require.NoError(t, err)
}()
func() {
tmpf, err := createTempFile([]byte(`paths:`))
require.NoError(t, err)
defer os.Remove(tmpf)
_, _, err = Load(tmpf, nil, nil)
require.NoError(t, err)
}()
func() {
tmpf, err := createTempFile([]byte(
"paths:\n" +
" mypath:\n"))
require.NoError(t, err)
defer os.Remove(tmpf)
_, _, err = Load(tmpf, nil, nil)
require.NoError(t, err)
}()
}
func TestConfFromFileAndEnv(t *testing.T) {
// global parameter
t.Setenv("RTSP_PROTOCOLS", "tcp")
// path parameter
t.Setenv("MTX_PATHS_CAM1_SOURCE", "rtsp://testing")
// deprecated global parameter
t.Setenv("MTX_RTMPDISABLE", "yes")
// deprecated path parameter
t.Setenv("MTX_PATHS_CAM2_DISABLEPUBLISHEROVERRIDE", "yes")
tmpf, err := createTempFile([]byte("{}"))
require.NoError(t, err)
defer os.Remove(tmpf)
conf, confPath, err := Load(tmpf, nil, nil)
require.NoError(t, err)
require.Equal(t, tmpf, confPath)
require.Equal(t, RTSPTransports{gortsplib.ProtocolTCP: {}}, conf.RTSPTransports)
require.Equal(t, false, conf.RTMP)
pa, ok := conf.Paths["cam1"]
require.Equal(t, true, ok)
require.Equal(t, "rtsp://testing", pa.Source)
pa, ok = conf.Paths["cam2"]
require.Equal(t, true, ok)
require.Equal(t, false, pa.OverridePublisher)
}
func TestConfFromEnvOnly(t *testing.T) {
t.Setenv("MTX_PATHS_CAM1_SOURCE", "rtsp://testing")
conf, confPath, err := Load("", nil, nil)
require.NoError(t, err)
require.Equal(t, "", confPath)
pa, ok := conf.Paths["cam1"]
require.Equal(t, true, ok)
require.Equal(t, "rtsp://testing", pa.Source)
}
func TestConfEncryption(t *testing.T) {
key := "testing123testin"
plaintext := "paths:\n" +
" path1:\n" +
" path2:\n"
encryptedConf := func() string {
var secretKey [32]byte
copy(secretKey[:], key)
var nonce [24]byte
_, err := io.ReadFull(rand.Reader, nonce[:])
require.NoError(t, err)
encrypted := secretbox.Seal(nonce[:], []byte(plaintext), &nonce, &secretKey)
return base64.StdEncoding.EncodeToString(encrypted)
}()
t.Setenv("RTSP_CONFKEY", key)
tmpf, err := createTempFile([]byte(encryptedConf))
require.NoError(t, err)
defer os.Remove(tmpf)
conf, confPath, err := Load(tmpf, nil, nil)
require.NoError(t, err)
require.Equal(t, tmpf, confPath)
_, ok := conf.Paths["path1"]
require.Equal(t, true, ok)
_, ok = conf.Paths["path2"]
require.Equal(t, true, ok)
}
func TestConfDeprecatedAuth(t *testing.T) {
tmpf, err := createTempFile([]byte(
"paths:\n" +
" cam:\n" +
" readUser: myuser\n" +
" readPass: mypass\n"))
require.NoError(t, err)
defer os.Remove(tmpf)
conf, _, err := Load(tmpf, nil, nil)
require.NoError(t, err)
require.Equal(t, []AuthInternalUser{
{
User: "any",
Permissions: []AuthInternalUserPermission{
{
Action: AuthActionPlayback,
},
},
},
{
User: "any",
IPs: IPNetworks{mustParseCIDR("127.0.0.1/32"), mustParseCIDR("::1/128")},
Permissions: []AuthInternalUserPermission{
{
Action: AuthActionAPI,
},
{
Action: AuthActionMetrics,
},
{
Action: AuthActionPprof,
},
},
},
{
User: "any",
IPs: IPNetworks{mustParseCIDR("0.0.0.0/0")},
Permissions: []AuthInternalUserPermission{
{
Action: AuthActionPublish,
Path: "cam",
},
},
},
{
User: "myuser",
Pass: "mypass",
IPs: IPNetworks{mustParseCIDR("0.0.0.0/0")},
Permissions: []AuthInternalUserPermission{
{
Action: AuthActionRead,
Path: "cam",
},
},
},
}, conf.AuthInternalUsers)
}
func TestConfErrors(t *testing.T) {
for _, ca := range []struct {
name string
conf string
err string
}{
{
"duplicate parameter",
"paths:\n" +
"paths:\n",
"[2:1] mapping key \"paths\" already defined at [1:1]\n 1 | null\n> 2 | paths:\n ^\n",
},
{
"non existent parameter",
`invalid: param`,
"json: unknown field \"invalid\"",
},
{
"invalid readTimeout",
"readTimeout: 0s\n",
"'readTimeout' must be greater than zero",
},
{
"invalid writeTimeout",
"writeTimeout: 0s\n",
"'writeTimeout' must be greater than zero",
},
{
"invalid writeQueueSize 1",
"writeQueueSize: 0\n",
"'writeQueueSize' must be greater than zero",
},
{
"invalid writeQueueSize 2",
"writeQueueSize: 1001\n",
"'writeQueueSize' must be a power of two",
},
{
"invalid udpMaxPayloadSize",
"udpMaxPayloadSize: 5000\n",
"'udpMaxPayloadSize' must be less than 1472",
},
{
"invalid ICE server",
"webrtcICEServers: [testing]\n",
"invalid ICE server: 'testing'",
},
{
"non existent parameter in path",
"paths:\n" +
" mypath:\n" +
" invalid: parameter\n",
"json: unknown field \"invalid\"",
},
{
"non existent parameter in auth",
"authInternalUsers:\n" +
"- users: test\n",
"json: unknown field \"authInternalUsers[0].users\"",
},
{
"invalid path name",
"paths:\n" +
" '':\n" +
" source: publisher\n",
"invalid path name '': cannot be empty",
},
{
"double raspberry pi camera",
"paths:\n" +
" cam1:\n" +
" source: rpiCamera\n" +
" cam2:\n" +
" source: rpiCamera\n",
"'rpiCamera' with same camera ID 0 is used as source in two paths, 'cam1' and 'cam2'",
},
{
"invalid srt publish passphrase",
"paths:\n" +
" mypath:\n" +
" srtPublishPassphrase: a\n",
`invalid 'srtPublishPassphrase': must be between 10 and 79 characters`,
},
{
"invalid srt read passphrase",
"paths:\n" +
" mypath:\n" +
" srtReadPassphrase: a\n",
`invalid 'readRTPassphrase': must be between 10 and 79 characters`,
},
{
"all_others aliases",
"paths:\n" +
" all:\n" +
" all_others:\n",
`all_others, all and '~^.*$' are aliases`,
},
{
"all_others aliases",
"paths:\n" +
" all_others:\n" +
" ~^.*$:\n",
`all_others, all and '~^.*$' are aliases`,
},
{
"jwt jwks empty",
"authMethod: jwt\n" +
"authJWTJWKS: \"\"\n" +
"authJWTClaimKey: test",
"'authJWTJWKS' is empty",
},
{
"invalid jwt jwks url",
"authMethod: jwt\n" +
"authJWTJWKS: ftp://invalid\n" +
"authJWTClaimKey: test",
"'authJWTJWKS' must be a HTTP URL",
},
{
"jwt claim key empty",
"authMethod: jwt\n" +
"authJWTJWKS: https://not-real.com\n" +
"authJWTClaimKey: \"\"",
"'authJWTClaimKey' is empty",
},
{
"http auth address empty",
"authMethod: http\n" +
"authHTTPAddress: \"\"",
"'authHTTPAddress' is empty",
},
{
"invalid http auth address",
"authMethod: http\n" +
"authHTTPAddress: ftp://invalid",
"'externalAuthenticationURL' must be a HTTP URL",
},
{
"invalid rtsp auth methods",
"rtspAuthMethods: []",
"at least one 'rtspAuthMethods' must be provided",
},
{
"rtsp digest with non-internal auth",
"authMethod: http\n" +
"authHTTPAddress: http://localhost:9000\n" +
"rtspAuthMethods: [digest]\n",
"when RTSP digest is enabled, the only supported auth method is 'internal'",
},
{
"rtsp digest with hashed credentials",
"rtspAuthMethods: [digest]\n" +
"authInternalUsers:\n" +
"- user: sha256:test\n" +
" pass: test\n" +
" permissions:\n" +
" - action: publish\n",
"when RTSP digest is enabled, hashed credentials cannot be used",
},
{
"invalid fallback",
"paths:\n" +
" my_path:\n" +
" fallback: invalid://invalid",
`'invalid://invalid' is not a valid RTSP URL`,
},
{
"invalid source redirect",
"paths:\n" +
" my_path:\n" +
" source: redirect\n" +
" sourceRedirect: invalid://invalid",
`'invalid://invalid' is not a valid RTSP URL`,
},
{
"useless source redirect",
"paths:\n" +
" my_path:\n" +
" sourceRedirect: invalid://invalid",
`'sourceRedirect' is useless when source is not 'redirect'`,
},
{
"invalid user",
"authInternalUsers:\n" +
"- user:\n" +
" pass: test\n" +
" permissions:\n" +
" - action: publish\n",
"empty usernames are not supported",
},
{
"invalid pass",
"authInternalUsers:\n" +
"- user: any\n" +
" pass: test\n" +
" permissions:\n" +
" - action: publish\n",
`using a password with 'any' user is not supported`,
},
{
"invalid record path 1",
"paths:\n" +
" my_path:\n" +
" recordPath: invalid\n",
`'recordPath' must contain %path`,
},
{
"invalid record path 2",
"paths:\n" +
" my_path:\n" +
" recordPath: '%path/invalid'\n",
`'recordPath' must contain either %s or %Y %m %d %H %M %S`,
},
{
"invalid record path 3",
"playback: true\n" +
"paths:\n" +
" my_path:\n" +
" recordPath: '%path/%s'\n",
`'recordPath' must contain %f`,
},
{
"invalid record delete after",
"paths:\n" +
" my_path:\n" +
" recordSegmentDuration: 30m\n" +
" recordDeleteAfter: 20m\n",
`'recordDeleteAfter' cannot be lower than 'recordSegmentDuration'`,
},
{
"missing rtpAddress with UDP and no encryption",
"rtspEncryption: \"no\"\n" +
"rtspTransports: [udp]\n" +
"rtpAddress: ''\n",
"'rtpAddress' must be set when UDP is enabled and RTSP encryption is 'no' or 'optional'",
},
{
"missing rtcpAddress with UDP and no encryption",
"rtspEncryption: \"no\"\n" +
"rtspTransports: [udp]\n" +
"rtpAddress: ':8000'\n" +
"rtcpAddress: ''\n",
"'rtcpAddress' must be set when UDP is enabled and RTSP encryption is 'no' or 'optional'",
},
{
"missing rtpAddress with UDP and optional encryption",
"rtspEncryption: optional\n" +
"rtspTransports: [udp]\n" +
"rtpAddress: ''\n",
"'rtpAddress' must be set when UDP is enabled and RTSP encryption is 'no' or 'optional'",
},
{
"missing rtcpAddress with UDP and optional encryption",
"rtspEncryption: optional\n" +
"rtspTransports: [udp]\n" +
"rtpAddress: ':8000'\n" +
"rtcpAddress: ''\n",
"'rtcpAddress' must be set when UDP is enabled and RTSP encryption is 'no' or 'optional'",
},
{
"missing multicastIPRange with UDP multicast and no encryption",
"rtspEncryption: \"no\"\n" +
"rtspTransports: [multicast]\n" +
"multicastIPRange: ''\n",
"'multicastIPRange' must be set when UDP multicast is enabled and RTSP encryption is 'no' or 'optional'",
},
{
"missing multicastRTPPort with UDP multicast and no encryption",
"rtspEncryption: \"no\"\n" +
"rtspTransports: [multicast]\n" +
"multicastIPRange: '224.1.0.0/16'\n" +
"multicastRTPPort: 0\n",
"'multicastRTPPort' must be set when UDP multicast is enabled and RTSP encryption is 'no' or 'optional'",
},
{
"missing multicastRTCPPort with UDP multicast and no encryption",
"rtspEncryption: \"no\"\n" +
"rtspTransports: [multicast]\n" +
"multicastIPRange: '224.1.0.0/16'\n" +
"multicastRTPPort: 8002\n" +
"multicastRTCPPort: 0\n",
"'multicastRTCPPort' must be set when UDP multicast is enabled and RTSP encryption is 'no' or 'optional'",
},
{
"missing multicastIPRange with UDP multicast and optional encryption",
"rtspEncryption: optional\n" +
"rtspTransports: [multicast]\n" +
"multicastIPRange: ''\n",
"'multicastIPRange' must be set when UDP multicast is enabled and RTSP encryption is 'no' or 'optional'",
},
{
"missing multicastRTPPort with UDP multicast and optional encryption",
"rtspEncryption: optional\n" +
"rtspTransports: [multicast]\n" +
"multicastIPRange: '224.1.0.0/16'\n" +
"multicastRTPPort: 0\n",
"'multicastRTPPort' must be set when UDP multicast is enabled and RTSP encryption is 'no' or 'optional'",
},
{
"missing multicastRTCPPort with UDP multicast and optional encryption",
"rtspEncryption: optional\n" +
"rtspTransports: [multicast]\n" +
"multicastIPRange: '224.1.0.0/16'\n" +
"multicastRTPPort: 8002\n" +
"multicastRTCPPort: 0\n",
"'multicastRTCPPort' must be set when UDP multicast is enabled and RTSP encryption is 'no' or 'optional'",
},
{
"missing srtpAddress with UDP and optional encryption",
"rtspEncryption: optional\n" +
"rtspTransports: [udp]\n" +
"rtpAddress: ':8000'\n" +
"rtcpAddress: ':8001'\n" +
"srtpAddress: ''\n",
"'srtpAddress' must be set when UDP is enabled and RTSP encryption is 'optional' or 'strict'",
},
{
"missing srtcpAddress with UDP and optional encryption",
"rtspEncryption: optional\n" +
"rtspTransports: [udp]\n" +
"rtpAddress: ':8000'\n" +
"rtcpAddress: ':8001'\n" +
"srtpAddress: ':8004'\n" +
"srtcpAddress: ''\n",
"'srtcpAddress' must be set when UDP is enabled and RTSP encryption is 'optional' or 'strict'",
},
{
"missing srtpAddress with UDP and strict encryption",
"rtspEncryption: strict\n" +
"rtspTransports: [udp]\n" +
"srtpAddress: ''\n",
"'srtpAddress' must be set when UDP is enabled and RTSP encryption is 'optional' or 'strict'",
},
{
"missing srtcpAddress with UDP and strict encryption",
"rtspEncryption: strict\n" +
"rtspTransports: [udp]\n" +
"srtpAddress: ':8004'\n" +
"srtcpAddress: ''\n",
"'srtcpAddress' must be set when UDP is enabled and RTSP encryption is 'optional' or 'strict'",
},
{
"missing multicastIPRange with UDP multicast and optional encryption second check",
"rtspEncryption: optional\n" +
"rtspTransports: [multicast]\n" +
"rtpAddress: ':8000'\n" +
"rtcpAddress: ':8001'\n" +
"multicastIPRange: ''\n",
"'multicastIPRange' must be set when UDP multicast is enabled and RTSP encryption is 'no' or 'optional'",
},
{
"missing multicastSRTPPort with UDP multicast and optional encryption",
"rtspEncryption: optional\n" +
"rtspTransports: [multicast]\n" +
"rtpAddress: ':8000'\n" +
"rtcpAddress: ':8001'\n" +
"multicastIPRange: '224.1.0.0/16'\n" +
"multicastRTPPort: 8002\n" +
"multicastRTCPPort: 8003\n" +
"srtpAddress: ':8004'\n" +
"srtcpAddress: ':8005'\n" +
"multicastSRTPPort: 0\n",
"'multicastSRTPPort' must be set when UDP multicast is enabled and RTSP encryption is 'optional' or 'strict'",
},
{
"missing multicastSRTCPPort with UDP multicast and optional encryption",
"rtspEncryption: optional\n" +
"rtspTransports: [multicast]\n" +
"rtpAddress: ':8000'\n" +
"rtcpAddress: ':8001'\n" +
"multicastIPRange: '224.1.0.0/16'\n" +
"multicastRTPPort: 8002\n" +
"multicastRTCPPort: 8003\n" +
"srtpAddress: ':8004'\n" +
"srtcpAddress: ':8005'\n" +
"multicastSRTPPort: 8006\n" +
"multicastSRTCPPort: 0\n",
"'multicastSRTCPPort' must be set when UDP multicast is enabled and RTSP encryption is 'optional' or 'strict'",
},
{
"missing multicastIPRange with UDP multicast and strict encryption",
"rtspEncryption: strict\n" +
"rtspTransports: [multicast]\n" +
"multicastIPRange: ''\n",
"'multicastIPRange' must be set when UDP multicast is enabled and RTSP encryption is 'optional' or 'strict'",
},
{
"missing multicastSRTPPort with UDP multicast and strict encryption",
"rtspEncryption: strict\n" +
"rtspTransports: [multicast]\n" +
"multicastIPRange: '224.1.0.0/16'\n" +
"multicastSRTPPort: 0\n",
"'multicastSRTPPort' must be set when UDP multicast is enabled and RTSP encryption is 'optional' or 'strict'",
},
{
"missing multicastSRTCPPort with UDP multicast and strict encryption",
"rtspEncryption: strict\n" +
"rtspTransports: [multicast]\n" +
"multicastIPRange: '224.1.0.0/16'\n" +
"multicastSRTPPort: 8006\n" +
"multicastSRTCPPort: 0\n",
"'multicastSRTCPPort' must be set when UDP multicast is enabled and RTSP encryption is 'optional' or 'strict'",
},
{
"missing rtspAddress with RTSP enabled and no encryption",
"rtsp: yes\n" +
"rtspEncryption: \"no\"\n" +
"rtspAddress: ''\n",
"'rtspAddress' must be set when RTSP is enabled and RTSP encryption is 'no' or 'optional'",
},
{
"missing rtspsAddress with RTSP enabled and strict encryption",
"rtsp: yes\n" +
"rtspEncryption: strict\n" +
"rtspsAddress: ''\n",
"'rtspsAddress' must be set when RTSP is enabled and RTSP encryption is 'optional' or 'strict'",
},
{
"missing rtmpAddress with RTMP enabled",
"rtmp: yes\n" +
"rtmpAddress: ''\n",
"'rtmpAddress' must be set when RTMP is enabled",
},
{
"missing hlsAddress with HLS enabled",
"hls: yes\n" +
"hlsAddress: ''\n",
"'hlsAddress' must be set when HLS is enabled",
},
{
"missing webrtcAddress with WebRTC enabled",
"webrtc: yes\n" +
"webrtcAddress: ''\n",
"'webrtcAddress' must be set when WebRTC is enabled",
},
{
"webrtc missing local addresses and ice servers",
"webrtc: yes\n" +
"webrtcLocalUDPAddress: ''\n" +
"webrtcLocalTCPAddress: ''\n" +
"webrtcICEServers2: []\n",
"at least one between 'webrtcLocalUDPAddress', 'webrtcLocalTCPAddress' or 'webrtcICEServers2' must be filled",
},
{
"webrtc missing ips config",
"webrtc: yes\n" +
"webrtcLocalUDPAddress: ':8189'\n" +
"webrtcIPsFromInterfaces: false\n" +
"webrtcAdditionalHosts: []\n",
"at least one between 'webrtcIPsFromInterfaces' or 'webrtcAdditionalHosts' must be filled",
},
{
"missing apiAddress with API enabled",
"api: yes\n" +
"apiAddress: ''\n",
"'apiAddress' must be set when API is enabled",
},
{
"missing metricsAddress with metrics enabled",
"metrics: yes\n" +
"metricsAddress: ''\n",
"'metricsAddress' must be set when metrics are enabled",
},
{
"missing pprofAddress with pprof enabled",
"pprof: yes\n" +
"pprofAddress: ''\n",
"'pprofAddress' must be set when pprof is enabled",
},
{
"missing playbackAddress with playback enabled",
"playback: yes\n" +
"playbackAddress: ''\n",
"'playbackAddress' must be set when playback is enabled",
},
{
"alwaysAvailableTracks and alwaysAvailableFile together",
"paths:\n" +
" mypath:\n" +
" alwaysAvailable: yes\n" +
" alwaysAvailableTracks:\n" +
" - codec: H264\n" +
" alwaysAvailableFile: /path/to/file.mp4\n",
"'alwaysAvailableFile' and 'alwaysAvailableTracks' cannot be used together",
},
} {
t.Run(ca.name, func(t *testing.T) {
tmpf, err := createTempFile([]byte(ca.conf))
require.NoError(t, err)
defer os.Remove(tmpf)
_, _, err = Load(tmpf, nil, nil)
require.EqualError(t, err, ca.err)
})
}
}
func TestAlwaysAvailableFileErrorMagicBytes(t *testing.T) {
tmpf, err := createTempFile([]byte("ABCDEFGHI"))
require.NoError(t, err)
defer os.Remove(tmpf)
tmpConf, err := createTempFile([]byte("paths:\n" +
" mypath:\n" +
" alwaysAvailable: yes\n" +
" alwaysAvailableFile: " + tmpf + "\n"))
require.NoError(t, err)
defer os.Remove(tmpConf)
_, _, err = Load(tmpConf, nil, nil)
require.EqualError(t, err, "invalid 'alwaysAvailableFile': file is not MP4, magic bytes are [69 70 71 72]")
}
func TestSampleConfFile(t *testing.T) {
func() {
conf1, confPath1, err := Load("../../mediamtx.yml", nil, nil)
require.NoError(t, err)
require.Equal(t, "../../mediamtx.yml", confPath1)
conf1.Paths = make(map[string]*Path)
conf1.OptionalPaths = nil
conf2, confPath2, err := Load("", nil, nil)
require.NoError(t, err)
require.Equal(t, "", confPath2)
require.Equal(t, conf1, conf2)
}()
func() {
conf1, confPath1, err := Load("../../mediamtx.yml", nil, nil)
require.NoError(t, err)
require.Equal(t, "../../mediamtx.yml", confPath1)
tmpf, err := createTempFile([]byte("paths:\n all_others:"))
require.NoError(t, err)
defer os.Remove(tmpf)
conf2, confPath2, err := Load(tmpf, nil, nil)
require.NoError(t, err)
require.Equal(t, tmpf, confPath2)
require.Equal(t, conf1.Paths, conf2.Paths)
}()
}
func TestClone(t *testing.T) {
conf1, _, err := Load("", nil, nil)
require.NoError(t, err)
conf2 := conf1.Clone()
require.Equal(t, conf1, conf2)
}
================================================
FILE: internal/conf/credential.go
================================================
package conf
import (
"crypto/sha256"
"encoding/base64"
"fmt"
"regexp"
"strings"
"github.com/bluenviron/mediamtx/internal/conf/jsonwrapper"
"github.com/matthewhartstonge/argon2"
)
var (
rePlainCredential = regexp.MustCompile(`^[a-zA-Z0-9!\$\(\)\*\+\.;<=>\[\]\^_\-\{\}@#&]+$`)
reBase64 = regexp.MustCompile(`^sha256:[a-zA-Z0-9\+/=]+$`)
)
const plainCredentialSupportedChars = "A-Z,0-9,!,$,(,),*,+,.,;,<,=,>,[,],^,_,-,\",\",@,#,&"
func sha256Base64(in string) string {
h := sha256.New()
h.Write([]byte(in))
return base64.StdEncoding.EncodeToString(h.Sum(nil))
}
// Credential is a parameter that is used as username or password.
type Credential string
// UnmarshalJSON implements json.Unmarshaler.
func (d *Credential) UnmarshalJSON(b []byte) error {
var in string
if err := jsonwrapper.Unmarshal(b, &in); err != nil {
return err
}
*d = Credential(in)
return d.validate()
}
// UnmarshalEnv implements env.Unmarshaler.
func (d *Credential) UnmarshalEnv(_ string, v string) error {
return d.UnmarshalJSON([]byte(`"` + v + `"`))
}
// IsSha256 returns true if the credential is a sha256 hash.
func (d Credential) IsSha256() bool {
return strings.HasPrefix(string(d), "sha256:")
}
// IsArgon2 returns true if the credential is an argon2 hash.
func (d Credential) IsArgon2() bool {
return strings.HasPrefix(string(d), "argon2:")
}
// IsHashed returns true if the credential is a sha256 or argon2 hash.
func (d Credential) IsHashed() bool {
return d.IsSha256() || d.IsArgon2()
}
// Check returns true if the given value matches the credential.
func (d Credential) Check(guess string) bool {
if d.IsSha256() {
return string(d)[len("sha256:"):] == sha256Base64(guess)
}
if d.IsArgon2() {
// TODO: remove matthewhartstonge/argon2 when this PR gets merged into mainline Go:
// https://go-review.googlesource.com/c/crypto/+/502515
ok, err := argon2.VerifyEncoded([]byte(guess), []byte(string(d)[len("argon2:"):]))
return ok && err == nil
}
if d != "" {
return string(d) == guess
}
return true
}
func (d Credential) validate() error {
if d != "" {
switch {
case d.IsSha256():
if !reBase64.MatchString(string(d)) {
return fmt.Errorf("credential contains unsupported characters, sha256 hash must be base64 encoded")
}
case d.IsArgon2():
// TODO: remove matthewhartstonge/argon2 when this PR gets merged into mainline Go:
// https://go-review.googlesource.com/c/crypto/+/502515
_, err := argon2.Decode([]byte(string(d)[len("argon2:"):]))
if err != nil {
return fmt.Errorf("invalid argon2 hash: %w", err)
}
default:
if !rePlainCredential.MatchString(string(d)) {
return fmt.Errorf("credential contains unsupported characters. Supported are: %s", plainCredentialSupportedChars)
}
}
}
return nil
}
================================================
FILE: internal/conf/credential_test.go
================================================
package conf
import (
"testing"
"github.com/stretchr/testify/assert"
)
func TestCredential(t *testing.T) {
t.Run("UnmarshalJSON", func(t *testing.T) {
expectedCred := Credential("password")
jsonData := []byte(`"password"`)
var actualCred Credential
err := actualCred.UnmarshalJSON(jsonData)
assert.NoError(t, err)
assert.Equal(t, expectedCred, actualCred)
})
t.Run("UnmarshalEnv", func(t *testing.T) {
cred := Credential("")
err := cred.UnmarshalEnv("", "password")
assert.NoError(t, err)
assert.Equal(t, Credential("password"), cred)
})
t.Run("IsSha256", func(t *testing.T) {
cred := Credential("")
assert.False(t, cred.IsSha256())
assert.False(t, cred.IsHashed())
cred = "sha256:j1tsRqDEw9xvq/D7/9tMx6Jh/jMhk3UfjwIB2f1zgMo="
assert.True(t, cred.IsSha256())
assert.True(t, cred.IsHashed())
cred = "argon2:$argon2id$v=19$m=65536,t=1," +
"p=4$WXJGqwIB2qd+pRmxMOw9Dg$X4gvR0ZB2DtQoN8vOnJPR2SeFdUhH9TyVzfV98sfWeE"
assert.False(t, cred.IsSha256())
assert.True(t, cred.IsHashed())
})
t.Run("IsArgon2", func(t *testing.T) {
cred := Credential("")
assert.False(t, cred.IsArgon2())
assert.False(t, cred.IsHashed())
cred = "sha256:j1tsRqDEw9xvq/D7/9tMx6Jh/jMhk3UfjwIB2f1zgMo="
assert.False(t, cred.IsArgon2())
assert.True(t, cred.IsHashed())
cred = "argon2:$argon2id$v=19$m=65536,t=1," +
"p=4$WXJGqwIB2qd+pRmxMOw9Dg$X4gvR0ZB2DtQoN8vOnJPR2SeFdUhH9TyVzfV98sfWeE"
assert.True(t, cred.IsArgon2())
assert.True(t, cred.IsHashed())
})
t.Run("Check-plain", func(t *testing.T) {
cred := Credential("password")
assert.True(t, cred.Check("password"))
assert.False(t, cred.Check("wrongpassword"))
})
t.Run("Check-sha256", func(t *testing.T) {
cred := Credential("password")
assert.True(t, cred.Check("password"))
assert.False(t, cred.Check("wrongpassword"))
})
t.Run("Check-sha256", func(t *testing.T) {
cred := Credential("sha256:rl3rgi4NcZkpAEcacZnQ2VuOfJ0FxAqCRaKB/SwdZoQ=")
assert.True(t, cred.Check("testuser"))
assert.False(t, cred.Check("notestuser"))
})
t.Run("Check-argon2", func(t *testing.T) {
cred := Credential("argon2:$argon2id$v=19$m=4096,t=3," +
"p=1$MTIzNDU2Nzg$Ux/LWeTgJQPyfMMJo1myR64+o8rALHoPmlE1i/TR+58")
assert.True(t, cred.Check("testuser"))
assert.False(t, cred.Check("notestuser"))
})
t.Run("validate", func(t *testing.T) {
tests := []struct {
name string
cred Credential
wantErr bool
}{
{
name: "Empty credential",
cred: Credential(""),
wantErr: false,
},
{
name: "Valid plain credential",
cred: Credential("validPlain123"),
wantErr: false,
},
{
name: "Invalid plain credential",
cred: Credential("invalid/Plain"),
wantErr: true,
},
{
name: "Valid sha256 credential",
cred: Credential("sha256:validBase64EncodedHash=="),
wantErr: false,
},
{
name: "Invalid sha256 credential",
cred: Credential("sha256:inval*idBase64"),
wantErr: true,
},
{
name: "Valid Argon2 credential",
cred: Credential("argon2:$argon2id$v=19$m=4096," +
"t=3,p=1$MTIzNDU2Nzg$zarsL19s86GzUWlAkvwt4gJBFuU/A9CVuCjNI4fksow"),
wantErr: false,
},
{
name: "Invalid Argon2 credential",
cred: Credential("argon2:invalid"),
wantErr: true,
},
{
name: "Invalid Argon2 credential",
// testing argon2d errors, because it's not supported
cred: Credential("$argon2d$v=19$m=4096,t=3," +
"p=1$MTIzNDU2Nzg$Xqyd4R7LzXvvAEHaVU12+Nzf5OkHoYcwIEIIYJUDpz0"),
wantErr: true,
},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
err := tt.cred.validate()
if tt.wantErr {
assert.Error(t, err)
} else {
assert.NoError(t, err)
}
})
}
})
}
================================================
FILE: internal/conf/decrypt/decrypt.go
================================================
// Package decrypt contains the Decrypt function.
package decrypt
import (
"encoding/base64"
"fmt"
"golang.org/x/crypto/nacl/secretbox"
)
// Decrypt decrypts the configuration with the given key.
func Decrypt(key string, byts []byte) ([]byte, error) {
enc, err := base64.StdEncoding.DecodeString(string(byts))
if err != nil {
return nil, err
}
var secretKey [32]byte
copy(secretKey[:], key)
var decryptNonce [24]byte
copy(decryptNonce[:], enc[:24])
decrypted, ok := secretbox.Open(nil, enc[24:], &decryptNonce, &secretKey)
if !ok {
return nil, fmt.Errorf("decryption error")
}
return decrypted, nil
}
================================================
FILE: internal/conf/duration.go
================================================
package conf
import (
"encoding/json"
"regexp"
"strconv"
"time"
"github.com/bluenviron/mediamtx/internal/conf/jsonwrapper"
)
var reDays = regexp.MustCompile("^(-?[0-9]+)d")
// Duration is a duration. It differs from the standard duration in these ways:
// - it is unmarshaled/marshaled from/to a string (instead of a number)
// - it supports days
type Duration time.Duration
func (d Duration) marshalInternal() string {
negative := false
if d < 0 {
negative = true
d = -d
}
day := Duration(86400 * time.Second)
days := d / day
nonDays := d % day
ret := ""
if negative {
ret += "-"
}
if days > 0 {
ret += strconv.FormatInt(int64(days), 10) + "d"
}
if nonDays != 0 {
ret += time.Duration(nonDays).String()
}
return ret
}
// MarshalJSON implements json.Marshaler.
func (d Duration) MarshalJSON() ([]byte, error) {
return json.Marshal(d.marshalInternal())
}
func (d *Duration) unmarshalInternal(in string) error {
negative := false
days := int64(0)
m := reDays.FindStringSubmatch(in)
if m != nil {
days, _ = strconv.ParseInt(m[1], 10, 64)
if days < 0 {
negative = true
days = -days
}
in = in[len(m[0]):]
}
var nonDays time.Duration
if len(in) != 0 {
var err error
nonDays, err = time.ParseDuration(in)
if err != nil {
return err
}
}
nonDays += time.Duration(days) * 24 * time.Hour
if negative {
nonDays = -nonDays
}
*d = Duration(nonDays)
return nil
}
// UnmarshalJSON implements json.Unmarshaler.
func (d *Duration) UnmarshalJSON(b []byte) error {
var in string
if err := jsonwrapper.Unmarshal(b, &in); err != nil {
return err
}
err := d.unmarshalInternal(in)
if err != nil {
return err
}
return nil
}
// UnmarshalEnv implements env.Unmarshaler.
func (d *Duration) UnmarshalEnv(_ string, v string) error {
return d.UnmarshalJSON([]byte(`"` + v + `"`))
}
================================================
FILE: internal/conf/duration_test.go
================================================
package conf
import (
"testing"
"time"
"github.com/stretchr/testify/require"
)
var casesDuration = []struct {
name string
dec Duration
enc string
}{
{
"standard",
Duration(13456 * time.Second),
`"3h44m16s"`,
},
{
"days",
Duration(50 * 13456 * time.Second),
`"7d18h53m20s"`,
},
{
"days negative",
Duration(-50 * 13456 * time.Second),
`"-7d18h53m20s"`,
},
{
"days even",
Duration(7 * 24 * time.Hour),
`"7d"`,
},
}
func TestDurationUnmarshal(t *testing.T) {
for _, ca := range casesDuration {
t.Run(ca.name, func(t *testing.T) {
var dec Duration
err := dec.UnmarshalJSON([]byte(ca.enc))
require.NoError(t, err)
require.Equal(t, ca.dec, dec)
})
}
}
func TestDurationMarshal(t *testing.T) {
for _, ca := range casesDuration {
t.Run(ca.name, func(t *testing.T) {
enc, err := ca.dec.MarshalJSON()
require.NoError(t, err)
require.Equal(t, ca.enc, string(enc))
})
}
}
================================================
FILE: internal/conf/encryption.go
================================================
package conf
import (
"fmt"
"github.com/bluenviron/mediamtx/internal/conf/jsonwrapper"
)
// Encryption is the rtspEncryption / rtmpEncryption parameter.
type Encryption string
// values.
const (
EncryptionNo Encryption = "no"
EncryptionOptional Encryption = "optional"
EncryptionStrict Encryption = "strict"
)
// UnmarshalJSON implements json.Unmarshaler.
func (d *Encryption) UnmarshalJSON(b []byte) error {
type alias Encryption
if err := jsonwrapper.Unmarshal(b, (*alias)(d)); err != nil {
return err
}
switch *d {
case "false":
*d = EncryptionNo
case "true", "yes":
*d = EncryptionStrict
}
switch *d {
case EncryptionNo, EncryptionOptional, EncryptionStrict:
default:
return fmt.Errorf("invalid encryption: '%s'", *d)
}
return nil
}
// UnmarshalEnv implements env.Unmarshaler.
func (d *Encryption) UnmarshalEnv(_ string, v string) error {
return d.UnmarshalJSON([]byte(`"` + v + `"`))
}
================================================
FILE: internal/conf/env/env.go
================================================
// Package env contains a function to load configuration from environment.
package env
import (
"fmt"
"os"
"reflect"
"strconv"
"strings"
)
// Unmarshaler can be implemented to override the unmarshaling process.
type Unmarshaler interface {
UnmarshalEnv(prefix string, v string) error
}
func envHasAtLeastAKeyWithPrefix(env map[string]string, prefix string) bool {
for key := range env {
if strings.HasPrefix(key, prefix) {
return true
}
}
return false
}
func loadEnvInternal(env map[string]string, prefix string, prv reflect.Value) error {
if prv.Kind() != reflect.Pointer {
return loadEnvInternal(env, prefix, prv.Addr())
}
rt := prv.Type().Elem()
if i, ok := prv.Interface().(Unmarshaler); ok {
if ev, ok2 := env[prefix]; ok2 {
if prv.IsNil() {
prv.Set(reflect.New(rt))
i = prv.Interface().(Unmarshaler)
}
err := i.UnmarshalEnv(prefix, ev)
if err != nil {
return fmt.Errorf("%s: %w", prefix, err)
}
} else if envHasAtLeastAKeyWithPrefix(env, prefix) {
err := i.UnmarshalEnv(prefix, "")
if err != nil {
return fmt.Errorf("%s: %w", prefix, err)
}
}
return nil
}
switch rt {
case reflect.TypeOf(""):
if ev, ok := env[prefix]; ok {
if prv.IsNil() {
prv.Set(reflect.New(rt))
}
prv.Elem().SetString(ev)
}
return nil
case reflect.TypeOf(int(0)):
if ev, ok := env[prefix]; ok {
if prv.IsNil() {
prv.Set(reflect.New(rt))
}
iv, err := strconv.ParseInt(ev, 10, 32)
if err != nil {
return fmt.Errorf("%s: %w", prefix, err)
}
prv.Elem().SetInt(iv)
}
return nil
case reflect.TypeOf(uint(0)):
if ev, ok := env[prefix]; ok {
if prv.IsNil() {
prv.Set(reflect.New(rt))
}
iv, err := strconv.ParseUint(ev, 10, 32)
if err != nil {
return fmt.Errorf("%s: %w", prefix, err)
}
prv.Elem().SetUint(iv)
}
return nil
case reflect.TypeOf(float64(0)):
if ev, ok := env[prefix]; ok {
if prv.IsNil() {
prv.Set(reflect.New(rt))
}
iv, err := strconv.ParseFloat(ev, 64)
if err != nil {
return fmt.Errorf("%s: %w", prefix, err)
}
prv.Elem().SetFloat(iv)
}
return nil
case reflect.TypeOf(bool(false)):
if ev, ok := env[prefix]; ok {
if prv.IsNil() {
prv.Set(reflect.New(rt))
}
switch strings.ToLower(ev) {
case "yes", "true":
prv.Elem().SetBool(true)
case "no", "false":
prv.Elem().SetBool(false)
default:
return fmt.Errorf("%s: invalid value '%s'", prefix, ev)
}
}
return nil
}
switch rt.Kind() {
case reflect.Map:
for k := range env {
if !strings.HasPrefix(k, prefix+"_") {
continue
}
mapKey := strings.Split(k[len(prefix+"_"):], "_")[0]
if len(mapKey) == 0 {
continue
}
// allow only keys in uppercase
if mapKey != strings.ToUpper(mapKey) {
continue
}
// initialize only if there's at least one key
if prv.Elem().IsNil() {
prv.Elem().Set(reflect.MakeMap(rt))
}
mapKeyLower := strings.ToLower(mapKey)
nv := prv.Elem().MapIndex(reflect.ValueOf(mapKeyLower))
zero := reflect.Value{}
if nv == zero {
nv = reflect.New(rt.Elem().Elem())
prv.Elem().SetMapIndex(reflect.ValueOf(mapKeyLower), nv)
}
err := loadEnvInternal(env, prefix+"_"+mapKey, nv.Elem())
if err != nil {
return err
}
}
return nil
case reflect.Struct:
flen := rt.NumField()
for i := range flen {
f := rt.Field(i)
jsonTag := f.Tag.Get("json")
// load only public fields
if jsonTag == "-" {
continue
}
err := loadEnvInternal(env, prefix+"_"+
strings.ToUpper(strings.TrimSuffix(jsonTag, ",omitempty")), prv.Elem().Field(i))
if err != nil {
return err
}
}
return nil
case reflect.Slice:
switch {
case rt.Elem() == reflect.TypeOf(""):
if ev, ok := env[prefix]; ok {
if ev == "" {
prv.Elem().Set(reflect.MakeSlice(prv.Elem().Type(), 0, 0))
} else {
if prv.IsNil() {
prv.Set(reflect.New(rt))
}
prv.Elem().Set(reflect.ValueOf(strings.Split(ev, ",")))
}
}
return nil
case rt.Elem() == reflect.TypeOf(uint(0)):
if ev, ok := env[prefix]; ok {
if ev == "" {
prv.Elem().Set(reflect.MakeSlice(prv.Elem().Type(), 0, 0))
} else {
if prv.IsNil() {
prv.Set(reflect.New(rt))
}
raw := strings.Split(ev, ",")
vals := make([]uint, len(raw))
for i, v := range raw {
tmp, err := strconv.ParseUint(v, 10, 64)
if err != nil {
return err
}
vals[i] = uint(tmp)
}
prv.Elem().Set(reflect.ValueOf(vals))
}
}
return nil
case rt.Elem() == reflect.TypeOf(float64(0)):
if ev, ok := env[prefix]; ok {
if ev == "" {
prv.Elem().Set(reflect.MakeSlice(prv.Elem().Type(), 0, 0))
} else {
if prv.IsNil() {
prv.Set(reflect.New(rt))
}
raw := strings.Split(ev, ",")
vals := make([]float64, len(raw))
for i, v := range raw {
tmp, err := strconv.ParseFloat(v, 64)
if err != nil {
return err
}
vals[i] = tmp
}
prv.Elem().Set(reflect.ValueOf(vals))
}
}
return nil
case rt.Elem().Kind() == reflect.Struct:
if ev, ok := env[prefix]; ok && ev == "" { // special case: empty list
prv.Elem().Set(reflect.MakeSlice(prv.Elem().Type(), 0, 0))
} else {
for i := 0; ; i++ {
itemPrefix := prefix + "_" + strconv.FormatInt(int64(i), 10)
if !envHasAtLeastAKeyWithPrefix(env, itemPrefix) && (prv.IsZero() || prv.Elem().Len() <= i) {
break
}
var elem reflect.Value
if !prv.IsZero() && prv.Elem().Len() > i {
elem = prv.Elem().Index(i).Addr()
} else {
elem = reflect.New(rt.Elem())
}
err := loadEnvInternal(env, itemPrefix, elem.Elem())
if err != nil {
return err
}
if !prv.IsZero() && prv.Elem().Len() > i {
prv.Elem().Index(i).Set(elem.Elem())
} else {
if prv.IsZero() {
prv.Set(reflect.New(rt))
}
prv.Elem().Set(reflect.Append(prv.Elem(), elem.Elem()))
}
}
}
return nil
}
}
return fmt.Errorf("unsupported type: %v", rt)
}
func loadWithEnv(env map[string]string, prefix string, v any) error {
return loadEnvInternal(env, prefix, reflect.ValueOf(v).Elem())
}
func envToMap() map[string]string {
env := make(map[string]string)
for _, kv := range os.Environ() {
tmp := strings.SplitN(kv, "=", 2)
env[tmp[0]] = tmp[1]
}
return env
}
// Load loads the configuration from the environment.
func Load(prefix string, v any) error {
return loadWithEnv(envToMap(), prefix, v)
}
================================================
FILE: internal/conf/env/env_test.go
================================================
package env
import (
"encoding/json"
"testing"
"time"
"github.com/stretchr/testify/require"
)
func ptrOf[T any](v T) *T {
p := new(T)
*p = v
return p
}
type myDuration time.Duration
func (d *myDuration) UnmarshalJSON(b []byte) error {
var in string
if err := json.Unmarshal(b, &in); err != nil {
return err
}
du, err := time.ParseDuration(in)
if err != nil {
return err
}
*d = myDuration(du)
return nil
}
// UnmarshalEnv implements env.Unmarshaler.
func (d *myDuration) UnmarshalEnv(_ string, v string) error {
return d.UnmarshalJSON([]byte(`"` + v + `"`))
}
func TestLoadPrimitives(t *testing.T) {
type subStruct2 struct {
MyParam int `json:"myParam"`
}
type mapEntry struct {
MyValue string `json:"myValue"`
MyStruct subStruct2 `json:"myStruct"`
}
type testStruct struct {
MyString string `json:"myString"`
MyStringOpt *string `json:"myStringOpt"`
MyInt int `json:"myInt"`
MyIntOpt *int `json:"myIntOpt"`
MyUint uint `json:"myUint"`
MyUintOpt *uint `json:"myUintOpt"`
MyFloat float64 `json:"myFloat"`
MyFloatOpt *float64 `json:"myFloatOpt"`
MyBool bool `json:"myBool"`
MyBoolOpt *bool `json:"myBoolOpt"`
MyDuration myDuration `json:"myDuration"`
MyDurationOpt *myDuration `json:"myDurationOpt"`
MyDurationOptUnset *myDuration `json:"myDurationOptUnset"`
MyMap map[string]*mapEntry `json:"myMap"`
Unset *bool `json:"unset"`
}
var s testStruct
t.Setenv("MYPREFIX_MYSTRING", "testcontent")
t.Setenv("MYPREFIX_MYSTRINGOPT", "testcontent2")
t.Setenv("MYPREFIX_MYINT", "123")
t.Setenv("MYPREFIX_MYINTOPT", "456")
t.Setenv("MYPREFIX_MYUINT", "8910")
t.Setenv("MYPREFIX_MYUINTOPT", "112313")
t.Setenv("MYPREFIX_MYFLOAT", "15.2")
t.Setenv("MYPREFIX_MYFLOATOPT", "16.2")
t.Setenv("MYPREFIX_MYBOOL", "yes")
t.Setenv("MYPREFIX_MYBOOLOPT", "false")
t.Setenv("MYPREFIX_MYDURATION", "22s")
t.Setenv("MYPREFIX_MYDURATIONOPT", "30s")
t.Setenv("MYPREFIX_MYMAP_MYKEY", "")
t.Setenv("MYPREFIX_MYMAP_MYKEY2_MYVALUE", "asd")
t.Setenv("MYPREFIX_MYMAP_MYKEY2_MYSTRUCT_MYPARAM", "456")
err := Load("MYPREFIX", &s)
require.NoError(t, err)
require.Equal(t, testStruct{
MyString: "testcontent",
MyStringOpt: ptrOf("testcontent2"),
MyInt: 123,
MyIntOpt: ptrOf(456),
MyUint: 8910,
MyUintOpt: ptrOf(uint(112313)),
MyFloat: 15.2,
MyFloatOpt: ptrOf(16.2),
MyBool: true,
MyBoolOpt: ptrOf(false),
MyDuration: 22000000000,
MyDurationOpt: ptrOf(myDuration(30000000000)),
MyMap: map[string]*mapEntry{
"mykey": {
MyValue: "",
MyStruct: subStruct2{
MyParam: 0,
},
},
"mykey2": {
MyValue: "asd",
MyStruct: subStruct2{
MyParam: 456,
},
},
},
}, s)
}
func TestLoadSlice(t *testing.T) {
type testStruct struct {
MySliceFloat []float64 `json:"mySliceFloat"`
MySliceString []string `json:"mySliceString"`
MySliceStringEmpty []string `json:"mySliceStringEmpty"`
MySliceStringOpt *[]string `json:"mySliceStringOpt"`
MySliceStringOptUnset *[]string `json:"mySliceStringOptUnset"`
}
var s testStruct
t.Setenv("MYPREFIX_MYSLICEFLOAT", "0.5,0.5")
t.Setenv("MYPREFIX_MYSLICESTRING", "val1,val2")
t.Setenv("MYPREFIX_MYSLICESTRINGEMPTY", "")
t.Setenv("MYPREFIX_MYSLICESTRINGOPT", "aa")
err := Load("MYPREFIX", &s)
require.NoError(t, err)
require.Equal(t, testStruct{
MySliceFloat: []float64{0.5, 0.5},
MySliceString: []string{
"val1",
"val2",
},
MySliceStringEmpty: []string{},
MySliceStringOpt: &[]string{"aa"},
}, s)
}
func TestLoadSliceStruct(t *testing.T) {
type subStruct struct {
URL string `json:"url"`
Username string `json:"username"`
Password string `json:"password"`
MyInt2 int `json:"myInt2"`
}
type testStruct struct {
MySliceSubStruct []subStruct `json:"mySliceSubStruct"`
MySliceSubStructOpt *[]subStruct `json:"mySliceSubStructOpt"`
MySliceSubStructOptUnset *[]subStruct `json:"mySliceSubStructOptUnset"`
}
var s testStruct
t.Setenv("MYPREFIX_MYSLICESUBSTRUCT_0_URL", "url1")
t.Setenv("MYPREFIX_MYSLICESUBSTRUCT_0_USERNAME", "user1")
t.Setenv("MYPREFIX_MYSLICESUBSTRUCT_0_PASSWORD", "pass1")
t.Setenv("MYPREFIX_MYSLICESUBSTRUCT_1_URL", "url2")
t.Setenv("MYPREFIX_MYSLICESUBSTRUCT_1_PASSWORD", "pass2")
t.Setenv("MYPREFIX_MYSLICESUBSTRUCTOPT_0_PASSWORD", "pwd")
err := Load("MYPREFIX", &s)
require.NoError(t, err)
require.Equal(t, testStruct{
MySliceSubStruct: []subStruct{
{
URL: "url1",
Username: "user1",
Password: "pass1",
},
{
URL: "url2",
Username: "",
Password: "pass2",
},
},
MySliceSubStructOpt: &[]subStruct{
{
Password: "pwd",
},
},
}, s)
}
func TestLoadEmptySliceStruct(t *testing.T) {
type subStruct struct {
URL string `json:"url"`
Username string `json:"username"`
Password string `json:"password"`
MyInt2 int `json:"myInt2"`
}
type testStruct struct {
MySliceSubStructEmpty []subStruct `json:"mySliceSubStructEmpty"`
}
var s testStruct
t.Setenv("MYPREFIX_MYSLICESUBSTRUCTEMPTY", "")
err := Load("MYPREFIX", &s)
require.NoError(t, err)
require.Equal(t, testStruct{
MySliceSubStructEmpty: []subStruct{},
}, s)
}
func TestLoadPreloadedSliceStruct(t *testing.T) {
type subStruct struct {
URL string `json:"url"`
Username string `json:"username"`
Password string `json:"password"`
MyInt2 int `json:"myInt2"`
}
type testStruct struct {
MySliceSubStructPreloaded []subStruct `json:"mySliceSubStructPreloaded"`
MySliceSubStructPreloaded2 []subStruct `json:"mySliceSubStructPreloaded2"`
}
s := testStruct{
MySliceSubStructPreloaded: []subStruct{
{
URL: "val1",
Username: "val2",
},
},
MySliceSubStructPreloaded2: []subStruct{
{
URL: "val3",
Username: "val4",
},
},
}
t.Setenv("MYPREFIX_MYSLICESUBSTRUCTPRELOADED_0_URL", "newurl")
t.Setenv("MYPREFIX_MYSLICESUBSTRUCTPRELOADED2_1_URL", "newurl2")
err := Load("MYPREFIX", &s)
require.NoError(t, err)
require.Equal(t, testStruct{
MySliceSubStructPreloaded: []subStruct{
{
URL: "newurl",
Username: "val2",
},
},
MySliceSubStructPreloaded2: []subStruct{
{
URL: "val3",
Username: "val4",
},
{
URL: "newurl2",
},
},
}, s)
}
================================================
FILE: internal/conf/global.go
================================================
package conf
import (
"encoding/json"
"reflect"
)
var globalValuesType = func() reflect.Type {
var fields []reflect.StructField
rt := reflect.TypeOf(Conf{})
nf := rt.NumField()
for i := range nf {
f := rt.Field(i)
j := f.Tag.Get("json")
if j != "-" && j != "pathDefaults" && j != "paths" {
fields = append(fields, reflect.StructField{
Name: f.Name,
Type: f.Type,
Tag: f.Tag,
})
}
}
return reflect.StructOf(fields)
}()
func newGlobalValues() any {
return reflect.New(globalValuesType).Interface()
}
// Global is the global part of Conf.
type Global struct {
Values any
}
// MarshalJSON implements json.Marshaler.
func (p *Global) MarshalJSON() ([]byte, error) {
return json.Marshal(p.Values)
}
================================================
FILE: internal/conf/hls_variant.go
================================================
package conf
import (
"encoding/json"
"fmt"
"github.com/bluenviron/gohlslib/v2"
"github.com/bluenviron/mediamtx/internal/conf/jsonwrapper"
)
// HLSVariant is the hlsVariant parameter.
type HLSVariant gohlslib.MuxerVariant
// MarshalJSON implements json.Marshaler.
func (d HLSVariant) MarshalJSON() ([]byte, error) {
var out string
switch d {
case HLSVariant(gohlslib.MuxerVariantMPEGTS):
out = "mpegts"
case HLSVariant(gohlslib.MuxerVariantFMP4):
out = "fmp4"
default:
out = "lowLatency"
}
return json.Marshal(out)
}
// UnmarshalJSON implements json.Unmarshaler.
func (d *HLSVariant) UnmarshalJSON(b []byte) error {
var in string
if err := jsonwrapper.Unmarshal(b, &in); err != nil {
return err
}
switch in {
case "mpegts":
*d = HLSVariant(gohlslib.MuxerVariantMPEGTS)
case "fmp4":
*d = HLSVariant(gohlslib.MuxerVariantFMP4)
case "lowLatency":
*d = HLSVariant(gohlslib.MuxerVariantLowLatency)
default:
return fmt.Errorf("invalid HLS variant: '%s'", in)
}
return nil
}
// UnmarshalEnv implements env.Unmarshaler.
func (d *HLSVariant) UnmarshalEnv(_ string, v string) error {
return d.UnmarshalJSON([]byte(`"` + v + `"`))
}
================================================
FILE: internal/conf/ip_network.go
================================================
package conf
import (
"encoding/json"
"fmt"
"net"
"github.com/bluenviron/mediamtx/internal/conf/jsonwrapper"
)
// IPNetwork represents an IP network.
type IPNetwork net.IPNet
// MarshalJSON implements json.Marshaler.
func (n IPNetwork) MarshalJSON() ([]byte, error) {
return json.Marshal(n.String())
}
// UnmarshalJSON implements json.Unmarshaler.
func (n *IPNetwork) UnmarshalJSON(b []byte) error {
var t string
if err := jsonwrapper.Unmarshal(b, &t); err != nil {
return err
}
if _, ipnet, err := net.ParseCIDR(t); err == nil {
if ipv4 := ipnet.IP.To4(); ipv4 != nil {
*n = IPNetwork{IP: ipv4, Mask: ipnet.Mask[len(ipnet.Mask)-4 : len(ipnet.Mask)]}
} else {
*n = IPNetwork(*ipnet)
}
} else if ip := net.ParseIP(t); ip != nil {
if ipv4 := ip.To4(); ipv4 != nil {
*n = IPNetwork{IP: ipv4, Mask: net.CIDRMask(32, 32)}
} else {
*n = IPNetwork{IP: ip, Mask: net.CIDRMask(128, 128)}
}
} else {
return fmt.Errorf("unable to parse IP/CIDR '%s'", t)
}
return nil
}
// String implements fmt.Stringer.
func (n IPNetwork) String() string {
ipnet := net.IPNet(n)
return ipnet.String()
}
// Contains checks whether the IP is part of the network.
func (n IPNetwork) Contains(ip net.IP) bool {
ipnet := net.IPNet(n)
return ipnet.Contains(ip)
}
================================================
FILE: internal/conf/ip_networks.go
================================================
package conf
import (
"encoding/json"
"net"
"strings"
"github.com/bluenviron/mediamtx/internal/conf/jsonwrapper"
)
// IPNetworks is a parameter that contains a list of IP networks.
type IPNetworks []IPNetwork
// UnmarshalEnv implements env.Unmarshaler.
func (d *IPNetworks) UnmarshalEnv(_ string, v string) error {
byts, _ := json.Marshal(strings.Split(v, ","))
return jsonwrapper.Unmarshal(byts, d)
}
// ToTrustedProxies converts IPNetworks into a string slice for SetTrustedProxies.
func (d *IPNetworks) ToTrustedProxies() []string {
ret := make([]string, len(*d))
for i, entry := range *d {
ret[i] = entry.String()
}
return ret
}
// Contains checks whether the IP is part of one of the networks.
func (d IPNetworks) Contains(ip net.IP) bool {
for _, network := range d {
if network.Contains(ip) {
return true
}
}
return false
}
================================================
FILE: internal/conf/jsonwrapper/testdata/fuzz/FuzzUnmarshal/297c43aee5d30530
================================================
go test fuzz v1
[]byte("[0\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n")
================================================
FILE: internal/conf/jsonwrapper/testdata/fuzz/FuzzUnmarshal/7f71a2d116d5afde
================================================
go test fuzz v1
[]byte("null")
================================================
FILE: internal/conf/jsonwrapper/unmarshal.go
================================================
// Package jsonwrapper contains a JSON unmarshaler.
package jsonwrapper
import (
"bytes"
"encoding/json"
"fmt"
"io"
"reflect"
"strings"
)
// differences with respect to the standard package:
// - JSON cannot contain unknown fields
// - existing elements of slices are never used, fixing https://github.com/golang/go/issues/21092
// - slices cannot be set to nil
func jsonFieldKey(f reflect.StructField) string {
tag := f.Tag.Get("json")
if tag == "" || tag == "-" {
return ""
}
return strings.Split(tag, ",")[0]
}
func isJSONNull(raw json.RawMessage) bool {
return string(bytes.TrimSpace(raw)) == "null"
}
func needsCustomDecode(t reflect.Type) bool {
for t.Kind() == reflect.Ptr {
t = t.Elem()
}
return t.Kind() == reflect.Struct || t.Kind() == reflect.Slice
}
func checkForUnknownFields(rawMap map[string]json.RawMessage, known map[string]int, path string) error {
for k := range rawMap {
if _, ok := known[k]; !ok {
if path != "" {
return fmt.Errorf("json: unknown field %q", path+"."+k)
}
return fmt.Errorf("json: unknown field %q", k)
}
}
return nil
}
func decode(v reflect.Value, raw json.RawMessage, path string) error {
for v.Kind() == reflect.Ptr {
if isJSONNull(raw) {
v.Set(reflect.Zero(v.Type()))
return nil
}
if v.IsNil() {
v.Set(reflect.New(v.Type().Elem()))
}
v = v.Elem()
}
if unm, ok := v.Addr().Interface().(json.Unmarshaler); ok {
return unm.UnmarshalJSON(raw)
}
switch v.Kind() {
case reflect.Struct:
var rawMap map[string]json.RawMessage
err := json.Unmarshal(raw, &rawMap)
if err != nil {
return err
}
vType := v.Type()
known := make(map[string]int, v.NumField())
for i := 0; i < v.NumField(); i++ {
if key := jsonFieldKey(vType.Field(i)); key != "" {
known[key] = i
}
}
err = checkForUnknownFields(rawMap, known, path)
if err != nil {
return err
}
for key, fieldIdx := range known {
rawVal, ok := rawMap[key]
if !ok {
continue
}
fieldPath := key
if path != "" {
fieldPath = path + "." + key
}
err = decode(v.Field(fieldIdx), rawVal, fieldPath)
if err != nil {
return err
}
}
return nil
case reflect.Slice:
if isJSONNull(raw) {
if path != "" {
return fmt.Errorf("cannot set slice %q to nil", path)
}
return fmt.Errorf("cannot set slice to nil")
}
if !v.IsNil() {
v.Set(reflect.Zero(v.Type()))
}
elemType := v.Type().Elem()
if needsCustomDecode(elemType) {
var rawElems []json.RawMessage
if err := json.Unmarshal(raw, &rawElems); err != nil {
return err
}
slice := reflect.MakeSlice(v.Type(), len(rawElems), len(rawElems))
for i, re := range rawElems {
err := decode(slice.Index(i), re, fmt.Sprintf("%s[%d]", path, i))
if err != nil {
return err
}
}
v.Set(slice)
return nil
}
return json.Unmarshal(raw, v.Addr().Interface())
default:
return json.Unmarshal(raw, v.Addr().Interface())
}
}
// Unmarshal decodes JSON.
func Unmarshal(buf []byte, dest any) error {
return Decode(bytes.NewReader(buf), dest)
}
// Decode decodes JSON.
func Decode(r io.Reader, dest any) error {
buf, err := io.ReadAll(r)
if err != nil {
return err
}
return decode(reflect.ValueOf(dest).Elem(), buf, "")
}
================================================
FILE: internal/conf/jsonwrapper/unmarshal_test.go
================================================
package jsonwrapper
import (
"encoding/json"
"strings"
"testing"
"github.com/stretchr/testify/require"
)
type testStruct struct {
Field1 string `json:"field1"`
Field2 int `json:"field2"`
}
func TestUnmarshalUnknownFields(t *testing.T) {
input := strings.NewReader(`{"field1": "test", "unknownField": "value", "field2": 456}`)
var result testStruct
err := Decode(input, &result)
require.Error(t, err)
require.EqualError(t, err, "json: unknown field \"unknownField\"")
}
func TestUnmarshalPreventSliceReuse(t *testing.T) {
t.Run("a", func(t *testing.T) {
type Person struct {
Name string `json:"name"`
Age int `json:"age"`
}
slice := []Person{
{Name: "John", Age: 30},
{Name: "Jane", Age: 25},
}
json := []byte(`[{"name": "Bob"}]`)
err := Unmarshal(json, &slice)
require.NoError(t, err)
require.Equal(t, []Person{{
Name: "Bob",
Age: 0,
}}, slice)
})
t.Run("b", func(t *testing.T) {
type Config struct {
Name string `json:"name"`
Enabled bool `json:"enabled"`
Port int `json:"port"`
}
type Settings struct {
Configs []Config `json:"configs"`
}
settings := Settings{
Configs: []Config{
{Name: "old1", Enabled: true, Port: 8080},
{Name: "old2", Enabled: false, Port: 9090},
{Name: "old3", Enabled: true, Port: 7070},
},
}
json := []byte(`{"configs": [{"name": "new1"}, {"name": "new2"}]}`)
err := Unmarshal(json, &settings)
require.NoError(t, err)
require.Equal(t, Settings{
Configs: []Config{
{Name: "new1", Enabled: false, Port: 0},
{Name: "new2", Enabled: false, Port: 0},
},
}, settings)
})
}
func TestUnmarshalSetSliceToNil(t *testing.T) {
t.Run("top level", func(t *testing.T) {
type Data struct {
Items []string `json:"items"`
}
var data Data
json := []byte(`{"items": null}`)
err := Unmarshal(json, &data)
require.EqualError(t, err, "cannot set slice \"items\" to nil")
data = Data{Items: []string{"a", "b"}}
json = []byte(`{"items": null}`)
err = Unmarshal(json, &data)
require.EqualError(t, err, "cannot set slice \"items\" to nil")
})
t.Run("nested", func(t *testing.T) {
type Inner struct {
Values []int `json:"values"`
}
type Outer struct {
Inner Inner `json:"inner"`
}
var data Outer
json := []byte(`{"inner": {"values": null}}`)
err := Unmarshal(json, &data)
require.EqualError(t, err, "cannot set slice \"inner.values\" to nil")
})
}
func TestUnmarshalSetNullableSliceToNil(t *testing.T) {
type Data struct {
Items *[]string `json:"items"`
}
var data Data
json := []byte(`{"items": null}`)
err := Unmarshal(json, &data)
require.NoError(t, err)
data = Data{Items: &[]string{"a", "b"}}
json = []byte(`{"items": null}`)
err = Unmarshal(json, &data)
require.NoError(t, err)
}
type testStructWithUnmarshaler struct {
Field1 string `json:"field1"`
}
func (s *testStructWithUnmarshaler) UnmarshalJSON(b []byte) error {
var t string
if err := json.Unmarshal(b, &t); err != nil {
return err
}
s.Field1 = t
return nil
}
func TestUnmarshalStructWithCustomUnmarshalerFromString(t *testing.T) {
var data testStructWithUnmarshaler
json := []byte(`"testing"`)
err := Unmarshal(json, &data)
require.NoError(t, err)
require.Equal(t, &testStructWithUnmarshaler{Field1: "testing"}, &data)
}
func FuzzUnmarshal(f *testing.F) {
f.Fuzz(func(_ *testing.T, buf []byte) {
var dest any
Unmarshal(buf, &dest) //nolint:errcheck
})
}
================================================
FILE: internal/conf/log_destination.go
================================================
package conf
import (
"encoding/json"
"fmt"
"github.com/bluenviron/mediamtx/internal/conf/jsonwrapper"
"github.com/bluenviron/mediamtx/internal/logger"
)
// LogDestination represents a log destination.
type LogDestination logger.Destination
// MarshalJSON implements json.Marshaler.
func (d LogDestination) MarshalJSON() ([]byte, error) {
switch d {
case LogDestination(logger.DestinationStdout):
return json.Marshal("stdout")
case LogDestination(logger.DestinationFile):
return json.Marshal("file")
default:
return json.Marshal("syslog")
}
}
// UnmarshalJSON implements json.Unmarshaler.
func (d *LogDestination) UnmarshalJSON(b []byte) error {
var in string
if err := jsonwrapper.Unmarshal(b, &in); err != nil {
return err
}
switch in {
case "stdout":
*d = LogDestination(logger.DestinationStdout)
case "file":
*d = LogDestination(logger.DestinationFile)
case "syslog":
*d = LogDestination(logger.DestinationSyslog)
default:
return fmt.Errorf("invalid log destination: %s", in)
}
return nil
}
================================================
FILE: internal/conf/log_destinations.go
================================================
package conf
import (
"encoding/json"
"strings"
"github.com/bluenviron/mediamtx/internal/conf/jsonwrapper"
"github.com/bluenviron/mediamtx/internal/logger"
)
// LogDestinations is the logDestionations parameter.
type LogDestinations []LogDestination
// UnmarshalEnv implements env.Unmarshaler.
func (d *LogDestinations) UnmarshalEnv(_ string, v string) error {
byts, _ := json.Marshal(strings.Split(v, ","))
return jsonwrapper.Unmarshal(byts, d)
}
// ToDestinations converts to logger.Destination slice.
func (d LogDestinations) ToDestinations() []logger.Destination {
out := make([]logger.Destination, len(d))
for i, v := range d {
out[i] = logger.Destination(v)
}
return out
}
================================================
FILE: internal/conf/log_level.go
================================================
package conf
import (
"encoding/json"
"fmt"
"github.com/bluenviron/mediamtx/internal/conf/jsonwrapper"
"github.com/bluenviron/mediamtx/internal/logger"
)
// LogLevel is the logLevel parameter.
type LogLevel logger.Level
// MarshalJSON implements json.Marshaler.
func (d LogLevel) MarshalJSON() ([]byte, error) {
var out string
switch d {
case LogLevel(logger.Error):
out = "error"
case LogLevel(logger.Warn):
out = "warn"
case LogLevel(logger.Info):
out = "info"
default:
out = "debug"
}
return json.Marshal(out)
}
// UnmarshalJSON implements json.Unmarshaler.
func (d *LogLevel) UnmarshalJSON(b []byte) error {
var in string
if err := jsonwrapper.Unmarshal(b, &in); err != nil {
return err
}
switch in {
case "error":
*d = LogLevel(logger.Error)
case "warn":
*d = LogLevel(logger.Warn)
case "info":
*d = LogLevel(logger.Info)
case "debug":
*d = LogLevel(logger.Debug)
default:
return fmt.Errorf("invalid log level: '%s'", in)
}
return nil
}
// UnmarshalEnv implements env.Unmarshaler.
func (d *LogLevel) UnmarshalEnv(_ string, v string) error {
return d.UnmarshalJSON([]byte(`"` + v + `"`))
}
================================================
FILE: internal/conf/optional_global.go
================================================
package conf
import (
"encoding/json"
"reflect"
"strings"
"github.com/bluenviron/mediamtx/internal/conf/jsonwrapper"
)
var optionalGlobalValuesType = func() reflect.Type {
var fields []reflect.StructField
rt := reflect.TypeOf(Conf{})
nf := rt.NumField()
for i := range nf {
f := rt.Field(i)
j := f.Tag.Get("json")
if j != "-" && j != "pathDefaults" && j != "paths" {
if !strings.Contains(j, ",omitempty") {
j += ",omitempty"
}
typ := f.Type
if typ.Kind() != reflect.Pointer {
typ = reflect.PointerTo(typ)
}
fields = append(fields, reflect.StructField{
Name: f.Name,
Type: typ,
Tag: reflect.StructTag(`json:"` + j + `"`),
})
}
}
return reflect.StructOf(fields)
}()
func newOptionalGlobalValues() any {
return reflect.New(optionalGlobalValuesType).Interface()
}
// OptionalGlobal is a Conf whose values can all be optional.
type OptionalGlobal struct {
Values any
}
// UnmarshalJSON implements json.Unmarshaler.
func (p *OptionalGlobal) UnmarshalJSON(b []byte) error {
p.Values = newOptionalGlobalValues()
return jsonwrapper.Unmarshal(b, p.Values)
}
// MarshalJSON implements json.Marshaler.
func (p *OptionalGlobal) MarshalJSON() ([]byte, error) {
return json.Marshal(p.Values)
}
================================================
FILE: internal/conf/optional_path.go
================================================
package conf
import (
"encoding/json"
"reflect"
"strings"
"github.com/bluenviron/mediamtx/internal/conf/env"
"github.com/bluenviron/mediamtx/internal/conf/jsonwrapper"
)
var optionalPathValuesType = func() reflect.Type {
var fields []reflect.StructField
rt := reflect.TypeOf(Path{})
nf := rt.NumField()
for i := range nf {
f := rt.Field(i)
j := f.Tag.Get("json")
if j != "-" {
if !strings.Contains(j, ",omitempty") {
j += ",omitempty"
}
typ := f.Type
if typ.Kind() != reflect.Pointer {
typ = reflect.PointerTo(typ)
}
fields = append(fields, reflect.StructField{
Name: f.Name,
Type: typ,
Tag: reflect.StructTag(`json:"` + j + `"`),
})
}
}
return reflect.StructOf(fields)
}()
func newOptionalPathValues() any {
return reflect.New(optionalPathValuesType).Interface()
}
// OptionalPath is a Path whose values can all be optional.
type OptionalPath struct {
Values any
}
// UnmarshalJSON implements json.Unmarshaler.
func (p *OptionalPath) UnmarshalJSON(b []byte) error {
p.Values = newOptionalPathValues()
return jsonwrapper.Unmarshal(b, p.Values)
}
// UnmarshalEnv implements env.Unmarshaler.
func (p *OptionalPath) UnmarshalEnv(prefix string, _ string) error {
if p.Values == nil {
p.Values = newOptionalPathValues()
}
return env.Load(prefix, p.Values)
}
// MarshalJSON implements json.Marshaler.
func (p *OptionalPath) MarshalJSON() ([]byte, error) {
return json.Marshal(p.Values)
}
================================================
FILE: internal/conf/path.go
================================================
package conf
import (
"bytes"
"fmt"
"io"
"net"
"net/url"
"os"
"reflect"
"regexp"
"sort"
"strings"
"time"
"github.com/bluenviron/gortsplib/v5/pkg/base"
"github.com/bluenviron/mediacommon/v2/pkg/formats/mp4/codecs"
"github.com/bluenviron/mediacommon/v2/pkg/formats/pmp4"
"github.com/bluenviron/mediamtx/internal/logger"
)
var rePathName = regexp.MustCompile(`^[0-9a-zA-Z_\-/\.~:]+$`)
// IsValidPathName checks whether the path name is valid.
func IsValidPathName(name string) error {
if name == "" {
return fmt.Errorf("cannot be empty")
}
if name[0] == '/' {
return fmt.Errorf("can't begin with a slash")
}
if name[len(name)-1] == '/' {
return fmt.Errorf("can't end with a slash")
}
if !rePathName.MatchString(name) {
return fmt.Errorf("can contain only alphanumeric characters, underscore, dot, tilde, minus, slash, colon")
}
return nil
}
func checkSRTPassphrase(passphrase string) error {
switch {
case len(passphrase) < 10 || len(passphrase) > 79:
return fmt.Errorf("must be between 10 and 79 characters")
default:
return nil
}
}
func checkRedirect(v string) error {
if strings.HasPrefix(v, "/") {
err := IsValidPathName(v[1:])
if err != nil {
return fmt.Errorf("'%s': %w", v, err)
}
} else {
_, err := base.ParseURL(v)
if err != nil {
return fmt.Errorf("'%s' is not a valid RTSP URL", v)
}
}
return nil
}
func checkMP4MagicBytes(f io.ReadSeeker) error {
magicBytes := make([]byte, 4)
_, err := f.Seek(4, io.SeekStart)
if err != nil {
return err
}
_, err = io.ReadFull(f, magicBytes)
if err != nil {
return err
}
if !bytes.Equal(magicBytes, []byte("ftyp")) {
return fmt.Errorf("file is not MP4, magic bytes are %v", magicBytes)
}
_, err = f.Seek(0, io.SeekStart)
if err != nil {
return err
}
return nil
}
func checkAlwaysAvailableFile(fpath string) error {
f, err := os.Open(fpath)
if err != nil {
return err
}
defer f.Close()
err = checkMP4MagicBytes(f)
if err != nil {
return err
}
var presentation pmp4.Presentation
err = presentation.Unmarshal(f)
if err != nil {
return err
}
if len(presentation.Tracks) == 0 {
return fmt.Errorf("file does not contain any track")
}
for _, track := range presentation.Tracks {
switch track.Codec.(type) {
case *codecs.AV1, *codecs.VP9, *codecs.H265, *codecs.H264, *codecs.Opus, *codecs.MPEG4Audio, *codecs.LPCM:
default:
return fmt.Errorf("unsupported codec %T", track.Codec)
}
}
return nil
}
// FindPathConf returns the configuration corresponding to the given path name.
func FindPathConf(pathConfs map[string]*Path, name string) (*Path, []string, error) {
// normal path
if pathConf, ok := pathConfs[name]; ok {
return pathConf, nil, nil
}
err := IsValidPathName(name)
if err != nil {
return nil, nil, fmt.Errorf("invalid path name: %w (%s)", err, name)
}
// gather and sort all regexp-based path configs
var regexpPathConfs []*Path
for _, pathConf := range pathConfs {
if pathConf.Regexp != nil {
regexpPathConfs = append(regexpPathConfs, pathConf)
}
}
sort.Slice(regexpPathConfs, func(i, j int) bool {
// keep all and all_others at the end
if regexpPathConfs[i].Name == "all" || regexpPathConfs[i].Name == "all_others" {
return false
}
if regexpPathConfs[j].Name == "all" || regexpPathConfs[j].Name == "all_others" {
return true
}
return regexpPathConfs[i].Name < regexpPathConfs[j].Name
})
// check path against regexp-based path configs
for _, pathConf := range regexpPathConfs {
m := pathConf.Regexp.FindStringSubmatch(name)
if m != nil {
return pathConf, m, nil
}
}
return nil, nil, fmt.Errorf("path '%s' is not configured", name)
}
// Path is a path configuration.
type Path struct {
Regexp *regexp.Regexp `json:"-"` // filled by Validate()
Name string `json:"name"` // filled by Validate()
// General
Source string `json:"source"`
SourceFingerprint string `json:"sourceFingerprint"`
SourceOnDemand bool `json:"sourceOnDemand"`
SourceOnDemandStartTimeout Duration `json:"sourceOnDemandStartTimeout"`
SourceOnDemandCloseAfter Duration `json:"sourceOnDemandCloseAfter"`
MaxReaders int `json:"maxReaders"`
SRTReadPassphrase string `json:"srtReadPassphrase"`
Fallback *string `json:"fallback,omitempty" deprecated:"true"`
UseAbsoluteTimestamp bool `json:"useAbsoluteTimestamp"`
// Always available
AlwaysAvailable bool `json:"alwaysAvailable"`
AlwaysAvailableTracks []AlwaysAvailableTrack `json:"alwaysAvailableTracks"`
AlwaysAvailableFile string `json:"alwaysAvailableFile"`
// Record
Record bool `json:"record"`
Playback *bool `json:"playback,omitempty" deprecated:"true"`
RecordPath string `json:"recordPath"`
RecordFormat RecordFormat `json:"recordFormat"`
RecordPartDuration Duration `json:"recordPartDuration"`
RecordMaxPartSize StringSize `json:"recordMaxPartSize"`
RecordSegmentDuration Duration `json:"recordSegmentDuration"`
RecordDeleteAfter Duration `json:"recordDeleteAfter"`
// Authentication (deprecated)
PublishUser *Credential `json:"publishUser,omitempty" deprecated:"true"`
PublishPass *Credential `json:"publishPass,omitempty" deprecated:"true"`
PublishIPs *IPNetworks `json:"publishIPs,omitempty" deprecated:"true"`
ReadUser *Credential `json:"readUser,omitempty" deprecated:"true"`
ReadPass *Credential `json:"readPass,omitempty" deprecated:"true"`
ReadIPs *IPNetworks `json:"readIPs,omitempty" deprecated:"true"`
// Publisher source
OverridePublisher bool `json:"overridePublisher"`
DisablePublisherOverride *bool `json:"disablePublisherOverride,omitempty" deprecated:"true"`
SRTPublishPassphrase string `json:"srtPublishPassphrase"`
RTSPDemuxMpegts bool `json:"rtspDemuxMpegts"`
// RTSP source
RTSPTransport RTSPTransport `json:"rtspTransport"`
RTSPAnyPort bool `json:"rtspAnyPort"`
SourceProtocol *RTSPTransport `json:"sourceProtocol,omitempty" deprecated:"true"`
SourceAnyPortEnable *bool `json:"sourceAnyPortEnable,omitempty" deprecated:"true"`
RTSPRangeType RTSPRangeType `json:"rtspRangeType"`
RTSPRangeStart string `json:"rtspRangeStart"`
RTSPUDPReadBufferSize *uint `json:"rtspUDPReadBufferSize,omitempty" deprecated:"true"`
RTSPUDPSourcePortRange []uint `json:"rtspUDPSourcePortRange"`
// MPEG-TS source
MPEGTSUDPReadBufferSize *uint `json:"mpegtsUDPReadBufferSize,omitempty" deprecated:"true"`
// RTP source
RTPSDP string `json:"rtpSDP"`
RTPUDPReadBufferSize *uint `json:"rtpUDPReadBufferSize,omitempty" deprecated:"true"`
// WHEP source
WHEPBearerToken string `json:"whepBearerToken"`
WHEPSTUNGatherTimeout Duration `json:"whepSTUNGatherTimeout"`
WHEPHandshakeTimeout Duration `json:"whepHandshakeTimeout"`
WHEPTrackGatherTimeout Duration `json:"whepTrackGatherTimeout"`
// Redirect source
SourceRedirect string `json:"sourceRedirect"`
// Raspberry Pi Camera source
RPICameraCamID uint `json:"rpiCameraCamID"`
RPICameraSecondary bool `json:"rpiCameraSecondary"`
RPICameraWidth uint `json:"rpiCameraWidth"`
RPICameraHeight uint `json:"rpiCameraHeight"`
RPICameraHFlip bool `json:"rpiCameraHFlip"`
RPICameraVFlip bool `json:"rpiCameraVFlip"`
RPICameraBrightness float64 `json:"rpiCameraBrightness"`
RPICameraContrast float64 `json:"rpiCameraContrast"`
RPICameraSaturation float64 `json:"rpiCameraSaturation"`
RPICameraSharpness float64 `json:"rpiCameraSharpness"`
RPICameraExposure string `json:"rpiCameraExposure"`
RPICameraAWB string `json:"rpiCameraAWB"`
RPICameraAWBGains []float64 `json:"rpiCameraAWBGains"`
RPICameraDenoise string `json:"rpiCameraDenoise"`
RPICameraShutter uint `json:"rpiCameraShutter"`
RPICameraMetering string `json:"rpiCameraMetering"`
RPICameraGain float64 `json:"rpiCameraGain"`
RPICameraEV float64 `json:"rpiCameraEV"`
RPICameraROI string `json:"rpiCameraROI"`
RPICameraHDR bool `json:"rpiCameraHDR"`
RPICameraTuningFile string `json:"rpiCameraTuningFile"`
RPICameraMode string `json:"rpiCameraMode"`
RPICameraFPS float64 `json:"rpiCameraFPS"`
RPICameraAfMode string `json:"rpiCameraAfMode"`
RPICameraAfRange string `json:"rpiCameraAfRange"`
RPICameraAfSpeed string `json:"rpiCameraAfSpeed"`
RPICameraLensPosition float64 `json:"rpiCameraLensPosition"`
RPICameraAfWindow string `json:"rpiCameraAfWindow"`
RPICameraFlickerPeriod uint `json:"rpiCameraFlickerPeriod"`
RPICameraTextOverlayEnable bool `json:"rpiCameraTextOverlayEnable"`
RPICameraTextOverlay string `json:"rpiCameraTextOverlay"`
RPICameraCodec string `json:"rpiCameraCodec"`
RPICameraIDRPeriod uint `json:"rpiCameraIDRPeriod"`
RPICameraBitrate uint `json:"rpiCameraBitrate"`
RPICameraProfile *string `json:"rpiCameraProfile,omitempty" deprecated:"true"`
RPICameraLevel *string `json:"rpiCameraLevel,omitempty" deprecated:"true"`
RPICameraHardwareH264Profile string `json:"rpiCameraHardwareH264Profile"`
RPICameraHardwareH264Level string `json:"rpiCameraHardwareH264Level"`
RPICameraSoftwareH264Profile string `json:"rpiCameraSoftwareH264Profile"`
RPICameraSoftwareH264Level string `json:"rpiCameraSoftwareH264Level"`
RPICameraJPEGQuality *uint `json:"rpiCameraJPEGQuality,omitempty" deprecated:"true"`
RPICameraMJPEGQuality uint `json:"rpiCameraMJPEGQuality"`
RPICameraPrimaryName string `json:"-"` // filled by Validate()
RPICameraSecondaryWidth uint `json:"-"` // filled by Validate()
RPICameraSecondaryHeight uint `json:"-"` // filled by Validate()
RPICameraSecondaryFPS float64 `json:"-"` // filled by Validate()
RPICameraSecondaryMJPEGQuality uint `json:"-"` // filled by Validate()
// Hooks
RunOnInit string `json:"runOnInit"`
RunOnInitRestart bool `json:"runOnInitRestart"`
RunOnDemand string `json:"runOnDemand"`
RunOnDemandRestart bool `json:"runOnDemandRestart"`
RunOnDemandStartTimeout Duration `json:"runOnDemandStartTimeout"`
RunOnDemandCloseAfter Duration `json:"runOnDemandCloseAfter"`
RunOnUnDemand string `json:"runOnUnDemand"`
RunOnReady string `json:"runOnReady"`
RunOnReadyRestart bool `json:"runOnReadyRestart"`
RunOnNotReady string `json:"runOnNotReady"`
RunOnRead string `json:"runOnRead"`
RunOnReadRestart bool `json:"runOnReadRestart"`
RunOnUnread string `json:"runOnUnread"`
RunOnRecordSegmentCreate string `json:"runOnRecordSegmentCreate"`
RunOnRecordSegmentComplete string `json:"runOnRecordSegmentComplete"`
}
func (pconf *Path) setDefaults() {
// General
pconf.Source = "publisher"
pconf.SourceOnDemandStartTimeout = 10 * Duration(time.Second)
pconf.SourceOnDemandCloseAfter = 10 * Duration(time.Second)
// Record
pconf.RecordPath = "./recordings/%path/%Y-%m-%d_%H-%M-%S-%f"
pconf.RecordFormat = RecordFormatFMP4
pconf.RecordPartDuration = Duration(1 * time.Second)
pconf.RecordMaxPartSize = 50 * 1024 * 1024
pconf.RecordSegmentDuration = 3600 * Duration(time.Second)
pconf.RecordDeleteAfter = 24 * 3600 * Duration(time.Second)
// Publisher source
pconf.OverridePublisher = true
// RTSP source
pconf.RTSPUDPSourcePortRange = []uint{10000, 65535}
// WHEP source
pconf.WHEPSTUNGatherTimeout = Duration(5 * time.Second)
pconf.WHEPHandshakeTimeout = Duration(10 * time.Second)
pconf.WHEPTrackGatherTimeout = Duration(2 * time.Second)
// Raspberry Pi Camera source
pconf.RPICameraWidth = 1920
pconf.RPICameraHeight = 1080
pconf.RPICameraContrast = 1
pconf.RPICameraSaturation = 1
pconf.RPICameraSharpness = 1
pconf.RPICameraExposure = "normal"
pconf.RPICameraAWB = "auto"
pconf.RPICameraAWBGains = []float64{0, 0}
pconf.RPICameraDenoise = "off"
pconf.RPICameraMetering = "centre"
pconf.RPICameraFPS = 30
pconf.RPICameraAfMode = "continuous"
pconf.RPICameraAfRange = "normal"
pconf.RPICameraAfSpeed = "normal"
pconf.RPICameraTextOverlay = "%Y-%m-%d %H:%M:%S - MediaMTX"
pconf.RPICameraCodec = "auto"
pconf.RPICameraIDRPeriod = 60
pconf.RPICameraBitrate = 5000000
pconf.RPICameraHardwareH264Profile = "main"
pconf.RPICameraHardwareH264Level = "4.1"
pconf.RPICameraSoftwareH264Profile = "baseline"
pconf.RPICameraSoftwareH264Level = "4.1"
pconf.RPICameraMJPEGQuality = 60
// Hooks
pconf.RunOnDemandStartTimeout = 10 * Duration(time.Second)
pconf.RunOnDemandCloseAfter = 10 * Duration(time.Second)
}
func newPath(defaults *Path, partial *OptionalPath) *Path {
pconf := &Path{}
copyStructFields(pconf, defaults)
copyStructFields(pconf, partial.Values)
return pconf
}
// Clone clones the configuration.
func (pconf Path) Clone() *Path {
cloned := deepClone(reflect.ValueOf(pconf)).Interface().(Path)
return &cloned
}
func (pconf *Path) validate(
conf *Conf,
name string,
deprecatedCredentialsMode bool,
l logger.Writer,
) error {
pconf.Name = name
switch {
case name == "all_others", name == "all":
pconf.Regexp = regexp.MustCompile("^.*$")
case name == "" || name[0] != '~': // normal path
err := IsValidPathName(name)
if err != nil {
return fmt.Errorf("invalid path name '%s': %w", name, err)
}
default: // regular expression-based path
regexp, err := regexp.Compile(name[1:])
if err != nil {
return fmt.Errorf("invalid regular expression: %s", name[1:])
}
pconf.Regexp = regexp
}
// common configuration errors
if pconf.SRTPublishPassphrase != "" && pconf.Source != "publisher" {
return fmt.Errorf("'srtPublishPassphase' can only be used when source is 'publisher'")
}
if pconf.Source != "redirect" && pconf.SourceRedirect != "" {
return fmt.Errorf("'sourceRedirect' is useless when source is not 'redirect'")
}
// General
switch {
case pconf.Source == "publisher":
if pconf.DisablePublisherOverride != nil {
l.Log(logger.Warn, "parameter 'disablePublisherOverride' is deprecated "+
"and has been replaced with 'overridePublisher'")
pconf.OverridePublisher = !*pconf.DisablePublisherOverride
}
if pconf.SRTPublishPassphrase != "" {
err := checkSRTPassphrase(pconf.SRTPublishPassphrase)
if err != nil {
return fmt.Errorf("invalid 'srtPublishPassphrase': %w", err)
}
}
case strings.HasPrefix(pconf.Source, "rtsp://") ||
strings.HasPrefix(pconf.Source, "rtsps://") ||
strings.HasPrefix(pconf.Source, "rtsp+http://") ||
strings.HasPrefix(pconf.Source, "rtsps+http://") ||
strings.HasPrefix(pconf.Source, "rtsp+ws://") ||
strings.HasPrefix(pconf.Source, "rtsps+ws://"):
_, err := url.Parse(pconf.Source)
if err != nil {
return fmt.Errorf("'%s' is not a valid URL", pconf.Source)
}
if pconf.SourceProtocol != nil {
l.Log(logger.Warn, "parameter 'sourceProtocol' is deprecated and has been replaced with 'rtspTransport'")
pconf.RTSPTransport = *pconf.SourceProtocol
}
if pconf.SourceAnyPortEnable != nil {
l.Log(logger.Warn, "parameter 'sourceAnyPortEnable' is deprecated and has been replaced with 'rtspAnyPort'")
pconf.RTSPAnyPort = *pconf.SourceAnyPortEnable
}
case strings.HasPrefix(pconf.Source, "rtmp://") ||
strings.HasPrefix(pconf.Source, "rtmps://"):
u, err := url.Parse(pconf.Source)
if err != nil {
return fmt.Errorf("'%s' is not a valid URL", pconf.Source)
}
if u.User != nil {
pass, _ := u.User.Password()
user := u.User.Username()
if user != "" && pass == "" ||
user == "" && pass != "" {
return fmt.Errorf("username and password must be both provided")
}
}
case strings.HasPrefix(pconf.Source, "http://") ||
strings.HasPrefix(pconf.Source, "https://"):
u, err := url.Parse(pconf.Source)
if err != nil {
return fmt.Errorf("'%s' is not a valid URL", pconf.Source)
}
if u.User != nil {
pass, _ := u.User.Password()
user := u.User.Username()
if user != "" && pass == "" ||
user == "" && pass != "" {
return fmt.Errorf("username and password must be both provided")
}
}
case strings.HasPrefix(pconf.Source, "udp://"):
_, _, err := net.SplitHostPort(pconf.Source[len("udp://"):])
if err != nil {
return fmt.Errorf("'%s' is not a valid UDP+MPEGTS URL", pconf.Source)
}
case strings.HasPrefix(pconf.Source, "udp+mpegts://"):
_, _, err := net.SplitHostPort(pconf.Source[len("udp+mpegts://"):])
if err != nil {
return fmt.Errorf("'%s' is not a valid UDP+MPEGTS URL", pconf.Source)
}
case strings.HasPrefix(pconf.Source, "unix+mpegts://"):
case strings.HasPrefix(pconf.Source, "udp+rtp://"):
_, _, err := net.SplitHostPort(pconf.Source[len("udp+rtp://"):])
if err != nil {
return fmt.Errorf("'%s' is not a valid UDP+RTP URL", pconf.Source)
}
if pconf.RTPSDP == "" {
return fmt.Errorf("`rtpSDP` was not provided")
}
case strings.HasPrefix(pconf.Source, "unix+rtp://"):
l.Log(logger.Warn, "source 'unix+rtp' is deprecated due to intrinsic instability, use 'udp+rtp' instead")
if pconf.RTPSDP == "" {
return fmt.Errorf("`rtpSDP` was not provided")
}
case strings.HasPrefix(pconf.Source, "srt://"):
_, err := url.Parse(pconf.Source)
if err != nil {
return fmt.Errorf("'%s' is not a valid URL", pconf.Source)
}
case strings.HasPrefix(pconf.Source, "whep://") ||
strings.HasPrefix(pconf.Source, "wheps://"):
_, err := url.Parse(pconf.Source)
if err != nil {
return fmt.Errorf("'%s' is not a valid URL", pconf.Source)
}
case pconf.Source == "redirect":
if pconf.SourceRedirect == "" {
return fmt.Errorf("source redirect must be filled")
}
err := checkRedirect(pconf.SourceRedirect)
if err != nil {
return err
}
case pconf.Source == "rpiCamera":
if pconf.RPICameraWidth == 0 {
return fmt.Errorf("invalid 'rpiCameraWidth' value")
}
if pconf.RPICameraHeight == 0 {
return fmt.Errorf("invalid 'rpiCameraHeight' value")
}
switch pconf.RPICameraExposure {
case "normal", "short", "long", "custom":
default:
return fmt.Errorf("invalid 'rpiCameraExposure' value")
}
switch pconf.RPICameraAWB {
case "auto", "incandescent", "tungsten", "fluorescent", "indoor", "daylight", "cloudy", "custom":
default:
return fmt.Errorf("invalid 'rpiCameraAWB' value")
}
if len(pconf.RPICameraAWBGains) != 2 {
return fmt.Errorf("invalid 'rpiCameraAWBGains' value")
}
switch pconf.RPICameraDenoise {
case "off", "cdn_off", "cdn_fast", "cdn_hq":
default:
return fmt.Errorf("invalid 'rpiCameraDenoise' value")
}
switch pconf.RPICameraMetering {
case "centre", "spot", "matrix", "custom":
default:
return fmt.Errorf("invalid 'rpiCameraMetering' value")
}
switch pconf.RPICameraAfMode {
case "auto", "manual", "continuous":
default:
return fmt.Errorf("invalid 'rpiCameraAfMode' value")
}
switch pconf.RPICameraAfRange {
case "normal", "macro", "full":
default:
return fmt.Errorf("invalid 'rpiCameraAfRange' value")
}
switch pconf.RPICameraAfSpeed {
case "normal", "fast":
default:
return fmt.Errorf("invalid 'rpiCameraAfSpeed' value")
}
if pconf.RPICameraProfile != nil {
l.Log(logger.Warn, "parameter 'rpiCameraProfile' is deprecated"+
" and has been replaced with 'rpiCameraHardwareH264Profile'")
pconf.RPICameraHardwareH264Profile = *pconf.RPICameraProfile
}
if pconf.RPICameraLevel != nil {
l.Log(logger.Warn, "parameter 'rpiCameraLevel' is deprecated"+
" and has been replaced with 'rpiCameraHardwareH264Level'")
pconf.RPICameraHardwareH264Level = *pconf.RPICameraLevel
}
switch pconf.RPICameraHardwareH264Profile {
case "baseline", "main", "high":
default:
return fmt.Errorf("invalid 'rpiCameraHardwareH264Profile' value")
}
switch pconf.RPICameraHardwareH264Level {
case "4.0", "4.1", "4.2":
default:
return fmt.Errorf("invalid 'rpiCameraHardwareH264Level' value")
}
switch pconf.RPICameraSoftwareH264Profile {
case "baseline", "main", "high":
default:
return fmt.Errorf("invalid 'rpiCameraSoftwareH264Profile' value")
}
switch pconf.RPICameraSoftwareH264Level {
case "4.0", "4.1", "4.2":
default:
return fmt.Errorf("invalid 'rpiCameraSoftwareH264Level' value")
}
if pconf.RPICameraJPEGQuality != nil {
l.Log(logger.Warn, "parameter 'rpiCameraJPEGQuality' is deprecated"+
" and has been replaced with 'rpiCameraMJPEGQuality'")
pconf.RPICameraMJPEGQuality = *pconf.RPICameraJPEGQuality
}
if !pconf.RPICameraSecondary {
switch pconf.RPICameraCodec {
case "auto", "hardwareH264", "softwareH264":
default:
return fmt.Errorf("supported codecs for a primary RPI Camera stream are auto, hardwareH264, softwareH264")
}
for otherName, otherPath := range conf.Paths {
if otherPath != pconf &&
otherPath != nil &&
otherPath.Source == "rpiCamera" &&
otherPath.RPICameraCamID == pconf.RPICameraCamID &&
!otherPath.RPICameraSecondary {
return fmt.Errorf("'rpiCamera' with same camera ID %d is used as source in two paths, '%s' and '%s'",
pconf.RPICameraCamID, name, otherName)
}
}
} else {
switch pconf.RPICameraCodec {
case "auto", "mjpeg":
default:
return fmt.Errorf("supported codecs for a secondary RPI Camera stream are auto, mjpeg")
}
var primaryName string
var primary *Path
for otherPathName, otherPath := range conf.Paths {
if otherPath != pconf &&
otherPath != nil &&
otherPath.Source == "rpiCamera" &&
otherPath.RPICameraCamID == pconf.RPICameraCamID &&
!otherPath.RPICameraSecondary {
primaryName = otherPathName
primary = otherPath
break
}
}
if primary == nil {
return fmt.Errorf("cannot find a primary RPI Camera stream to associate with the secondary stream")
}
if primary.RPICameraSecondaryWidth != 0 {
return fmt.Errorf("a primary RPI Camera stream is associated with multiple secondary streams")
}
pconf.RPICameraPrimaryName = primaryName
primary.RPICameraSecondaryWidth = pconf.RPICameraWidth
primary.RPICameraSecondaryHeight = pconf.RPICameraHeight
primary.RPICameraSecondaryFPS = pconf.RPICameraFPS
primary.RPICameraSecondaryMJPEGQuality = pconf.RPICameraMJPEGQuality
}
default:
return fmt.Errorf("invalid source: '%s'", pconf.Source)
}
if pconf.SourceOnDemand {
if pconf.Source == "publisher" {
return fmt.Errorf("'sourceOnDemand' is useless when source is 'publisher'")
}
} else {
if pconf.Source != "publisher" && pconf.Source != "redirect" && pconf.Regexp != nil {
return fmt.Errorf("a path with a regular expression (or path 'all') and a static source" +
" must have 'sourceOnDemand' set to true")
}
}
if pconf.SRTReadPassphrase != "" {
err := checkSRTPassphrase(pconf.SRTReadPassphrase)
if err != nil {
return fmt.Errorf("invalid 'readRTPassphrase': %w", err)
}
}
if pconf.Fallback != nil {
l.Log(logger.Warn, "the 'fallback' feature is deprecated, use 'alwaysAvailable' instead")
err := checkRedirect(*pconf.Fallback)
if err != nil {
return err
}
}
// Always available
if pconf.AlwaysAvailable {
if pconf.Regexp != nil {
return fmt.Errorf("'alwaysAvailable' cannot be used in a path with a regular expression (or path 'all')")
}
if pconf.SourceOnDemand {
return fmt.Errorf("'sourceOnDemand' is not compatible with 'alwaysAvailable'")
}
if pconf.RunOnDemand != "" || pconf.RunOnUnDemand != "" {
return fmt.Errorf("'runOnDemand' and 'runOnUnDemand' cannot be used with 'alwaysAvailable'")
}
if pconf.AlwaysAvailableFile != "" {
if len(pconf.AlwaysAvailableTracks) != 0 {
return fmt.Errorf("'alwaysAvailableFile' and 'alwaysAvailableTracks' cannot be used together")
}
err := checkAlwaysAvailableFile(pconf.AlwaysAvailableFile)
if err != nil {
return fmt.Errorf("invalid 'alwaysAvailableFile': %w", err)
}
} else if len(pconf.AlwaysAvailableTracks) == 0 {
return fmt.Errorf("'alwaysAvailableTracks' must contain at least one track")
}
if pconf.UseAbsoluteTimestamp {
return fmt.Errorf("'useAbsoluteTimestamp' cannot be used with 'alwaysAvailable'")
}
}
// Record
if pconf.Playback != nil {
l.Log(logger.Warn, "parameter 'playback' is deprecated and has no effect")
}
if !strings.Contains(pconf.RecordPath, "%path") {
return fmt.Errorf("'recordPath' must contain %%path")
}
if !strings.Contains(pconf.RecordPath, "%s") &&
(!strings.Contains(pconf.RecordPath, "%Y") ||
!strings.Contains(pconf.RecordPath, "%m") ||
!strings.Contains(pconf.RecordPath, "%d") ||
!strings.Contains(pconf.RecordPath, "%H") ||
!strings.Contains(pconf.RecordPath, "%M") ||
!strings.Contains(pconf.RecordPath, "%S")) {
return fmt.Errorf("'recordPath' must contain either %%s or %%Y %%m %%d %%H %%M %%S")
}
if conf.Playback && !strings.Contains(pconf.RecordPath, "%f") {
return fmt.Errorf("'recordPath' must contain %%f")
}
if pconf.RecordSegmentDuration > Duration(24*time.Hour) { // avoid overflowing DurationV0 of mvhd
return fmt.Errorf("maximum segment duration is 1 day")
}
if pconf.RecordDeleteAfter != 0 && pconf.RecordDeleteAfter < pconf.RecordSegmentDuration {
return fmt.Errorf("'recordDeleteAfter' cannot be lower than 'recordSegmentDuration'")
}
// Authentication (deprecated)
if deprecatedCredentialsMode {
func() {
var user Credential = "any"
if pconf.PublishUser != nil && *pconf.PublishUser != "" {
user = *pconf.PublishUser
}
var pass Credential
if pconf.PublishPass != nil && *pconf.PublishPass != "" {
pass = *pconf.PublishPass
}
ips := IPNetworks{mustParseCIDR("0.0.0.0/0")}
if pconf.PublishIPs != nil && len(*pconf.PublishIPs) != 0 {
ips = *pconf.PublishIPs
}
pathName := name
if name == "all_others" || name == "all" {
pathName = "~^.*$"
}
conf.AuthInternalUsers = append(conf.AuthInternalUsers, AuthInternalUser{
User: user,
Pass: pass,
IPs: ips,
Permissions: []AuthInternalUserPermission{{
Action: AuthActionPublish,
Path: pathName,
}},
})
}()
func() {
var user Credential = "any"
if pconf.ReadUser != nil && *pconf.ReadUser != "" {
user = *pconf.ReadUser
}
var pass Credential
if pconf.ReadPass != nil && *pconf.ReadPass != "" {
pass = *pconf.ReadPass
}
ips := IPNetworks{mustParseCIDR("0.0.0.0/0")}
if pconf.ReadIPs != nil && len(*pconf.ReadIPs) != 0 {
ips = *pconf.ReadIPs
}
pathName := name
if name == "all_others" || name == "all" {
pathName = "~^.*$"
}
conf.AuthInternalUsers = append(conf.AuthInternalUsers, AuthInternalUser{
User: user,
Pass: pass,
IPs: ips,
Permissions: []AuthInternalUserPermission{{
Action: AuthActionRead,
Path: pathName,
}},
})
}()
}
// Hooks
if pconf.RunOnInit != "" && pconf.Regexp != nil {
return fmt.Errorf("a path with a regular expression (or path 'all')" +
" does not support option 'runOnInit'; use another path")
}
if (pconf.RunOnDemand != "" || pconf.RunOnUnDemand != "") && pconf.Source != "publisher" {
return fmt.Errorf("'runOnDemand' and 'runOnUnDemand' can be used only when source is 'publisher'")
}
return nil
}
// Equal checks whether two Paths are equal.
func (pconf *Path) Equal(other *Path) bool {
return reflect.DeepEqual(pconf, other)
}
// HasStaticSource checks whether the path has a static source.
func (pconf Path) HasStaticSource() bool {
return pconf.Source != "publisher" && pconf.Source != "redirect"
}
// HasOnDemandStaticSource checks whether the path has a on demand static source.
func (pconf Path) HasOnDemandStaticSource() bool {
return pconf.HasStaticSource() && pconf.SourceOnDemand
}
// HasOnDemandPublisher checks whether the path has a on-demand publisher.
func (pconf Path) HasOnDemandPublisher() bool {
return pconf.RunOnDemand != ""
}
================================================
FILE: internal/conf/path_test.go
================================================
package conf
import (
"testing"
"github.com/bluenviron/gortsplib/v5"
"github.com/stretchr/testify/require"
)
func TestPathClone(t *testing.T) {
original := &Path{
Name: "example",
RTSPTransport: RTSPTransport{ptrOf(gortsplib.ProtocolUDP)},
SourceAnyPortEnable: ptrOf(true),
RecordPath: "/var/recordings",
}
clone := original.Clone()
require.Equal(t, original, clone)
}
================================================
FILE: internal/conf/record_format.go
================================================
package conf
import (
"fmt"
"github.com/bluenviron/mediamtx/internal/conf/jsonwrapper"
)
// RecordFormat is the recordFormat parameter.
type RecordFormat string
// supported values.
const (
RecordFormatFMP4 RecordFormat = "fmp4"
RecordFormatMPEGTS RecordFormat = "mpegts"
)
// UnmarshalJSON implements json.Unmarshaler.
func (d *RecordFormat) UnmarshalJSON(b []byte) error {
type alias RecordFormat
if err := jsonwrapper.Unmarshal(b, (*alias)(d)); err != nil {
return err
}
switch *d {
case RecordFormatFMP4, RecordFormatMPEGTS:
default:
return fmt.Errorf("invalid record format '%s'", *d)
}
return nil
}
// UnmarshalEnv implements env.Unmarshaler.
func (d *RecordFormat) UnmarshalEnv(_ string, v string) error {
return d.UnmarshalJSON([]byte(`"` + v + `"`))
}
================================================
FILE: internal/conf/rtsp_auth_method.go
================================================
package conf
import (
"encoding/json"
"fmt"
"github.com/bluenviron/gortsplib/v5/pkg/auth"
"github.com/bluenviron/mediamtx/internal/conf/jsonwrapper"
)
// RTSPAuthMethod represents an RTSP authentication method.
type RTSPAuthMethod auth.VerifyMethod
// MarshalJSON implements json.Marshaler.
func (d RTSPAuthMethod) MarshalJSON() ([]byte, error) {
switch d {
case RTSPAuthMethod(auth.VerifyMethodBasic):
return json.Marshal("basic")
default:
return json.Marshal("digest")
}
}
// UnmarshalJSON implements json.Unmarshaler.
func (d *RTSPAuthMethod) UnmarshalJSON(b []byte) error {
var in string
if err := jsonwrapper.Unmarshal(b, &in); err != nil {
return err
}
switch in {
case "basic":
*d = RTSPAuthMethod(auth.VerifyMethodBasic)
case "digest":
*d = RTSPAuthMethod(auth.VerifyMethodDigestMD5)
default:
return fmt.Errorf("invalid authentication method: '%s'", in)
}
return nil
}
================================================
FILE: internal/conf/rtsp_auth_methods.go
================================================
package conf
import (
"encoding/json"
"strings"
"github.com/bluenviron/gortsplib/v5/pkg/auth"
"github.com/bluenviron/mediamtx/internal/conf/jsonwrapper"
)
// RTSPAuthMethods is the rtspAuthMethods parameter.
type RTSPAuthMethods []RTSPAuthMethod
// UnmarshalEnv implements env.Unmarshaler.
func (d *RTSPAuthMethods) UnmarshalEnv(_ string, v string) error {
byts, _ := json.Marshal(strings.Split(v, ","))
return jsonwrapper.Unmarshal(byts, d)
}
// ToAuthMethods converts to auth.VerifyMethod slice.
func (d RTSPAuthMethods) ToAuthMethods() []auth.VerifyMethod {
out := make([]auth.VerifyMethod, len(d))
for i, v := range d {
out[i] = auth.VerifyMethod(v)
}
return out
}
================================================
FILE: internal/conf/rtsp_range_type.go
================================================
package conf
import (
"fmt"
"github.com/bluenviron/mediamtx/internal/conf/jsonwrapper"
)
// RTSPRangeType is the type used in the Range header.
type RTSPRangeType string
// supported values.
const (
RTSPRangeTypeUndefined RTSPRangeType = ""
RTSPRangeTypeClock RTSPRangeType = "clock"
RTSPRangeTypeNPT RTSPRangeType = "npt"
RTSPRangeTypeSMPTE RTSPRangeType = "smpte"
)
// UnmarshalJSON implements json.Unmarshaler.
func (d *RTSPRangeType) UnmarshalJSON(b []byte) error {
type alias RTSPRangeType
if err := jsonwrapper.Unmarshal(b, (*alias)(d)); err != nil {
return err
}
switch *d {
case RTSPRangeTypeUndefined, RTSPRangeTypeClock, RTSPRangeTypeNPT, RTSPRangeTypeSMPTE:
default:
return fmt.Errorf("invalid rtsp range type: '%s'", *d)
}
return nil
}
// UnmarshalEnv implements env.Unmarshaler.
func (d *RTSPRangeType) UnmarshalEnv(_ string, v string) error {
return d.UnmarshalJSON([]byte(`"` + v + `"`))
}
================================================
FILE: internal/conf/rtsp_transport.go
================================================
package conf
import (
"encoding/json"
"fmt"
"github.com/bluenviron/gortsplib/v5"
"github.com/bluenviron/mediamtx/internal/conf/jsonwrapper"
)
func ptrOf[T any](v T) *T {
p := new(T)
*p = v
return p
}
// RTSPTransport is the rtspTransport parameter.
type RTSPTransport struct {
*gortsplib.Protocol
}
// MarshalJSON implements json.Marshaler.
func (d RTSPTransport) MarshalJSON() ([]byte, error) {
var out string
if d.Protocol == nil {
out = "automatic"
} else {
switch *d.Protocol {
case gortsplib.ProtocolUDP:
out = "udp"
case gortsplib.ProtocolUDPMulticast:
out = "multicast"
default:
out = "tcp"
}
}
return json.Marshal(out)
}
// UnmarshalJSON implements json.Unmarshaler.
func (d *RTSPTransport) UnmarshalJSON(b []byte) error {
var in string
if err := jsonwrapper.Unmarshal(b, &in); err != nil {
return err
}
switch in {
case "udp":
d.Protocol = ptrOf(gortsplib.ProtocolUDP)
case "multicast":
d.Protocol = ptrOf(gortsplib.ProtocolUDPMulticast)
case "tcp":
d.Protocol = ptrOf(gortsplib.ProtocolTCP)
case "automatic":
d.Protocol = nil
default:
return fmt.Errorf("invalid transport '%s'", in)
}
return nil
}
// UnmarshalEnv implements env.Unmarshaler.
func (d *RTSPTransport) UnmarshalEnv(_ string, v string) error {
return d.UnmarshalJSON([]byte(`"` + v + `"`))
}
================================================
FILE: internal/conf/rtsp_transports.go
================================================
package conf
import (
"encoding/json"
"fmt"
"sort"
"strings"
"github.com/bluenviron/gortsplib/v5"
"github.com/bluenviron/mediamtx/internal/conf/jsonwrapper"
)
// RTSPTransports is the rtspTransports parameter.
type RTSPTransports map[gortsplib.Protocol]struct{}
// MarshalJSON implements json.Marshaler.
func (d RTSPTransports) MarshalJSON() ([]byte, error) {
out := make([]string, len(d))
i := 0
for p := range d {
var v string
switch p {
case gortsplib.ProtocolUDP:
v = "udp"
case gortsplib.ProtocolUDPMulticast:
v = "multicast"
default:
v = "tcp"
}
out[i] = v
i++
}
sort.Strings(out)
return json.Marshal(out)
}
// UnmarshalJSON implements json.Unmarshaler.
func (d *RTSPTransports) UnmarshalJSON(b []byte) error {
var in []string
if err := jsonwrapper.Unmarshal(b, &in); err != nil {
return err
}
*d = make(RTSPTransports)
for _, proto := range in {
switch proto {
case "udp":
(*d)[gortsplib.ProtocolUDP] = struct{}{}
case "multicast":
(*d)[gortsplib.ProtocolUDPMulticast] = struct{}{}
case "tcp":
(*d)[gortsplib.ProtocolTCP] = struct{}{}
default:
return fmt.Errorf("invalid transport: %s", proto)
}
}
return nil
}
// UnmarshalEnv implements env.Unmarshaler.
func (d *RTSPTransports) UnmarshalEnv(_ string, v string) error {
byts, _ := json.Marshal(strings.Split(v, ","))
return d.UnmarshalJSON(byts)
}
================================================
FILE: internal/conf/string_size.go
================================================
package conf
import (
"code.cloudfoundry.org/bytefmt"
"github.com/bluenviron/mediamtx/internal/conf/jsonwrapper"
)
// StringSize is a size that is unmarshaled from a string.
type StringSize uint64
// MarshalJSON implements json.Marshaler.
func (s StringSize) MarshalJSON() ([]byte, error) {
return []byte(`"` + bytefmt.ByteSize(uint64(s)) + `"`), nil
}
// UnmarshalJSON implements json.Unmarshaler.
func (s *StringSize) UnmarshalJSON(b []byte) error {
var in string
if err := jsonwrapper.Unmarshal(b, &in); err != nil {
return err
}
v, err := bytefmt.ToBytes(in)
if err != nil {
return err
}
*s = StringSize(v)
return nil
}
// UnmarshalEnv implements env.Unmarshaler.
func (s *StringSize) UnmarshalEnv(_ string, v string) error {
return s.UnmarshalJSON([]byte(`"` + v + `"`))
}
================================================
FILE: internal/conf/webrtc_ice_server.go
================================================
package conf
// WebRTCICEServer is a WebRTC ICE Server.
type WebRTCICEServer struct {
URL string `json:"url"`
Username string `json:"username"`
Password string `json:"password"`
ClientOnly bool `json:"clientOnly"`
}
================================================
FILE: internal/conf/yamlwrapper/testdata/fuzz/FuzzUnmarshal/90b5d1b18dd9f8ac
================================================
go test fuzz v1
[]byte("*0")
================================================
FILE: internal/conf/yamlwrapper/testdata/fuzz/FuzzUnmarshal/dc806ec658c460fc
================================================
go test fuzz v1
[]byte("...")
================================================
FILE: internal/conf/yamlwrapper/unmarshal.go
================================================
// Package yamlwrapper contains a YAML unmarshaler.
package yamlwrapper
import (
"encoding/json"
"fmt"
"github.com/bluenviron/mediamtx/internal/conf/jsonwrapper"
"github.com/goccy/go-yaml"
"github.com/goccy/go-yaml/ast"
"github.com/goccy/go-yaml/parser"
"github.com/goccy/go-yaml/token"
)
// differences with respect to the standard package:
// - some legacy YAML 1.1 boolean values (yes, no) are supported
// - all differences of jsonwrapper are inherited
func convertLegacyBools(node ast.Node) ast.Node {
if node != nil {
switch n := node.(type) {
case *ast.MappingNode:
for _, value := range n.Values {
convertLegacyBools(value)
}
case *ast.MappingValueNode:
n.Key = convertLegacyBools(n.Key).(ast.MapKeyNode)
n.Value = convertLegacyBools(n.Value)
case *ast.SequenceNode:
for i, value := range n.Values {
n.Values[i] = convertLegacyBools(value)
}
case *ast.DocumentNode:
n.Body = convertLegacyBools(n.Body)
case *ast.StringNode:
if n.Token.Type == token.StringType {
var boolVal bool
shouldConvert := false
switch n.Token.Value {
case "yes", "Yes", "YES", "on", "On", "ON":
boolVal = true
shouldConvert = true
case "no", "No", "NO", "off", "Off", "OFF":
boolVal = false
shouldConvert = true
}
if shouldConvert {
newToken := &token.Token{
Type: token.BoolType,
Value: n.Token.Value,
}
if boolVal {
newToken.Value = "true"
} else {
newToken.Value = "false"
}
boolNode := ast.Bool(newToken)
boolNode.Value = boolVal
return boolNode
}
}
}
}
return node
}
// Unmarshal loads the configuration from YAML.
func Unmarshal(buf []byte, dest any) error {
file, err := parser.ParseBytes(buf, parser.ParseComments)
if err != nil {
return err
}
if len(file.Docs) != 1 {
return fmt.Errorf("invalid YAML")
}
file.Docs[0] = convertLegacyBools(file.Docs[0]).(*ast.DocumentNode)
var temp any
if file.Docs[0].Body != nil {
err = yaml.NodeToValue(file.Docs[0].Body, &temp)
if err != nil {
return err
}
}
// convert the generic map into JSON
buf, err = json.Marshal(temp)
if err != nil {
return err
}
// load JSON into destination
return jsonwrapper.Unmarshal(buf, dest)
}
================================================
FILE: internal/conf/yamlwrapper/unmarshal_test.go
================================================
package yamlwrapper
import (
"testing"
"github.com/stretchr/testify/require"
)
func TestUnmarshalIntegerMapKey(t *testing.T) {
buf := []byte(`
1: value
test: value2
`)
var dest any
err := Unmarshal(buf, &dest)
require.NoError(t, err)
require.Equal(t, map[string]any{
"1": "value",
"test": "value2",
}, dest)
}
func TestUnmarshalDuplicateKey(t *testing.T) {
buf := []byte(`
key: value1
key: value2
`)
err := Unmarshal(buf, &map[string]string{})
require.EqualError(t, err, "[3:1] mapping key \"key\" already defined at [2:1]"+
"\n 2 | key: value1\n> 3 | key: value2\n ^\n")
}
func TestUnmarshalUnknownFields(t *testing.T) {
type testStruct struct {
Field1 string `json:"field1"`
Field2 int `json:"field2"`
}
input := []byte(`field1: test
unknownField: value
field2: 456`)
var result testStruct
err := Unmarshal(input, &result)
require.Error(t, err)
require.EqualError(t, err, "json: unknown field \"unknownField\"")
}
func TestUnmarshalLegacyBools(t *testing.T) {
type testStruct struct {
Field1 bool `json:"field1"`
Field2 string `json:"field2"`
}
input := []byte("field1: yes\n" +
"field2: \"yes\"\n")
var result testStruct
err := Unmarshal(input, &result)
require.NoError(t, err)
require.Equal(t, true, result.Field1)
}
func TestUnmarshalEmpty(t *testing.T) {
input := []byte(``)
var result any
err := Unmarshal(input, &result)
require.NoError(t, err)
}
func FuzzUnmarshal(f *testing.F) {
f.Fuzz(func(_ *testing.T, buf []byte) {
var dest any
Unmarshal(buf, &dest) //nolint:errcheck
})
}
================================================
FILE: internal/confwatcher/confwatcher.go
================================================
// Package confwatcher contains a configuration watcher.
package confwatcher
import (
"os"
"path/filepath"
"time"
"github.com/fsnotify/fsnotify"
)
const (
minInterval = 1 * time.Second
additionalWait = 10 * time.Millisecond
)
// ConfWatcher is a configuration file watcher.
type ConfWatcher struct {
FilePath string
inner *fsnotify.Watcher
absolutePath string
// in
terminate chan struct{}
// out
signal chan struct{}
done chan struct{}
}
// Initialize initializes a ConfWatcher.
func (w *ConfWatcher) Initialize() error {
if _, err := os.Stat(w.FilePath); err != nil {
return err
}
var err error
w.inner, err = fsnotify.NewWatcher()
if err != nil {
return err
}
// use absolute paths to support Darwin
w.absolutePath, _ = filepath.Abs(w.FilePath)
parentPath := filepath.Dir(w.absolutePath)
err = w.inner.Add(parentPath)
if err != nil {
w.inner.Close() //nolint:errcheck
return err
}
w.terminate = make(chan struct{})
w.signal = make(chan struct{})
w.done = make(chan struct{})
go w.run()
return nil
}
// Close closes a ConfWatcher.
func (w *ConfWatcher) Close() {
close(w.terminate)
<-w.done
}
func (w *ConfWatcher) run() {
defer close(w.done)
var lastCalled time.Time
previousWatchedPath, _ := filepath.EvalSymlinks(w.absolutePath)
outer:
for {
select {
case event := <-w.inner.Events:
if time.Since(lastCalled) < minInterval {
continue
}
currentWatchedPath, _ := filepath.EvalSymlinks(w.absolutePath)
eventPath, _ := filepath.Abs(event.Name)
eventPath, _ = filepath.EvalSymlinks(eventPath)
if currentWatchedPath == "" {
// watched file was removed; wait for write event to trigger reload
previousWatchedPath = ""
} else if currentWatchedPath != previousWatchedPath ||
(eventPath == currentWatchedPath &&
((event.Op&fsnotify.Write) == fsnotify.Write ||
(event.Op&fsnotify.Create) == fsnotify.Create)) {
// wait some additional time to allow the writer to complete its job
time.Sleep(additionalWait)
previousWatchedPath = currentWatchedPath
lastCalled = time.Now()
select {
case w.signal <- struct{}{}:
case <-w.terminate:
break outer
}
}
case <-w.inner.Errors:
break outer
case <-w.terminate:
break outer
}
}
close(w.signal)
w.inner.Close() //nolint:errcheck
}
// Watch returns a channel that is called after the configuration file has changed.
func (w *ConfWatcher) Watch() chan struct{} {
return w.signal
}
================================================
FILE: internal/confwatcher/confwatcher_test.go
================================================
package confwatcher
import (
"os"
"testing"
"time"
"github.com/bluenviron/mediamtx/internal/test"
"github.com/stretchr/testify/require"
)
func TestNoFile(t *testing.T) {
w := &ConfWatcher{FilePath: "/nonexistent"}
err := w.Initialize()
require.Error(t, err)
}
func TestWrite(t *testing.T) {
fpath, err := test.CreateTempFile([]byte("{}"))
require.NoError(t, err)
w := &ConfWatcher{FilePath: fpath}
err = w.Initialize()
require.NoError(t, err)
defer w.Close()
func() {
var f *os.File
f, err = os.Create(fpath)
require.NoError(t, err)
defer f.Close()
_, err = f.Write([]byte("{}"))
require.NoError(t, err)
}()
select {
case <-w.Watch():
case <-time.After(500 * time.Millisecond):
t.Errorf("timed out")
return
}
}
func TestWriteMultipleTimes(t *testing.T) {
fpath, err := test.CreateTempFile([]byte("{}"))
require.NoError(t, err)
w := &ConfWatcher{FilePath: fpath}
err = w.Initialize()
require.NoError(t, err)
defer w.Close()
func() {
f, err2 := os.Create(fpath)
require.NoError(t, err2)
defer f.Close()
_, err2 = f.Write([]byte("{}"))
require.NoError(t, err2)
}()
time.Sleep(10 * time.Millisecond)
func() {
f, err2 := os.Create(fpath)
require.NoError(t, err2)
defer f.Close()
_, err2 = f.Write([]byte("{}"))
require.NoError(t, err2)
}()
select {
case <-w.Watch():
case <-time.After(500 * time.Millisecond):
t.Errorf("timed out")
return
}
select {
case <-time.After(500 * time.Millisecond):
case <-w.Watch():
t.Errorf("should not happen")
return
}
}
func TestDeleteCreate(t *testing.T) {
fpath, err := test.CreateTempFile([]byte("{}"))
require.NoError(t, err)
w := &ConfWatcher{FilePath: fpath}
err = w.Initialize()
require.NoError(t, err)
defer w.Close()
os.Remove(fpath)
time.Sleep(10 * time.Millisecond)
func() {
var f *os.File
f, err = os.Create(fpath)
require.NoError(t, err)
defer f.Close()
_, err = f.Write([]byte("{}"))
require.NoError(t, err)
}()
select {
case <-w.Watch():
case <-time.After(500 * time.Millisecond):
t.Errorf("timed out")
return
}
}
func TestSymlinkDeleteCreate(t *testing.T) {
fpath, err := test.CreateTempFile([]byte("{}"))
require.NoError(t, err)
err = os.Symlink(fpath, fpath+"-sym")
require.NoError(t, err)
w := &ConfWatcher{FilePath: fpath + "-sym"}
err = w.Initialize()
require.NoError(t, err)
defer w.Close()
os.Remove(fpath)
func() {
f, err2 := os.Create(fpath)
require.NoError(t, err2)
defer f.Close()
_, err2 = f.Write([]byte("{}"))
require.NoError(t, err2)
}()
select {
case <-w.Watch():
case <-time.After(500 * time.Millisecond):
t.Errorf("timed out")
return
}
}
================================================
FILE: internal/core/api_test.go
================================================
//nolint:dupl,lll
package core
import (
"bufio"
"bytes"
"context"
"crypto/tls"
"encoding/json"
"io"
"net/http"
"net/url"
"os"
"testing"
"time"
"github.com/bluenviron/gortmplib"
rtmpcodecs "github.com/bluenviron/gortmplib/pkg/codecs"
"github.com/bluenviron/gortsplib/v5"
"github.com/bluenviron/gortsplib/v5/pkg/description"
"github.com/bluenviron/mediacommon/v2/pkg/formats/mpegts"
tscodecs "github.com/bluenviron/mediacommon/v2/pkg/formats/mpegts/codecs"
srt "github.com/datarhei/gosrt"
"github.com/google/uuid"
"github.com/pion/rtp"
pwebrtc "github.com/pion/webrtc/v4"
"github.com/stretchr/testify/require"
"github.com/bluenviron/mediamtx/internal/defs"
"github.com/bluenviron/mediamtx/internal/protocols/webrtc"
"github.com/bluenviron/mediamtx/internal/protocols/whip"
"github.com/bluenviron/mediamtx/internal/test"
)
func checkClose(t *testing.T, closeFunc func() error) {
require.NoError(t, closeFunc())
}
func httpRequest(t *testing.T, hc *http.Client, method string, ur string, in any, out any) {
buf := func() io.Reader {
if in == nil {
return nil
}
byts, err := json.Marshal(in)
require.NoError(t, err)
return bytes.NewBuffer(byts)
}()
req, err := http.NewRequest(method, ur, buf)
require.NoError(t, err)
res, err := hc.Do(req)
require.NoError(t, err)
defer res.Body.Close()
if res.StatusCode != http.StatusOK {
t.Errorf("bad status code: %d", res.StatusCode)
}
if out == nil {
return
}
err = json.NewDecoder(res.Body).Decode(out)
require.NoError(t, err)
}
func checkError(t *testing.T, msg string, body io.Reader) {
var resErr map[string]any
err := json.NewDecoder(body).Decode(&resErr)
require.NoError(t, err)
require.Equal(t, map[string]any{"status": "error", "error": msg}, resErr)
}
func TestAPIPathsList(t *testing.T) {
type pathSource struct {
Type string `json:"type"`
}
type path struct {
Name string `json:"name"`
Source pathSource `json:"source"`
Ready bool `json:"ready"`
Tracks []defs.APIPathTrackCodec `json:"tracks"`
InboundBytes uint64 `json:"inboundBytes"`
OutboundBytes uint64 `json:"outboundBytes"`
InboundFramesInError uint64 `json:"inboundFramesInError"`
BytesReceived uint64 `json:"bytesReceived"`
BytesSent uint64 `json:"bytesSent"`
}
type pathList struct {
ItemCount int `json:"itemCount"`
PageCount int `json:"pageCount"`
Items []path `json:"items"`
}
t.Run("rtsp session", func(t *testing.T) {
p, ok := newInstance("api: yes\n" +
"paths:\n" +
" mypath:\n")
require.Equal(t, true, ok)
defer p.Close()
tr := &http.Transport{}
defer tr.CloseIdleConnections()
hc := &http.Client{Transport: tr}
media0 := test.UniqueMediaH264()
source := gortsplib.Client{}
err := source.StartRecording(
"rtsp://localhost:8554/mypath",
&description.Session{Medias: []*description.Media{
media0,
test.MediaMPEG4Audio,
}})
require.NoError(t, err)
defer source.Close()
err = source.WritePacketRTP(media0, &rtp.Packet{
Header: rtp.Header{
Version: 2,
PayloadType: 96,
},
Payload: []byte{5, 1, 2, 3, 4},
})
require.NoError(t, err)
var out pathList
httpRequest(t, hc, http.MethodGet, "http://localhost:9997/v3/paths/list", nil, &out)
require.Equal(t, pathList{
ItemCount: 1,
PageCount: 1,
Items: []path{{
Name: "mypath",
Source: pathSource{
Type: "rtspSession",
},
Ready: true,
Tracks: []defs.APIPathTrackCodec{defs.APIPathTrackCodecH264, defs.APIPathTrackCodecMPEG4Audio},
InboundBytes: 17,
InboundFramesInError: 0,
BytesReceived: 17,
}},
}, out)
})
t.Run("rtsps session", func(t *testing.T) {
serverCertFpath, err := test.CreateTempFile(test.TLSCertPub)
require.NoError(t, err)
defer os.Remove(serverCertFpath)
serverKeyFpath, err := test.CreateTempFile(test.TLSCertKey)
require.NoError(t, err)
defer os.Remove(serverKeyFpath)
p, ok := newInstance("api: yes\n" +
"rtspEncryption: optional\n" +
"rtspServerCert: " + serverCertFpath + "\n" +
"rtspServerKey: " + serverKeyFpath + "\n" +
"paths:\n" +
" mypath:\n")
require.Equal(t, true, ok)
defer p.Close()
tr := &http.Transport{}
defer tr.CloseIdleConnections()
hc := &http.Client{Transport: tr}
source := gortsplib.Client{TLSConfig: &tls.Config{InsecureSkipVerify: true}}
err = source.StartRecording("rtsps://localhost:8322/mypath",
&description.Session{Medias: []*description.Media{
test.UniqueMediaH264(),
test.UniqueMediaMPEG4Audio(),
}})
require.NoError(t, err)
defer source.Close()
var out pathList
httpRequest(t, hc, http.MethodGet, "http://localhost:9997/v3/paths/list", nil, &out)
require.Equal(t, pathList{
ItemCount: 1,
PageCount: 1,
Items: []path{{
Name: "mypath",
Source: pathSource{
Type: "rtspsSession",
},
Ready: true,
Tracks: []defs.APIPathTrackCodec{defs.APIPathTrackCodecH264, defs.APIPathTrackCodecMPEG4Audio},
}},
}, out)
})
t.Run("rtsp source", func(t *testing.T) {
p, ok := newInstance("api: yes\n" +
"paths:\n" +
" mypath:\n" +
" source: rtsp://127.0.0.1:1234/mypath\n" +
" sourceOnDemand: yes\n")
require.Equal(t, true, ok)
defer p.Close()
tr := &http.Transport{}
defer tr.CloseIdleConnections()
hc := &http.Client{Transport: tr}
var out pathList
httpRequest(t, hc, http.MethodGet, "http://localhost:9997/v3/paths/list", nil, &out)
require.Equal(t, pathList{
ItemCount: 1,
PageCount: 1,
Items: []path{{
Name: "mypath",
Source: pathSource{
Type: "rtspSource",
},
Ready: false,
Tracks: []defs.APIPathTrackCodec{},
}},
}, out)
})
t.Run("rtmp source", func(t *testing.T) {
p, ok := newInstance("api: yes\n" +
"paths:\n" +
" mypath:\n" +
" source: rtmp://127.0.0.1:1234/mypath\n" +
" sourceOnDemand: yes\n")
require.Equal(t, true, ok)
defer p.Close()
tr := &http.Transport{}
defer tr.CloseIdleConnections()
hc := &http.Client{Transport: tr}
var out pathList
httpRequest(t, hc, http.MethodGet, "http://localhost:9997/v3/paths/list", nil, &out)
require.Equal(t, pathList{
ItemCount: 1,
PageCount: 1,
Items: []path{{
Name: "mypath",
Source: pathSource{
Type: "rtmpSource",
},
Ready: false,
Tracks: []defs.APIPathTrackCodec{},
}},
}, out)
})
t.Run("hls source", func(t *testing.T) {
p, ok := newInstance("api: yes\n" +
"paths:\n" +
" mypath:\n" +
" source: http://127.0.0.1:1234/mypath\n" +
" sourceOnDemand: yes\n")
require.Equal(t, true, ok)
defer p.Close()
tr := &http.Transport{}
defer tr.CloseIdleConnections()
hc := &http.Client{Transport: tr}
var out pathList
httpRequest(t, hc, http.MethodGet, "http://localhost:9997/v3/paths/list", nil, &out)
require.Equal(t, pathList{
ItemCount: 1,
PageCount: 1,
Items: []path{{
Name: "mypath",
Source: pathSource{
Type: "hlsSource",
},
Ready: false,
Tracks: []defs.APIPathTrackCodec{},
}},
}, out)
})
}
func TestAPIPathsGet(t *testing.T) {
p, ok := newInstance("api: yes\n" +
"paths:\n" +
" all_others:\n")
require.Equal(t, true, ok)
defer p.Close()
tr := &http.Transport{}
defer tr.CloseIdleConnections()
hc := &http.Client{Transport: tr}
for _, ca := range []string{"ok", "ok-nested", "not found"} {
t.Run(ca, func(t *testing.T) {
type pathSource struct {
Type string `json:"type"`
}
type path struct {
Name string `json:"name"`
Source pathSource `json:"source"`
Ready bool `json:"Ready"`
Tracks []defs.APIPathTrackCodec `json:"tracks"`
InboundBytes uint64 `json:"inboundBytes"`
OutboundBytes uint64 `json:"outboundBytes"`
InboundFramesInError uint64 `json:"inboundFramesInError"`
BytesReceived uint64 `json:"bytesReceived"`
BytesSent uint64 `json:"bytesSent"`
}
var pathName string
switch ca {
case "ok":
pathName = "mypath"
case "ok-nested":
pathName = "my/nested/path"
case "not found":
pathName = "nonexisting"
}
if ca == "ok" || ca == "ok-nested" {
source := gortsplib.Client{}
err := source.StartRecording("rtsp://localhost:8554/"+pathName,
&description.Session{Medias: []*description.Media{test.UniqueMediaH264()}})
require.NoError(t, err)
defer source.Close()
var out path
httpRequest(t, hc, http.MethodGet, "http://localhost:9997/v3/paths/get/"+pathName, nil, &out)
require.Equal(t, path{
Name: pathName,
Source: pathSource{
Type: "rtspSession",
},
Ready: true,
Tracks: []defs.APIPathTrackCodec{defs.APIPathTrackCodecH264},
}, out)
} else {
res, err := hc.Get("http://localhost:9997/v3/paths/get/" + pathName)
require.NoError(t, err)
defer res.Body.Close()
require.Equal(t, http.StatusNotFound, res.StatusCode)
checkError(t, "path not found", res.Body)
}
})
}
}
func TestAPIProtocolListGet(t *testing.T) {
serverCertFpath, err := test.CreateTempFile(test.TLSCertPub)
require.NoError(t, err)
defer os.Remove(serverCertFpath)
serverKeyFpath, err := test.CreateTempFile(test.TLSCertKey)
require.NoError(t, err)
defer os.Remove(serverKeyFpath)
for _, ca := range []string{
"rtsp conns",
"rtsp sessions",
"rtsps conns",
"rtsps sessions",
"rtmp",
"rtmps",
"hls",
"webrtc",
"srt",
} {
t.Run(ca, func(t *testing.T) {
cnf := "api: yes\n"
switch ca {
case "rtsps conns", "rtsps sessions":
cnf += "rtspEncryption: strict\n" +
"rtspServerCert: " + serverCertFpath + "\n" +
"rtspServerKey: " + serverKeyFpath + "\n"
case "rtmps":
cnf += "rtmpEncryption: strict\n" +
"rtmpServerCert: " + serverCertFpath + "\n" +
"rtmpServerKey: " + serverKeyFpath + "\n"
}
cnf += "paths:\n" +
" all_others:\n"
p, ok := newInstance(cnf)
require.Equal(t, true, ok)
defer p.Close()
tr := &http.Transport{}
defer tr.CloseIdleConnections()
hc := &http.Client{Transport: tr}
medi := test.UniqueMediaH264()
switch ca { //nolint:dupl
case "rtsp conns", "rtsp sessions":
source := gortsplib.Client{}
err = source.StartRecording("rtsp://localhost:8554/mypath?key=val",
&description.Session{Medias: []*description.Media{medi}})
require.NoError(t, err)
defer source.Close()
case "rtsps conns", "rtsps sessions":
source := gortsplib.Client{
TLSConfig: &tls.Config{InsecureSkipVerify: true},
}
err = source.StartRecording("rtsps://localhost:8322/mypath?key=val",
&description.Session{Medias: []*description.Media{medi}})
require.NoError(t, err)
defer source.Close()
case "rtmp", "rtmps":
var port string
if ca == "rtmp" {
port = "1935"
} else {
port = "1936"
}
var rawURL string
if ca == "rtmps" {
rawURL = "rtmps://"
} else {
rawURL = "rtmp://"
}
rawURL += "127.0.0.1:" + port + "/mypath?key=val"
var u *url.URL
u, err = url.Parse(rawURL)
require.NoError(t, err)
conn := &gortmplib.Client{
URL: u,
TLSConfig: &tls.Config{InsecureSkipVerify: true},
Publish: true,
}
err = conn.Initialize(context.Background())
require.NoError(t, err)
defer conn.Close()
track := &gortmplib.Track{
Codec: &rtmpcodecs.H264{
SPS: test.FormatH264.SPS,
PPS: test.FormatH264.PPS,
},
}
w := &gortmplib.Writer{
Conn: conn,
Tracks: []*gortmplib.Track{track},
}
err = w.Initialize()
require.NoError(t, err)
err = w.WriteH264(track, 2*time.Second, 2*time.Second, [][]byte{{5, 2, 3, 4}})
require.NoError(t, err)
time.Sleep(500 * time.Millisecond)
case "hls":
source := gortsplib.Client{}
err = source.StartRecording("rtsp://localhost:8554/mypath",
&description.Session{Medias: []*description.Media{medi}})
require.NoError(t, err)
defer source.Close()
go func() {
time.Sleep(500 * time.Millisecond)
for i := range 3 {
/*source.WritePacketRTP(medi, &rtp.Packet{
Header: rtp.Header{
Version: 2,
Marker: true,
PayloadType: 96,
SequenceNumber: 123 + uint16(i),
Timestamp: 45343 + uint32(i)*90000,
SSRC: 563423,
},
Payload: []byte{
testSPS,
0x05,
},
})
[]byte{ // 1920x1080 baseline
0x67, 0x42, 0xc0, 0x28, 0xd9, 0x00, 0x78, 0x02,
0x27, 0xe5, 0x84, 0x00, 0x00, 0x03, 0x00, 0x04,
0x00, 0x00, 0x03, 0x00, 0xf0, 0x3c, 0x60, 0xc9, 0x20,
},*/
err2 := source.WritePacketRTP(medi, &rtp.Packet{
Header: rtp.Header{
Version: 2,
Marker: true,
PayloadType: 96,
SequenceNumber: 123 + uint16(i),
Timestamp: 45343 + uint32(i)*90000,
SSRC: 563423,
},
Payload: []byte{
// testSPS,
0x05,
},
})
require.NoError(t, err2)
}
}()
func() {
res, err2 := hc.Get("http://localhost:8888/mypath/index.m3u8")
require.NoError(t, err2)
defer res.Body.Close()
require.Equal(t, 200, res.StatusCode)
}()
case "webrtc":
source := gortsplib.Client{}
err = source.StartRecording("rtsp://localhost:8554/mypath",
&description.Session{Medias: []*description.Media{medi}})
require.NoError(t, err)
defer source.Close()
var u *url.URL
u, err = url.Parse("http://localhost:8889/mypath/whep?key=val")
require.NoError(t, err)
go func() {
time.Sleep(500 * time.Millisecond)
err2 := source.WritePacketRTP(medi, &rtp.Packet{
Header: rtp.Header{
Version: 2,
Marker: true,
PayloadType: 96,
SequenceNumber: 123,
Timestamp: 45343,
SSRC: 563423,
},
Payload: []byte{5, 1, 2, 3, 4},
})
require.NoError(t, err2)
}()
c := &whip.Client{
HTTPClient: hc,
URL: u,
Log: test.NilLogger,
}
err = c.Initialize(context.Background())
require.NoError(t, err)
defer checkClose(t, c.Close)
case "srt":
conf := srt.DefaultConfig()
conf.StreamId = "publish:mypath:::key=val"
var conn srt.Conn
conn, err = srt.Dial("srt", "localhost:8890", conf)
require.NoError(t, err)
defer conn.Close()
track := &mpegts.Track{
Codec: &tscodecs.H264{},
}
bw := bufio.NewWriter(conn)
w := &mpegts.Writer{W: bw, Tracks: []*mpegts.Track{track}}
err = w.Initialize()
require.NoError(t, err)
err = w.WriteH264(track, 0, 0, [][]byte{{1}})
require.NoError(t, err)
err = bw.Flush()
require.NoError(t, err)
time.Sleep(500 * time.Millisecond)
}
var pa string
switch ca {
case "rtsp conns":
pa = "rtspconns"
case "rtsp sessions":
pa = "rtspsessions"
case "rtsps conns":
pa = "rtspsconns"
case "rtsps sessions":
pa = "rtspssessions"
case "rtmp":
pa = "rtmpconns"
case "rtmps":
pa = "rtmpsconns"
case "hls":
pa = "hlsmuxers"
case "webrtc":
pa = "webrtcsessions"
case "srt":
pa = "srtconns"
}
var out1 any
httpRequest(t, hc, http.MethodGet, "http://localhost:9997/v3/"+pa+"/list", nil, &out1)
switch ca {
case "rtsp conns":
require.Equal(t, map[string]any{
"pageCount": float64(1),
"itemCount": float64(1),
"items": []any{
map[string]any{
"inboundBytes": out1.(map[string]any)["items"].([]any)[0].(map[string]any)["inboundBytes"],
"outboundBytes": out1.(map[string]any)["items"].([]any)[0].(map[string]any)["outboundBytes"],
"bytesReceived": out1.(map[string]any)["items"].([]any)[0].(map[string]any)["bytesReceived"],
"bytesSent": out1.(map[string]any)["items"].([]any)[0].(map[string]any)["bytesSent"],
"created": out1.(map[string]any)["items"].([]any)[0].(map[string]any)["created"],
"id": out1.(map[string]any)["items"].([]any)[0].(map[string]any)["id"],
"remoteAddr": out1.(map[string]any)["items"].([]any)[0].(map[string]any)["remoteAddr"],
"session": out1.(map[string]any)["items"].([]any)[0].(map[string]any)["session"],
"tunnel": "none",
},
},
}, out1)
case "rtsp sessions":
require.Equal(t, map[string]any{
"pageCount": float64(1),
"itemCount": float64(1),
"items": []any{
map[string]any{
"inboundBytes": out1.(map[string]any)["items"].([]any)[0].(map[string]any)["inboundBytes"],
"inboundRTPPackets": out1.(map[string]any)["items"].([]any)[0].(map[string]any)["inboundRTPPackets"],
"inboundRTPPacketsLost": out1.(map[string]any)["items"].([]any)[0].(map[string]any)["inboundRTPPacketsLost"],
"inboundRTPPacketsInError": out1.(map[string]any)["items"].([]any)[0].(map[string]any)["inboundRTPPacketsInError"],
"inboundRTPPacketsJitter": out1.(map[string]any)["items"].([]any)[0].(map[string]any)["inboundRTPPacketsJitter"],
"inboundRTCPPackets": out1.(map[string]any)["items"].([]any)[0].(map[string]any)["inboundRTCPPackets"],
"inboundRTCPPacketsInError": out1.(map[string]any)["items"].([]any)[0].(map[string]any)["inboundRTCPPacketsInError"],
"outboundBytes": out1.(map[string]any)["items"].([]any)[0].(map[string]any)["outboundBytes"],
"outboundRTPPackets": out1.(map[string]any)["items"].([]any)[0].(map[string]any)["outboundRTPPackets"],
"outboundRTPPacketsReportedLost": out1.(map[string]any)["items"].([]any)[0].(map[string]any)["outboundRTPPacketsReportedLost"],
"outboundRTPPacketsDiscarded": out1.(map[string]any)["items"].([]any)[0].(map[string]any)["outboundRTPPacketsDiscarded"],
"outboundRTCPPackets": out1.(map[string]any)["items"].([]any)[0].(map[string]any)["outboundRTCPPackets"],
"bytesReceived": out1.(map[string]any)["items"].([]any)[0].(map[string]any)["bytesReceived"],
"bytesSent": out1.(map[string]any)["items"].([]any)[0].(map[string]any)["bytesSent"],
"created": out1.(map[string]any)["items"].([]any)[0].(map[string]any)["created"],
"id": out1.(map[string]any)["items"].([]any)[0].(map[string]any)["id"],
"path": "mypath",
"query": "key=val",
"user": "",
"remoteAddr": out1.(map[string]any)["items"].([]any)[0].(map[string]any)["remoteAddr"],
"state": "publish",
"transport": "UDP",
"profile": "AVP",
"rtpPacketsReceived": float64(0),
"rtpPacketsSent": float64(0),
"rtpPacketsLost": float64(0),
"rtpPacketsInError": float64(0),
"rtpPacketsJitter": float64(0),
"rtcpPacketsReceived": float64(0),
"rtcpPacketsSent": float64(0),
"rtcpPacketsInError": float64(0),
"conns": out1.(map[string]any)["items"].([]any)[0].(map[string]any)["conns"],
},
},
}, out1)
case "rtsps conns":
require.Equal(t, map[string]any{
"pageCount": float64(1),
"itemCount": float64(1),
"items": []any{
map[string]any{
"inboundBytes": out1.(map[string]any)["items"].([]any)[0].(map[string]any)["inboundBytes"],
"outboundBytes": out1.(map[string]any)["items"].([]any)[0].(map[string]any)["outboundBytes"],
"bytesReceived": out1.(map[string]any)["items"].([]any)[0].(map[string]any)["bytesReceived"],
"bytesSent": out1.(map[string]any)["items"].([]any)[0].(map[string]any)["bytesSent"],
"created": out1.(map[string]any)["items"].([]any)[0].(map[string]any)["created"],
"id": out1.(map[string]any)["items"].([]any)[0].(map[string]any)["id"],
"remoteAddr": out1.(map[string]any)["items"].([]any)[0].(map[string]any)["remoteAddr"],
"session": out1.(map[string]any)["items"].([]any)[0].(map[string]any)["session"],
"tunnel": "none",
},
},
}, out1)
case "rtsps sessions":
require.Equal(t, map[string]any{
"pageCount": float64(1),
"itemCount": float64(1),
"items": []any{
map[string]any{
"inboundBytes": out1.(map[string]any)["items"].([]any)[0].(map[string]any)["inboundBytes"],
"inboundRTPPackets": out1.(map[string]any)["items"].([]any)[0].(map[string]any)["inboundRTPPackets"],
"inboundRTPPacketsLost": out1.(map[string]any)["items"].([]any)[0].(map[string]any)["inboundRTPPacketsLost"],
"inboundRTPPacketsInError": out1.(map[string]any)["items"].([]any)[0].(map[string]any)["inboundRTPPacketsInError"],
"inboundRTPPacketsJitter": out1.(map[string]any)["items"].([]any)[0].(map[string]any)["inboundRTPPacketsJitter"],
"inboundRTCPPackets": out1.(map[string]any)["items"].([]any)[0].(map[string]any)["inboundRTCPPackets"],
"inboundRTCPPacketsInError": out1.(map[string]any)["items"].([]any)[0].(map[string]any)["inboundRTCPPacketsInError"],
"outboundBytes": out1.(map[string]any)["items"].([]any)[0].(map[string]any)["outboundBytes"],
"outboundRTPPackets": out1.(map[string]any)["items"].([]any)[0].(map[string]any)["outboundRTPPackets"],
"outboundRTPPacketsReportedLost": out1.(map[string]any)["items"].([]any)[0].(map[string]any)["outboundRTPPacketsReportedLost"],
"outboundRTPPacketsDiscarded": out1.(map[string]any)["items"].([]any)[0].(map[string]any)["outboundRTPPacketsDiscarded"],
"outboundRTCPPackets": out1.(map[string]any)["items"].([]any)[0].(map[string]any)["outboundRTCPPackets"],
"bytesReceived": out1.(map[string]any)["items"].([]any)[0].(map[string]any)["bytesReceived"],
"bytesSent": out1.(map[string]any)["items"].([]any)[0].(map[string]any)["bytesSent"],
"created": out1.(map[string]any)["items"].([]any)[0].(map[string]any)["created"],
"id": out1.(map[string]any)["items"].([]any)[0].(map[string]any)["id"],
"path": "mypath",
"query": "key=val",
"user": "",
"remoteAddr": out1.(map[string]any)["items"].([]any)[0].(map[string]any)["remoteAddr"],
"state": "publish",
"transport": "UDP",
"profile": "SAVP",
"rtpPacketsReceived": float64(0),
"rtpPacketsSent": float64(0),
"rtpPacketsLost": float64(0),
"rtpPacketsInError": float64(0),
"rtpPacketsJitter": float64(0),
"rtcpPacketsReceived": float64(0),
"rtcpPacketsSent": float64(0),
"rtcpPacketsInError": float64(0),
"conns": out1.(map[string]any)["items"].([]any)[0].(map[string]any)["conns"],
},
},
}, out1)
case "rtmp":
require.Equal(t, map[string]any{
"pageCount": float64(1),
"itemCount": float64(1),
"items": []any{
map[string]any{
"inboundBytes": out1.(map[string]any)["items"].([]any)[0].(map[string]any)["inboundBytes"],
"outboundBytes": out1.(map[string]any)["items"].([]any)[0].(map[string]any)["outboundBytes"],
"outboundFramesDiscarded": out1.(map[string]any)["items"].([]any)[0].(map[string]any)["outboundFramesDiscarded"],
"bytesReceived": out1.(map[string]any)["items"].([]any)[0].(map[string]any)["bytesReceived"],
"bytesSent": out1.(map[string]any)["items"].([]any)[0].(map[string]any)["bytesSent"],
"created": out1.(map[string]any)["items"].([]any)[0].(map[string]any)["created"],
"id": out1.(map[string]any)["items"].([]any)[0].(map[string]any)["id"],
"path": "mypath",
"query": "key=val",
"user": "",
"remoteAddr": out1.(map[string]any)["items"].([]any)[0].(map[string]any)["remoteAddr"],
"state": "publish",
},
},
}, out1)
case "rtmps":
require.Equal(t, map[string]any{
"pageCount": float64(1),
"itemCount": float64(1),
"items": []any{
map[string]any{
"inboundBytes": out1.(map[string]any)["items"].([]any)[0].(map[string]any)["inboundBytes"],
"outboundBytes": out1.(map[string]any)["items"].([]any)[0].(map[string]any)["outboundBytes"],
"outboundFramesDiscarded": out1.(map[string]any)["items"].([]any)[0].(map[string]any)["outboundFramesDiscarded"],
"bytesReceived": out1.(map[string]any)["items"].([]any)[0].(map[string]any)["bytesReceived"],
"bytesSent": out1.(map[string]any)["items"].([]any)[0].(map[string]any)["bytesSent"],
"created": out1.(map[string]any)["items"].([]any)[0].(map[string]any)["created"],
"id": out1.(map[string]any)["items"].([]any)[0].(map[string]any)["id"],
"path": "mypath",
"query": "key=val",
"user": "",
"remoteAddr": out1.(map[string]any)["items"].([]any)[0].(map[string]any)["remoteAddr"],
"state": "publish",
},
},
}, out1)
case "hls":
require.Equal(t, map[string]any{
"itemCount": float64(1),
"pageCount": float64(1),
"items": []any{
map[string]any{
"outboundBytes": out1.(map[string]any)["items"].([]any)[0].(map[string]any)["outboundBytes"],
"outboundFramesDiscarded": out1.(map[string]any)["items"].([]any)[0].(map[string]any)["outboundFramesDiscarded"],
"bytesSent": out1.(map[string]any)["items"].([]any)[0].(map[string]any)["bytesSent"],
"created": out1.(map[string]any)["items"].([]any)[0].(map[string]any)["created"],
"lastRequest": out1.(map[string]any)["items"].([]any)[0].(map[string]any)["lastRequest"],
"path": "mypath",
},
},
}, out1)
case "webrtc":
require.Equal(t, map[string]any{
"itemCount": float64(1),
"pageCount": float64(1),
"items": []any{
map[string]any{
"inboundBytes": out1.(map[string]any)["items"].([]any)[0].(map[string]any)["inboundBytes"],
"inboundRTPPackets": out1.(map[string]any)["items"].([]any)[0].(map[string]any)["inboundRTPPackets"],
"inboundRTPPacketsLost": out1.(map[string]any)["items"].([]any)[0].(map[string]any)["inboundRTPPacketsLost"],
"inboundRTPPacketsJitter": out1.(map[string]any)["items"].([]any)[0].(map[string]any)["inboundRTPPacketsJitter"],
"inboundRTCPPackets": out1.(map[string]any)["items"].([]any)[0].(map[string]any)["inboundRTCPPackets"],
"outboundBytes": out1.(map[string]any)["items"].([]any)[0].(map[string]any)["outboundBytes"],
"outboundRTPPackets": out1.(map[string]any)["items"].([]any)[0].(map[string]any)["outboundRTPPackets"],
"outboundRTCPPackets": out1.(map[string]any)["items"].([]any)[0].(map[string]any)["outboundRTCPPackets"],
"outboundFramesDiscarded": out1.(map[string]any)["items"].([]any)[0].(map[string]any)["outboundFramesDiscarded"],
"bytesReceived": out1.(map[string]any)["items"].([]any)[0].(map[string]any)["bytesReceived"],
"bytesSent": out1.(map[string]any)["items"].([]any)[0].(map[string]any)["bytesSent"],
"created": out1.(map[string]any)["items"].([]any)[0].(map[string]any)["created"],
"id": out1.(map[string]any)["items"].([]any)[0].(map[string]any)["id"],
"localCandidate": out1.(map[string]any)["items"].([]any)[0].(map[string]any)["localCandidate"],
"path": "mypath",
"peerConnectionEstablished": true,
"query": "key=val",
"remoteAddr": out1.(map[string]any)["items"].([]any)[0].(map[string]any)["remoteAddr"],
"remoteCandidate": out1.(map[string]any)["items"].([]any)[0].(map[string]any)["remoteCandidate"],
"state": "read",
"user": "",
"rtcpPacketsReceived": float64(0),
"rtcpPacketsSent": float64(2),
"rtpPacketsJitter": float64(0),
"rtpPacketsLost": float64(0),
"rtpPacketsReceived": float64(0),
"rtpPacketsSent": float64(1),
},
},
}, out1)
case "srt":
require.Equal(t, map[string]any{
"itemCount": float64(1),
"pageCount": float64(1),
"items": []any{
map[string]any{
"byteMSS": float64(1500),
"bytesAvailReceiveBuf": float64(0),
"bytesAvailSendBuf": float64(0),
"bytesReceiveBuf": float64(0),
"bytesReceived": float64(628),
"bytesReceivedBelated": float64(0),
"bytesReceivedDrop": float64(0),
"bytesReceivedLoss": float64(0),
"bytesReceivedRetrans": float64(0),
"bytesReceivedUndecrypt": float64(0),
"outboundFramesDiscarded": out1.(map[string]any)["items"].([]any)[0].(map[string]any)["outboundFramesDiscarded"],
"bytesReceivedUnique": float64(628),
"bytesRetrans": float64(0),
"bytesSendBuf": float64(0),
"bytesSendDrop": float64(0),
"bytesSent": float64(0),
"bytesSentUnique": float64(0),
"created": out1.(map[string]any)["items"].([]any)[0].(map[string]any)["created"],
"id": out1.(map[string]any)["items"].([]any)[0].(map[string]any)["id"],
"mbpsLinkCapacity": float64(0),
"mbpsMaxBW": float64(-1),
"mbpsReceiveRate": float64(0),
"mbpsSendRate": float64(0),
"msRTT": out1.(map[string]any)["items"].([]any)[0].(map[string]any)["msRTT"],
"msReceiveBuf": float64(0),
"msReceiveTsbPdDelay": float64(120),
"msSendBuf": float64(0),
"msSendTsbPdDelay": float64(120),
"packetsFlightSize": float64(0),
"packetsFlowWindow": float64(25600),
"packetsReceiveBuf": float64(0),
"packetsReceived": float64(1),
"packetsReceivedACK": out1.(map[string]any)["items"].([]any)[0].(map[string]any)["packetsReceivedACK"],
"packetsReceivedAvgBelatedTime": float64(0),
"packetsReceivedBelated": float64(0),
"packetsReceivedDrop": float64(0),
"packetsReceivedKM": float64(0),
"packetsReceivedLoss": float64(0),
"packetsReceivedLossRate": float64(0),
"packetsReceivedNAK": float64(0),
"packetsReceivedRetrans": float64(0),
"packetsReceivedUndecrypt": float64(0),
"packetsReceivedUnique": float64(1),
"packetsReorderTolerance": float64(0),
"packetsRetrans": float64(0),
"packetsSendBuf": float64(0),
"packetsSendDrop": float64(0),
"packetsSendLoss": float64(0),
"packetsSendLossRate": float64(0),
"packetsSent": float64(0),
"packetsSentACK": out1.(map[string]any)["items"].([]any)[0].(map[string]any)["packetsSentACK"],
"packetsSentKM": float64(0),
"packetsSentNAK": float64(0),
"packetsSentUnique": float64(0),
"path": "mypath",
"query": "key=val",
"remoteAddr": out1.(map[string]any)["items"].([]any)[0].(map[string]any)["remoteAddr"],
"state": "publish",
"user": "",
"usPacketsSendPeriod": float64(10.967254638671875),
"usSndDuration": float64(0),
},
},
}, out1)
}
var out2 any
if ca == "hls" {
httpRequest(t, hc, http.MethodGet, "http://localhost:9997/v3/"+pa+"/get/"+
out1.(map[string]any)["items"].([]any)[0].(map[string]any)["path"].(string),
nil, &out2)
} else {
httpRequest(t, hc, http.MethodGet, "http://localhost:9997/v3/"+pa+"/get/"+
out1.(map[string]any)["items"].([]any)[0].(map[string]any)["id"].(string),
nil, &out2)
}
switch ca {
case "rtsp conns", "rtsps conns":
out2.(map[string]any)["inboundBytes"] = out1.(map[string]any)["items"].([]any)[0].(map[string]any)["inboundBytes"]
out2.(map[string]any)["outboundBytes"] = out1.(map[string]any)["items"].([]any)[0].(map[string]any)["outboundBytes"]
out2.(map[string]any)["bytesReceived"] = out1.(map[string]any)["items"].([]any)[0].(map[string]any)["bytesReceived"]
out2.(map[string]any)["bytesSent"] = out1.(map[string]any)["items"].([]any)[0].(map[string]any)["bytesSent"]
case "rtsp sessions", "rtsps sessions":
out2.(map[string]any)["inboundBytes"] = out1.(map[string]any)["items"].([]any)[0].(map[string]any)["inboundBytes"]
out2.(map[string]any)["inboundRTPPackets"] = out1.(map[string]any)["items"].([]any)[0].(map[string]any)["inboundRTPPackets"]
out2.(map[string]any)["inboundRTPPacketsLost"] = out1.(map[string]any)["items"].([]any)[0].(map[string]any)["inboundRTPPacketsLost"]
out2.(map[string]any)["inboundRTPPacketsInError"] = out1.(map[string]any)["items"].([]any)[0].(map[string]any)["inboundRTPPacketsInError"]
out2.(map[string]any)["inboundRTPPacketsJitter"] = out1.(map[string]any)["items"].([]any)[0].(map[string]any)["inboundRTPPacketsJitter"]
out2.(map[string]any)["inboundRTCPPackets"] = out1.(map[string]any)["items"].([]any)[0].(map[string]any)["inboundRTCPPackets"]
out2.(map[string]any)["inboundRTCPPacketsInError"] = out1.(map[string]any)["items"].([]any)[0].(map[string]any)["inboundRTCPPacketsInError"]
out2.(map[string]any)["outboundBytes"] = out1.(map[string]any)["items"].([]any)[0].(map[string]any)["outboundBytes"]
out2.(map[string]any)["outboundRTPPackets"] = out1.(map[string]any)["items"].([]any)[0].(map[string]any)["outboundRTPPackets"]
out2.(map[string]any)["outboundRTPPacketsReportedLost"] = out1.(map[string]any)["items"].([]any)[0].(map[string]any)["outboundRTPPacketsReportedLost"]
out2.(map[string]any)["outboundRTPPacketsDiscarded"] = out1.(map[string]any)["items"].([]any)[0].(map[string]any)["outboundRTPPacketsDiscarded"]
out2.(map[string]any)["outboundRTCPPackets"] = out1.(map[string]any)["items"].([]any)[0].(map[string]any)["outboundRTCPPackets"]
out2.(map[string]any)["bytesReceived"] = out1.(map[string]any)["items"].([]any)[0].(map[string]any)["bytesReceived"]
out2.(map[string]any)["bytesSent"] = out1.(map[string]any)["items"].([]any)[0].(map[string]any)["bytesSent"]
out2.(map[string]any)["rtpPacketsReceived"] = out1.(map[string]any)["items"].([]any)[0].(map[string]any)["rtpPacketsReceived"]
out2.(map[string]any)["rtpPacketsSent"] = out1.(map[string]any)["items"].([]any)[0].(map[string]any)["rtpPacketsSent"]
out2.(map[string]any)["rtpPacketsLost"] = out1.(map[string]any)["items"].([]any)[0].(map[string]any)["rtpPacketsLost"]
out2.(map[string]any)["rtpPacketsInError"] = out1.(map[string]any)["items"].([]any)[0].(map[string]any)["rtpPacketsInError"]
out2.(map[string]any)["rtpPacketsJitter"] = out1.(map[string]any)["items"].([]any)[0].(map[string]any)["rtpPacketsJitter"]
out2.(map[string]any)["rtcpPacketsReceived"] = out1.(map[string]any)["items"].([]any)[0].(map[string]any)["rtcpPacketsReceived"]
out2.(map[string]any)["rtcpPacketsSent"] = out1.(map[string]any)["items"].([]any)[0].(map[string]any)["rtcpPacketsSent"]
out2.(map[string]any)["rtcpPacketsInError"] = out1.(map[string]any)["items"].([]any)[0].(map[string]any)["rtcpPacketsInError"]
case "webrtc":
out2.(map[string]any)["inboundBytes"] = out1.(map[string]any)["items"].([]any)[0].(map[string]any)["inboundBytes"]
out2.(map[string]any)["inboundRTPPackets"] = out1.(map[string]any)["items"].([]any)[0].(map[string]any)["inboundRTPPackets"]
out2.(map[string]any)["inboundRTPPacketsLost"] = out1.(map[string]any)["items"].([]any)[0].(map[string]any)["inboundRTPPacketsLost"]
out2.(map[string]any)["inboundRTPPacketsJitter"] = out1.(map[string]any)["items"].([]any)[0].(map[string]any)["inboundRTPPacketsJitter"]
out2.(map[string]any)["inboundRTCPPackets"] = out1.(map[string]any)["items"].([]any)[0].(map[string]any)["inboundRTCPPackets"]
out2.(map[string]any)["outboundBytes"] = out1.(map[string]any)["items"].([]any)[0].(map[string]any)["outboundBytes"]
out2.(map[string]any)["outboundRTPPackets"] = out1.(map[string]any)["items"].([]any)[0].(map[string]any)["outboundRTPPackets"]
out2.(map[string]any)["outboundRTCPPackets"] = out1.(map[string]any)["items"].([]any)[0].(map[string]any)["outboundRTCPPackets"]
out2.(map[string]any)["outboundFramesDiscarded"] = out1.(map[string]any)["items"].([]any)[0].(map[string]any)["outboundFramesDiscarded"]
out2.(map[string]any)["bytesReceived"] = out1.(map[string]any)["items"].([]any)[0].(map[string]any)["bytesReceived"]
out2.(map[string]any)["bytesSent"] = out1.(map[string]any)["items"].([]any)[0].(map[string]any)["bytesSent"]
out2.(map[string]any)["rtpPacketsReceived"] = out1.(map[string]any)["items"].([]any)[0].(map[string]any)["rtpPacketsReceived"]
out2.(map[string]any)["rtpPacketsSent"] = out1.(map[string]any)["items"].([]any)[0].(map[string]any)["rtpPacketsSent"]
out2.(map[string]any)["rtpPacketsLost"] = out1.(map[string]any)["items"].([]any)[0].(map[string]any)["rtpPacketsLost"]
out2.(map[string]any)["rtpPacketsJitter"] = out1.(map[string]any)["items"].([]any)[0].(map[string]any)["rtpPacketsJitter"]
out2.(map[string]any)["rtcpPacketsReceived"] = out1.(map[string]any)["items"].([]any)[0].(map[string]any)["rtcpPacketsReceived"]
out2.(map[string]any)["rtcpPacketsSent"] = out1.(map[string]any)["items"].([]any)[0].(map[string]any)["rtcpPacketsSent"]
case "hls":
out2.(map[string]any)["lastRequest"] = out1.(map[string]any)["items"].([]any)[0].(map[string]any)["lastRequest"]
}
require.Equal(t, out1.(map[string]any)["items"].([]any)[0], out2)
})
}
}
func TestAPIProtocolGetNotFound(t *testing.T) {
serverCertFpath, err := test.CreateTempFile(test.TLSCertPub)
require.NoError(t, err)
defer os.Remove(serverCertFpath)
serverKeyFpath, err := test.CreateTempFile(test.TLSCertKey)
require.NoError(t, err)
defer os.Remove(serverKeyFpath)
for _, ca := range []string{
"rtsp conns",
"rtsp sessions",
"rtsps conns",
"rtsps sessions",
"rtmp",
"rtmps",
"hls",
"webrtc",
"srt",
} {
t.Run(ca, func(t *testing.T) {
cnf := "api: yes\n"
switch ca {
case "rtsps conns", "rtsps sessions":
cnf += "rtspTransports: [tcp]\n" +
"rtspEncryption: strict\n" +
"rtspServerCert: " + serverCertFpath + "\n" +
"rtspServerKey: " + serverKeyFpath + "\n"
case "rtmps":
cnf += "rtmpEncryption: strict\n" +
"rtmpServerCert: " + serverCertFpath + "\n" +
"rtmpServerKey: " + serverKeyFpath + "\n"
}
cnf += "paths:\n" +
" all_others:\n"
p, ok := newInstance(cnf)
require.Equal(t, true, ok)
defer p.Close()
tr := &http.Transport{}
defer tr.CloseIdleConnections()
hc := &http.Client{Transport: tr}
var pa string
switch ca {
case "rtsp conns":
pa = "rtspconns"
case "rtsp sessions":
pa = "rtspsessions"
case "rtsps conns":
pa = "rtspsconns"
case "rtsps sessions":
pa = "rtspssessions"
case "rtmp":
pa = "rtmpconns"
case "rtmps":
pa = "rtmpsconns"
case "hls":
pa = "hlsmuxers"
case "webrtc":
pa = "webrtcsessions"
case "srt":
pa = "srtconns"
}
func() {
var req *http.Request
req, err = http.NewRequest(http.MethodGet, "http://localhost:9997/v3/"+pa+"/get/"+uuid.New().String(), nil)
require.NoError(t, err)
var res *http.Response
res, err = hc.Do(req)
require.NoError(t, err)
defer res.Body.Close()
require.Equal(t, http.StatusNotFound, res.StatusCode)
switch ca {
case "rtsp conns", "rtsps conns", "rtmp", "rtmps", "srt":
checkError(t, "connection not found", res.Body)
case "rtsp sessions", "rtsps sessions", "webrtc":
checkError(t, "session not found", res.Body)
case "hls":
checkError(t, "muxer not found", res.Body)
}
}()
})
}
}
func TestAPIProtocolKick(t *testing.T) {
serverCertFpath, err := test.CreateTempFile(test.TLSCertPub)
require.NoError(t, err)
defer os.Remove(serverCertFpath)
serverKeyFpath, err := test.CreateTempFile(test.TLSCertKey)
require.NoError(t, err)
defer os.Remove(serverKeyFpath)
for _, ca := range []string{
"rtsp",
"rtsps",
"rtmp",
"webrtc",
"srt",
} {
t.Run(ca, func(t *testing.T) {
cnf := "api: yes\n"
if ca == "rtsps" {
cnf += "rtspTransports: [tcp]\n" +
"rtspEncryption: strict\n" +
"rtspServerCert: " + serverCertFpath + "\n" +
"rtspServerKey: " + serverKeyFpath + "\n"
}
cnf += "paths:\n" +
" all_others:\n"
p, ok := newInstance(cnf)
require.Equal(t, true, ok)
defer p.Close()
tr := &http.Transport{}
defer tr.CloseIdleConnections()
hc := &http.Client{Transport: tr}
medi := test.MediaH264
switch ca {
case "rtsp":
source := gortsplib.Client{}
err = source.StartRecording("rtsp://localhost:8554/mypath",
&description.Session{Medias: []*description.Media{medi}})
require.NoError(t, err)
defer source.Close()
case "rtsps":
source := gortsplib.Client{
TLSConfig: &tls.Config{InsecureSkipVerify: true},
}
err = source.StartRecording("rtsps://localhost:8322/mypath",
&description.Session{Medias: []*description.Media{medi}})
require.NoError(t, err)
defer source.Close()
case "rtmp":
var u *url.URL
u, err = url.Parse("rtmp://localhost:1935/mypath")
require.NoError(t, err)
conn := &gortmplib.Client{
URL: u,
Publish: true,
}
err = conn.Initialize(context.Background())
require.NoError(t, err)
defer conn.Close()
track := &gortmplib.Track{
Codec: &rtmpcodecs.H264{
SPS: test.FormatH264.SPS,
PPS: test.FormatH264.PPS,
},
}
w := &gortmplib.Writer{
Conn: conn,
Tracks: []*gortmplib.Track{track},
}
err = w.Initialize()
require.NoError(t, err)
err = w.WriteH264(track, 2*time.Second, 2*time.Second, [][]byte{{5, 2, 3, 4}})
require.NoError(t, err)
case "webrtc":
var u *url.URL
u, err = url.Parse("http://localhost:8889/mypath/whip")
require.NoError(t, err)
track := &webrtc.OutgoingTrack{
Caps: pwebrtc.RTPCodecCapability{
MimeType: pwebrtc.MimeTypeH264,
ClockRate: 90000,
SDPFmtpLine: "level-asymmetry-allowed=1;packetization-mode=1;profile-level-id=42e01f",
},
}
c := &whip.Client{
HTTPClient: hc,
URL: u,
Log: test.NilLogger,
Publish: true,
OutgoingTracks: []*webrtc.OutgoingTrack{track},
}
err = c.Initialize(context.Background())
require.NoError(t, err)
defer func() {
require.Error(t, c.Close())
}()
case "srt":
conf := srt.DefaultConfig()
conf.StreamId = "publish:mypath"
var conn srt.Conn
conn, err = srt.Dial("srt", "localhost:8890", conf)
require.NoError(t, err)
defer conn.Close()
track := &mpegts.Track{
Codec: &tscodecs.H264{},
}
bw := bufio.NewWriter(conn)
w := &mpegts.Writer{W: bw, Tracks: []*mpegts.Track{track}}
err = w.Initialize()
require.NoError(t, err)
err = w.WriteH264(track, 0, 0, [][]byte{{1}})
require.NoError(t, err)
err = bw.Flush()
require.NoError(t, err)
}
var pa string
switch ca {
case "rtsp":
pa = "rtspsessions"
case "rtsps":
pa = "rtspssessions"
case "rtmp":
pa = "rtmpconns"
case "webrtc":
pa = "webrtcsessions"
case "srt":
pa = "srtconns"
}
var out1 struct {
Items []struct {
ID string `json:"id"`
} `json:"items"`
}
httpRequest(t, hc, http.MethodGet, "http://localhost:9997/v3/"+pa+"/list", nil, &out1)
httpRequest(t, hc, http.MethodPost, "http://localhost:9997/v3/"+pa+"/kick/"+out1.Items[0].ID, nil, nil)
var out2 struct {
Items []struct {
ID string `json:"id"`
} `json:"items"`
}
httpRequest(t, hc, http.MethodGet, "http://localhost:9997/v3/"+pa+"/list", nil, &out2)
require.Empty(t, out2.Items)
})
}
}
func TestAPIProtocolKickNotFound(t *testing.T) {
serverCertFpath, err := test.CreateTempFile(test.TLSCertPub)
require.NoError(t, err)
defer os.Remove(serverCertFpath)
serverKeyFpath, err := test.CreateTempFile(test.TLSCertKey)
require.NoError(t, err)
defer os.Remove(serverKeyFpath)
for _, ca := range []string{
"rtsp",
"rtsps",
"rtmp",
"webrtc",
"srt",
} {
t.Run(ca, func(t *testing.T) {
cnf := "api: yes\n"
if ca == "rtsps" {
cnf += "rtspTransports: [tcp]\n" +
"rtspEncryption: strict\n" +
"rtspServerCert: " + serverCertFpath + "\n" +
"rtspServerKey: " + serverKeyFpath + "\n"
}
cnf += "paths:\n" +
" all_others:\n"
p, ok := newInstance(cnf)
require.Equal(t, true, ok)
defer p.Close()
tr := &http.Transport{}
defer tr.CloseIdleConnections()
hc := &http.Client{Transport: tr}
var pa string
switch ca {
case "rtsp":
pa = "rtspsessions"
case "rtsps":
pa = "rtspssessions"
case "rtmp":
pa = "rtmpconns"
case "webrtc":
pa = "webrtcsessions"
case "srt":
pa = "srtconns"
}
func() {
var req *http.Request
req, err = http.NewRequest(http.MethodPost, "http://localhost:9997/v3/"+pa+"/kick/"+uuid.New().String(), nil)
require.NoError(t, err)
var res *http.Response
res, err = hc.Do(req)
require.NoError(t, err)
defer res.Body.Close()
require.Equal(t, http.StatusNotFound, res.StatusCode)
switch ca {
case "rtsp conns", "rtsps conns", "rtmp", "rtmps", "srt":
checkError(t, "connection not found", res.Body)
case "rtsp sessions", "rtsps sessions", "webrtc":
checkError(t, "session not found", res.Body)
case "hls":
checkError(t, "muxer not found", res.Body)
}
}()
})
}
}
================================================
FILE: internal/core/core.go
================================================
// Package core contains the main struct of the software.
package core
import (
"context"
_ "embed"
"fmt"
"os"
"os/signal"
"path/filepath"
"reflect"
"runtime"
"runtime/debug"
"slices"
"strings"
"syscall"
"time"
"github.com/alecthomas/kong"
"github.com/gin-gonic/gin"
"github.com/bluenviron/mediamtx/internal/api"
"github.com/bluenviron/mediamtx/internal/auth"
"github.com/bluenviron/mediamtx/internal/conf"
"github.com/bluenviron/mediamtx/internal/confwatcher"
"github.com/bluenviron/mediamtx/internal/externalcmd"
"github.com/bluenviron/mediamtx/internal/logger"
"github.com/bluenviron/mediamtx/internal/metrics"
"github.com/bluenviron/mediamtx/internal/playback"
"github.com/bluenviron/mediamtx/internal/pprof"
"github.com/bluenviron/mediamtx/internal/recordcleaner"
"github.com/bluenviron/mediamtx/internal/rlimit"
"github.com/bluenviron/mediamtx/internal/servers/hls"
"github.com/bluenviron/mediamtx/internal/servers/rtmp"
"github.com/bluenviron/mediamtx/internal/servers/rtsp"
"github.com/bluenviron/mediamtx/internal/servers/srt"
"github.com/bluenviron/mediamtx/internal/servers/webrtc"
)
//go:generate go run ./versiongetter
//go:embed VERSION
var version []byte
var started = time.Now()
var defaultConfPaths = []string{
"rtsp-simple-server.yml",
"mediamtx.yml",
}
var defaultConfPathsNotWin = []string{
"/usr/local/etc/mediamtx.yml",
"/usr/etc/mediamtx.yml",
"/etc/mediamtx/mediamtx.yml",
}
func goArm() string {
bi, _ := debug.ReadBuildInfo()
for _, bs := range bi.Settings {
if bs.Key == "GOARM" {
return bs.Value
}
}
return ""
}
func getArch() string {
var arch string
if runtime.GOARCH == "arm" {
arch = "armv" + goArm()
} else {
arch = runtime.GOARCH
}
return arch
}
func atLeastOneRecordDeleteAfter(pathConfs map[string]*conf.Path) bool {
for _, e := range pathConfs {
if e.RecordDeleteAfter != 0 {
return true
}
}
return false
}
func getRTPMaxPayloadSize(udpMaxPayloadSize int, rtspEncryption conf.Encryption) int {
// UDP max payload size - 12 (RTP header)
v := udpMaxPayloadSize - 12
// 10 (SRTP HMAC SHA1 authentication tag)
if rtspEncryption == conf.EncryptionOptional || rtspEncryption == conf.EncryptionStrict {
v -= 10
}
return v
}
var cli struct {
Confpath string `arg:"" default:""`
Version bool `help:"print version"`
Upgrade bool `help:"upgrade executable to the latest version"`
}
// Core is an instance of MediaMTX.
type Core struct {
ctx context.Context
ctxCancel func()
confPath string
conf *conf.Conf
logger *logger.Logger
externalCmdPool *externalcmd.Pool
authManager *auth.Manager
metrics *metrics.Metrics
pprof *pprof.PPROF
recordCleaner *recordcleaner.Cleaner
playbackServer *playback.Server
pathManager *pathManager
rtspServer *rtsp.Server
rtspsServer *rtsp.Server
rtmpServer *rtmp.Server
rtmpsServer *rtmp.Server
hlsServer *hls.Server
webRTCServer *webrtc.Server
srtServer *srt.Server
api *api.API
confWatcher *confwatcher.ConfWatcher
// in
chAPIConfigSet chan *conf.Conf
// out
done chan struct{}
}
// New allocates a Core.
func New(args []string) (*Core, bool) {
parser, err := kong.New(&cli,
kong.Description("MediaMTX "+string(version)+", "+runtime.GOOS+", "+getArch()),
kong.UsageOnError(),
kong.ValueFormatter(func(value *kong.Value) string {
switch value.Name {
case "confpath":
return "path to a config file. The default is mediamtx.yml."
default:
return kong.DefaultHelpValueFormatter(value)
}
}))
if err != nil {
panic(err)
}
_, err = parser.Parse(args)
parser.FatalIfErrorf(err)
if cli.Version {
fmt.Println(string(version))
os.Exit(0)
}
if cli.Upgrade {
err = upgrade() //nolint:staticcheck
if err != nil { //nolint:staticcheck
fmt.Printf("ERR: %v\n", err)
os.Exit(1)
}
os.Exit(0)
}
ctx, ctxCancel := context.WithCancel(context.Background())
p := &Core{
ctx: ctx,
ctxCancel: ctxCancel,
chAPIConfigSet: make(chan *conf.Conf),
done: make(chan struct{}),
}
tempLogger := &logger.Logger{
Level: logger.Warn,
Destinations: []logger.Destination{logger.DestinationStdout},
Structured: false,
File: "",
SysLogPrefix: "",
}
tempLogger.Initialize() //nolint:errcheck
confPaths := append([]string(nil), defaultConfPaths...)
if runtime.GOOS != "windows" {
confPaths = append(confPaths, defaultConfPathsNotWin...)
}
p.conf, p.confPath, err = conf.Load(cli.Confpath, confPaths, tempLogger)
if err != nil {
fmt.Printf("ERR: %s\n", err)
return nil, false
}
err = p.createResources(true)
if err != nil {
if p.logger != nil {
p.Log(logger.Error, "%s", err)
} else {
fmt.Printf("ERR: %s\n", err)
}
p.closeResources(nil, false)
return nil, false
}
go p.run()
return p, true
}
// Close closes Core and waits for all goroutines to return.
func (p *Core) Close() {
p.ctxCancel()
<-p.done
}
// Wait waits for the Core to exit.
func (p *Core) Wait() {
<-p.done
}
// Log implements logger.Writer.
func (p *Core) Log(level logger.Level, format string, args ...any) {
p.logger.Log(level, format, args...)
}
func (p *Core) run() {
defer close(p.done)
confChanged := func() chan struct{} {
if p.confWatcher != nil {
return p.confWatcher.Watch()
}
return make(chan struct{})
}()
interrupt := make(chan os.Signal, 1)
signal.Notify(interrupt, os.Interrupt)
if runtime.GOOS == "linux" {
signal.Notify(interrupt, syscall.SIGTERM)
}
outer:
for {
select {
case <-confChanged:
p.Log(logger.Info, "reloading configuration (file changed)")
newConf, _, err := conf.Load(p.confPath, nil, p.logger)
if err != nil {
p.Log(logger.Error, "%s", err)
break outer
}
err = p.reloadConf(newConf, false)
if err != nil {
p.Log(logger.Error, "%s", err)
break outer
}
case newConf := <-p.chAPIConfigSet:
p.Log(logger.Info, "reloading configuration (API request)")
err := p.reloadConf(newConf, true)
if err != nil {
p.Log(logger.Error, "%s", err)
break outer
}
case <-interrupt:
p.Log(logger.Info, "shutting down gracefully")
break outer
case <-p.ctx.Done():
break outer
}
}
p.ctxCancel()
p.closeResources(nil, false)
}
func (p *Core) createResources(initial bool) error {
var err error
if p.logger == nil {
i := &logger.Logger{
Level: logger.Level(p.conf.LogLevel),
Destinations: p.conf.LogDestinations.ToDestinations(),
Structured: p.conf.LogStructured,
File: p.conf.LogFile,
SysLogPrefix: p.conf.SysLogPrefix,
}
err = i.Initialize()
if err != nil {
return err
}
p.logger = i
}
if initial {
p.Log(logger.Info, "MediaMTX %s, %s, %s", string(version), runtime.GOOS, getArch())
if p.confPath != "" {
a, _ := filepath.Abs(p.confPath)
p.Log(logger.Info, "configuration loaded from %s", a)
} else {
list := make([]string, len(defaultConfPaths))
for i, pa := range defaultConfPaths {
a, _ := filepath.Abs(pa)
list[i] = a
}
p.Log(logger.Warn,
"configuration file not found (looked in %s), using an empty configuration",
strings.Join(list, ", "))
}
// on Linux, try to raise the number of file descriptors that can be opened
// to allow the maximum possible number of clients.
rlimit.Raise() //nolint:errcheck
gin.SetMode(gin.ReleaseMode)
p.externalCmdPool = &externalcmd.Pool{}
p.externalCmdPool.Initialize()
}
if p.authManager == nil {
p.authManager = &auth.Manager{
Method: p.conf.AuthMethod,
InternalUsers: p.conf.AuthInternalUsers,
HTTPAddress: p.conf.AuthHTTPAddress,
HTTPFingerprint: p.conf.AuthHTTPFingerprint,
HTTPExclude: p.conf.AuthHTTPExclude,
JWTJWKS: p.conf.AuthJWTJWKS,
JWTJWKSFingerprint: p.conf.AuthJWTJWKSFingerprint,
JWTClaimKey: p.conf.AuthJWTClaimKey,
JWTExclude: p.conf.AuthJWTExclude,
JWTInHTTPQuery: p.conf.AuthJWTInHTTPQuery,
JWTIssuer: p.conf.AuthJWTIssuer,
JWTAudience: p.conf.AuthJWTAudience,
ReadTimeout: time.Duration(p.conf.ReadTimeout),
}
}
if p.conf.Metrics &&
p.metrics == nil {
i := &metrics.Metrics{
Address: p.conf.MetricsAddress,
DumpPackets: p.conf.DumpPackets,
Encryption: p.conf.MetricsEncryption,
ServerKey: p.conf.MetricsServerKey,
ServerCert: p.conf.MetricsServerCert,
AllowOrigins: p.conf.MetricsAllowOrigins,
TrustedProxies: p.conf.MetricsTrustedProxies,
ReadTimeout: p.conf.ReadTimeout,
WriteTimeout: p.conf.WriteTimeout,
AuthManager: p.authManager,
Parent: p,
}
err = i.Initialize()
if err != nil {
return err
}
p.metrics = i
}
if p.conf.PPROF &&
p.pprof == nil {
i := &pprof.PPROF{
Address: p.conf.PPROFAddress,
DumpPackets: p.conf.DumpPackets,
Encryption: p.conf.PPROFEncryption,
ServerKey: p.conf.PPROFServerKey,
ServerCert: p.conf.PPROFServerCert,
AllowOrigins: p.conf.PPROFAllowOrigins,
TrustedProxies: p.conf.PPROFTrustedProxies,
ReadTimeout: p.conf.ReadTimeout,
WriteTimeout: p.conf.WriteTimeout,
AuthManager: p.authManager,
Parent: p,
}
err = i.Initialize()
if err != nil {
return err
}
p.pprof = i
}
if p.recordCleaner == nil &&
atLeastOneRecordDeleteAfter(p.conf.Paths) {
p.recordCleaner = &recordcleaner.Cleaner{
PathConfs: p.conf.Paths,
Parent: p,
}
p.recordCleaner.Initialize()
}
if p.conf.Playback &&
p.playbackServer == nil {
i := &playback.Server{
Address: p.conf.PlaybackAddress,
DumpPackets: p.conf.DumpPackets,
Encryption: p.conf.PlaybackEncryption,
ServerKey: p.conf.PlaybackServerKey,
ServerCert: p.conf.PlaybackServerCert,
AllowOrigins: p.conf.PlaybackAllowOrigins,
TrustedProxies: p.conf.PlaybackTrustedProxies,
ReadTimeout: p.conf.ReadTimeout,
WriteTimeout: p.conf.WriteTimeout,
PathConfs: p.conf.Paths,
AuthManager: p.authManager,
Parent: p,
}
err = i.Initialize()
if err != nil {
return err
}
p.playbackServer = i
}
if p.pathManager == nil {
rtpMaxPayloadSize := getRTPMaxPayloadSize(p.conf.UDPMaxPayloadSize, p.conf.RTSPEncryption)
p.pathManager = &pathManager{
logLevel: p.conf.LogLevel,
dumpPackets: p.conf.DumpPackets,
rtspAddress: p.conf.RTSPAddress,
readTimeout: p.conf.ReadTimeout,
writeTimeout: p.conf.WriteTimeout,
writeQueueSize: p.conf.WriteQueueSize,
udpReadBufferSize: p.conf.UDPReadBufferSize,
rtpMaxPayloadSize: rtpMaxPayloadSize,
pathConfs: p.conf.Paths,
authManager: p.authManager,
externalCmdPool: p.externalCmdPool,
metrics: p.metrics,
parent: p,
}
p.pathManager.initialize()
}
if p.conf.RTSP &&
(p.conf.RTSPEncryption == conf.EncryptionNo ||
p.conf.RTSPEncryption == conf.EncryptionOptional) &&
p.rtspServer == nil {
udpReadBufferSize := p.conf.UDPReadBufferSize
if p.conf.RTSPUDPReadBufferSize != nil {
udpReadBufferSize = *p.conf.RTSPUDPReadBufferSize
}
i := &rtsp.Server{
Address: p.conf.RTSPAddress,
AuthMethods: p.conf.RTSPAuthMethods.ToAuthMethods(),
DumpPackets: p.conf.DumpPackets,
UDPReadBufferSize: udpReadBufferSize,
ReadTimeout: p.conf.ReadTimeout,
WriteTimeout: p.conf.WriteTimeout,
WriteQueueSize: p.conf.WriteQueueSize,
RTSPTransports: p.conf.RTSPTransports,
RTPAddress: p.conf.RTPAddress,
RTCPAddress: p.conf.RTCPAddress,
MulticastIPRange: p.conf.MulticastIPRange,
MulticastRTPPort: p.conf.MulticastRTPPort,
MulticastRTCPPort: p.conf.MulticastRTCPPort,
IsTLS: false,
ServerCert: "",
ServerKey: "",
RTSPAddress: p.conf.RTSPAddress,
Transports: p.conf.RTSPTransports,
RunOnConnect: p.conf.RunOnConnect,
RunOnConnectRestart: p.conf.RunOnConnectRestart,
RunOnDisconnect: p.conf.RunOnDisconnect,
ExternalCmdPool: p.externalCmdPool,
Metrics: p.metrics,
PathManager: p.pathManager,
Parent: p,
}
err = i.Initialize()
if err != nil {
return err
}
p.rtspServer = i
}
if p.conf.RTSP &&
(p.conf.RTSPEncryption == conf.EncryptionStrict ||
p.conf.RTSPEncryption == conf.EncryptionOptional) &&
p.rtspsServer == nil {
udpReadBufferSize := p.conf.UDPReadBufferSize
if p.conf.RTSPUDPReadBufferSize != nil {
udpReadBufferSize = *p.conf.RTSPUDPReadBufferSize
}
i := &rtsp.Server{
Address: p.conf.RTSPSAddress,
AuthMethods: p.conf.RTSPAuthMethods.ToAuthMethods(),
DumpPackets: p.conf.DumpPackets,
UDPReadBufferSize: udpReadBufferSize,
ReadTimeout: p.conf.ReadTimeout,
WriteTimeout: p.conf.WriteTimeout,
WriteQueueSize: p.conf.WriteQueueSize,
RTSPTransports: p.conf.RTSPTransports,
RTPAddress: p.conf.SRTPAddress,
RTCPAddress: p.conf.SRTCPAddress,
MulticastIPRange: p.conf.MulticastIPRange,
MulticastRTPPort: p.conf.MulticastSRTPPort,
MulticastRTCPPort: p.conf.MulticastSRTCPPort,
IsTLS: true,
ServerCert: p.conf.RTSPServerCert,
ServerKey: p.conf.RTSPServerKey,
RTSPAddress: p.conf.RTSPAddress,
Transports: p.conf.RTSPTransports,
RunOnConnect: p.conf.RunOnConnect,
RunOnConnectRestart: p.conf.RunOnConnectRestart,
RunOnDisconnect: p.conf.RunOnDisconnect,
ExternalCmdPool: p.externalCmdPool,
Metrics: p.metrics,
PathManager: p.pathManager,
Parent: p,
}
err = i.Initialize()
if err != nil {
return err
}
p.rtspsServer = i
}
if p.conf.RTMP &&
(p.conf.RTMPEncryption == conf.EncryptionNo ||
p.conf.RTMPEncryption == conf.EncryptionOptional) &&
p.rtmpServer == nil {
i := &rtmp.Server{
Address: p.conf.RTMPAddress,
DumpPackets: p.conf.DumpPackets,
ReadTimeout: p.conf.ReadTimeout,
WriteTimeout: p.conf.WriteTimeout,
IsTLS: false,
ServerCert: "",
ServerKey: "",
RTSPAddress: p.conf.RTSPAddress,
RunOnConnect: p.conf.RunOnConnect,
RunOnConnectRestart: p.conf.RunOnConnectRestart,
RunOnDisconnect: p.conf.RunOnDisconnect,
ExternalCmdPool: p.externalCmdPool,
Metrics: p.metrics,
PathManager: p.pathManager,
Parent: p,
}
err = i.Initialize()
if err != nil {
return err
}
p.rtmpServer = i
}
if p.conf.RTMP &&
(p.conf.RTMPEncryption == conf.EncryptionStrict ||
p.conf.RTMPEncryption == conf.EncryptionOptional) &&
p.rtmpsServer == nil {
i := &rtmp.Server{
Address: p.conf.RTMPSAddress,
ReadTimeout: p.conf.ReadTimeout,
WriteTimeout: p.conf.WriteTimeout,
IsTLS: true,
ServerCert: p.conf.RTMPServerCert,
ServerKey: p.conf.RTMPServerKey,
DumpPackets: p.conf.DumpPackets,
RTSPAddress: p.conf.RTSPAddress,
RunOnConnect: p.conf.RunOnConnect,
RunOnConnectRestart: p.conf.RunOnConnectRestart,
RunOnDisconnect: p.conf.RunOnDisconnect,
ExternalCmdPool: p.externalCmdPool,
Metrics: p.metrics,
PathManager: p.pathManager,
Parent: p,
}
err = i.Initialize()
if err != nil {
return err
}
p.rtmpsServer = i
}
if p.conf.HLS &&
p.hlsServer == nil {
i := &hls.Server{
Address: p.conf.HLSAddress,
DumpPackets: p.conf.DumpPackets,
Encryption: p.conf.HLSEncryption,
ServerKey: p.conf.HLSServerKey,
ServerCert: p.conf.HLSServerCert,
AllowOrigins: p.conf.HLSAllowOrigins,
TrustedProxies: p.conf.HLSTrustedProxies,
AlwaysRemux: p.conf.HLSAlwaysRemux,
Variant: p.conf.HLSVariant,
SegmentCount: p.conf.HLSSegmentCount,
SegmentDuration: p.conf.HLSSegmentDuration,
PartDuration: p.conf.HLSPartDuration,
SegmentMaxSize: p.conf.HLSSegmentMaxSize,
Directory: p.conf.HLSDirectory,
ReadTimeout: p.conf.ReadTimeout,
WriteTimeout: p.conf.WriteTimeout,
MuxerCloseAfter: p.conf.HLSMuxerCloseAfter,
Metrics: p.metrics,
PathManager: p.pathManager,
Parent: p,
}
err = i.Initialize()
if err != nil {
return err
}
p.hlsServer = i
}
if p.conf.WebRTC &&
p.webRTCServer == nil {
i := &webrtc.Server{
Address: p.conf.WebRTCAddress,
DumpPackets: p.conf.DumpPackets,
Encryption: p.conf.WebRTCEncryption,
ServerKey: p.conf.WebRTCServerKey,
ServerCert: p.conf.WebRTCServerCert,
AllowOrigins: p.conf.WebRTCAllowOrigins,
TrustedProxies: p.conf.WebRTCTrustedProxies,
ReadTimeout: p.conf.ReadTimeout,
WriteTimeout: p.conf.WriteTimeout,
UDPReadBufferSize: p.conf.UDPReadBufferSize,
LocalUDPAddress: p.conf.WebRTCLocalUDPAddress,
LocalTCPAddress: p.conf.WebRTCLocalTCPAddress,
IPsFromInterfaces: p.conf.WebRTCIPsFromInterfaces,
IPsFromInterfacesList: p.conf.WebRTCIPsFromInterfacesList,
AdditionalHosts: p.conf.WebRTCAdditionalHosts,
ICEServers: p.conf.WebRTCICEServers2,
STUNGatherTimeout: p.conf.WebRTCSTUNGatherTimeout,
HandshakeTimeout: p.conf.WebRTCHandshakeTimeout,
TrackGatherTimeout: p.conf.WebRTCTrackGatherTimeout,
ExternalCmdPool: p.externalCmdPool,
Metrics: p.metrics,
PathManager: p.pathManager,
Parent: p,
}
err = i.Initialize()
if err != nil {
return err
}
p.webRTCServer = i
}
if p.conf.SRT &&
p.srtServer == nil {
i := &srt.Server{
Address: p.conf.SRTAddress,
RTSPAddress: p.conf.RTSPAddress,
ReadTimeout: p.conf.ReadTimeout,
WriteTimeout: p.conf.WriteTimeout,
UDPMaxPayloadSize: p.conf.UDPMaxPayloadSize,
RunOnConnect: p.conf.RunOnConnect,
RunOnConnectRestart: p.conf.RunOnConnectRestart,
RunOnDisconnect: p.conf.RunOnDisconnect,
ExternalCmdPool: p.externalCmdPool,
Metrics: p.metrics,
PathManager: p.pathManager,
Parent: p,
}
err = i.Initialize()
if err != nil {
return err
}
p.srtServer = i
}
if p.conf.API &&
p.api == nil {
i := &api.API{
Version: string(version),
Started: started,
Address: p.conf.APIAddress,
DumpPackets: p.conf.DumpPackets,
Encryption: p.conf.APIEncryption,
ServerKey: p.conf.APIServerKey,
ServerCert: p.conf.APIServerCert,
AllowOrigins: p.conf.APIAllowOrigins,
TrustedProxies: p.conf.APITrustedProxies,
ReadTimeout: p.conf.ReadTimeout,
WriteTimeout: p.conf.WriteTimeout,
Conf: p.conf,
AuthManager: p.authManager,
PathManager: p.pathManager,
RTSPServer: p.rtspServer,
RTSPSServer: p.rtspsServer,
RTMPServer: p.rtmpServer,
RTMPSServer: p.rtmpsServer,
HLSServer: p.hlsServer,
WebRTCServer: p.webRTCServer,
SRTServer: p.srtServer,
Parent: p,
}
err = i.Initialize()
if err != nil {
return err
}
p.api = i
}
if initial && p.confPath != "" {
cf := &confwatcher.ConfWatcher{FilePath: p.confPath}
err = cf.Initialize()
if err != nil {
return err
}
p.confWatcher = cf
}
return nil
}
func (p *Core) closeResources(newConf *conf.Conf, calledByAPI bool) {
closeLogger := newConf == nil ||
newConf.LogLevel != p.conf.LogLevel ||
!reflect.DeepEqual(newConf.LogDestinations, p.conf.LogDestinations) ||
newConf.LogFile != p.conf.LogFile ||
newConf.SysLogPrefix != p.conf.SysLogPrefix ||
newConf.LogStructured != p.conf.LogStructured
closeAuthManager := newConf == nil ||
newConf.AuthMethod != p.conf.AuthMethod ||
newConf.AuthHTTPAddress != p.conf.AuthHTTPAddress ||
newConf.AuthHTTPFingerprint != p.conf.AuthHTTPFingerprint ||
!reflect.DeepEqual(newConf.AuthHTTPExclude, p.conf.AuthHTTPExclude) ||
newConf.AuthJWTJWKS != p.conf.AuthJWTJWKS ||
newConf.AuthJWTJWKSFingerprint != p.conf.AuthJWTJWKSFingerprint ||
newConf.AuthJWTClaimKey != p.conf.AuthJWTClaimKey ||
!reflect.DeepEqual(newConf.AuthJWTExclude, p.conf.AuthJWTExclude) ||
newConf.AuthJWTInHTTPQuery != p.conf.AuthJWTInHTTPQuery ||
newConf.AuthJWTIssuer != p.conf.AuthJWTIssuer ||
newConf.AuthJWTAudience != p.conf.AuthJWTAudience ||
newConf.ReadTimeout != p.conf.ReadTimeout
if !closeAuthManager && !reflect.DeepEqual(newConf.AuthInternalUsers, p.conf.AuthInternalUsers) {
p.authManager.ReloadInternalUsers(newConf.AuthInternalUsers)
}
closeMetrics := newConf == nil ||
newConf.Metrics != p.conf.Metrics ||
newConf.MetricsAddress != p.conf.MetricsAddress ||
newConf.MetricsEncryption != p.conf.MetricsEncryption ||
newConf.MetricsServerKey != p.conf.MetricsServerKey ||
newConf.MetricsServerCert != p.conf.MetricsServerCert ||
!slices.Equal(newConf.MetricsAllowOrigins, p.conf.MetricsAllowOrigins) ||
!reflect.DeepEqual(newConf.MetricsTrustedProxies, p.conf.MetricsTrustedProxies) ||
newConf.ReadTimeout != p.conf.ReadTimeout ||
newConf.WriteTimeout != p.conf.WriteTimeout ||
newConf.DumpPackets != p.conf.DumpPackets ||
closeAuthManager ||
closeLogger
closePPROF := newConf == nil ||
newConf.PPROF != p.conf.PPROF ||
newConf.PPROFAddress != p.conf.PPROFAddress ||
newConf.PPROFEncryption != p.conf.PPROFEncryption ||
newConf.PPROFServerKey != p.conf.PPROFServerKey ||
newConf.PPROFServerCert != p.conf.PPROFServerCert ||
!slices.Equal(newConf.PPROFAllowOrigins, p.conf.PPROFAllowOrigins) ||
!reflect.DeepEqual(newConf.PPROFTrustedProxies, p.conf.PPROFTrustedProxies) ||
newConf.ReadTimeout != p.conf.ReadTimeout ||
newConf.WriteTimeout != p.conf.WriteTimeout ||
newConf.DumpPackets != p.conf.DumpPackets ||
closeAuthManager ||
closeLogger
closeRecorderCleaner := newConf == nil ||
atLeastOneRecordDeleteAfter(newConf.Paths) != atLeastOneRecordDeleteAfter(p.conf.Paths) ||
closeLogger
if !closeRecorderCleaner && p.recordCleaner != nil && !reflect.DeepEqual(newConf.Paths, p.conf.Paths) {
p.recordCleaner.ReloadPathConfs(newConf.Paths)
}
closePlaybackServer := newConf == nil ||
newConf.Playback != p.conf.Playback ||
newConf.PlaybackAddress != p.conf.PlaybackAddress ||
newConf.PlaybackEncryption != p.conf.PlaybackEncryption ||
newConf.PlaybackServerKey != p.conf.PlaybackServerKey ||
newConf.PlaybackServerCert != p.conf.PlaybackServerCert ||
!slices.Equal(newConf.PlaybackAllowOrigins, p.conf.PlaybackAllowOrigins) ||
!reflect.DeepEqual(newConf.PlaybackTrustedProxies, p.conf.PlaybackTrustedProxies) ||
newConf.ReadTimeout != p.conf.ReadTimeout ||
newConf.WriteTimeout != p.conf.WriteTimeout ||
newConf.DumpPackets != p.conf.DumpPackets ||
closeAuthManager ||
closeLogger
if !closePlaybackServer && p.playbackServer != nil && !reflect.DeepEqual(newConf.Paths, p.conf.Paths) {
p.playbackServer.ReloadPathConfs(newConf.Paths)
}
closePathManager := newConf == nil ||
newConf.LogLevel != p.conf.LogLevel ||
newConf.DumpPackets != p.conf.DumpPackets ||
newConf.RTSPAddress != p.conf.RTSPAddress ||
newConf.ReadTimeout != p.conf.ReadTimeout ||
newConf.WriteTimeout != p.conf.WriteTimeout ||
newConf.WriteQueueSize != p.conf.WriteQueueSize ||
newConf.UDPReadBufferSize != p.conf.UDPReadBufferSize ||
newConf.UDPMaxPayloadSize != p.conf.UDPMaxPayloadSize ||
newConf.RTSPEncryption != p.conf.RTSPEncryption ||
closeMetrics ||
closeAuthManager ||
closeLogger
if !closePathManager && !reflect.DeepEqual(newConf.Paths, p.conf.Paths) {
p.pathManager.ReloadPathConfs(newConf.Paths)
}
closeRTSPServer := newConf == nil ||
newConf.RTSP != p.conf.RTSP ||
newConf.RTSPEncryption != p.conf.RTSPEncryption ||
newConf.RTSPAddress != p.conf.RTSPAddress ||
!reflect.DeepEqual(newConf.RTSPAuthMethods, p.conf.RTSPAuthMethods) ||
newConf.RTSPUDPReadBufferSize != p.conf.RTSPUDPReadBufferSize ||
newConf.DumpPackets != p.conf.DumpPackets ||
newConf.UDPReadBufferSize != p.conf.UDPReadBufferSize ||
newConf.ReadTimeout != p.conf.ReadTimeout ||
newConf.WriteTimeout != p.conf.WriteTimeout ||
newConf.WriteQueueSize != p.conf.WriteQueueSize ||
newConf.RTPAddress != p.conf.RTPAddress ||
newConf.RTCPAddress != p.conf.RTCPAddress ||
newConf.MulticastIPRange != p.conf.MulticastIPRange ||
newConf.MulticastRTPPort != p.conf.MulticastRTPPort ||
newConf.MulticastRTCPPort != p.conf.MulticastRTCPPort ||
!reflect.DeepEqual(newConf.RTSPTransports, p.conf.RTSPTransports) ||
newConf.RunOnConnect != p.conf.RunOnConnect ||
newConf.RunOnConnectRestart != p.conf.RunOnConnectRestart ||
newConf.RunOnDisconnect != p.conf.RunOnDisconnect ||
closeMetrics ||
closePathManager ||
closeLogger
closeRTSPSServer := newConf == nil ||
newConf.RTSP != p.conf.RTSP ||
newConf.RTSPEncryption != p.conf.RTSPEncryption ||
newConf.RTSPSAddress != p.conf.RTSPSAddress ||
!reflect.DeepEqual(newConf.RTSPAuthMethods, p.conf.RTSPAuthMethods) ||
newConf.RTSPUDPReadBufferSize != p.conf.RTSPUDPReadBufferSize ||
newConf.DumpPackets != p.conf.DumpPackets ||
newConf.UDPReadBufferSize != p.conf.UDPReadBufferSize ||
newConf.ReadTimeout != p.conf.ReadTimeout ||
newConf.WriteTimeout != p.conf.WriteTimeout ||
newConf.WriteQueueSize != p.conf.WriteQueueSize ||
newConf.RTSPServerCert != p.conf.RTSPServerCert ||
newConf.RTSPServerKey != p.conf.RTSPServerKey ||
newConf.RTSPAddress != p.conf.RTSPAddress ||
!reflect.DeepEqual(newConf.RTSPTransports, p.conf.RTSPTransports) ||
newConf.RunOnConnect != p.conf.RunOnConnect ||
newConf.RunOnConnectRestart != p.conf.RunOnConnectRestart ||
newConf.RunOnDisconnect != p.conf.RunOnDisconnect ||
closeMetrics ||
closePathManager ||
closeLogger
closeRTMPServer := newConf == nil ||
newConf.RTMP != p.conf.RTMP ||
newConf.RTMPEncryption != p.conf.RTMPEncryption ||
newConf.RTMPAddress != p.conf.RTMPAddress ||
newConf.DumpPackets != p.conf.DumpPackets ||
newConf.ReadTimeout != p.conf.ReadTimeout ||
newConf.WriteTimeout != p.conf.WriteTimeout ||
newConf.RTSPAddress != p.conf.RTSPAddress ||
newConf.RunOnConnect != p.conf.RunOnConnect ||
newConf.RunOnConnectRestart != p.conf.RunOnConnectRestart ||
newConf.RunOnDisconnect != p.conf.RunOnDisconnect ||
closeMetrics ||
closePathManager ||
closeLogger
closeRTMPSServer := newConf == nil ||
newConf.RTMP != p.conf.RTMP ||
newConf.RTMPEncryption != p.conf.RTMPEncryption ||
newConf.RTMPSAddress != p.conf.RTMPSAddress ||
newConf.DumpPackets != p.conf.DumpPackets ||
newConf.ReadTimeout != p.conf.ReadTimeout ||
newConf.WriteTimeout != p.conf.WriteTimeout ||
newConf.RTMPServerCert != p.conf.RTMPServerCert ||
newConf.RTMPServerKey != p.conf.RTMPServerKey ||
newConf.RTSPAddress != p.conf.RTSPAddress ||
newConf.RunOnConnect != p.conf.RunOnConnect ||
newConf.RunOnConnectRestart != p.conf.RunOnConnectRestart ||
newConf.RunOnDisconnect != p.conf.RunOnDisconnect ||
closeMetrics ||
closePathManager ||
closeLogger
closeHLSServer := newConf == nil ||
newConf.HLS != p.conf.HLS ||
newConf.HLSAddress != p.conf.HLSAddress ||
newConf.HLSEncryption != p.conf.HLSEncryption ||
newConf.HLSServerKey != p.conf.HLSServerKey ||
newConf.HLSServerCert != p.conf.HLSServerCert ||
!slices.Equal(newConf.HLSAllowOrigins, p.conf.HLSAllowOrigins) ||
!reflect.DeepEqual(newConf.HLSTrustedProxies, p.conf.HLSTrustedProxies) ||
newConf.HLSAlwaysRemux != p.conf.HLSAlwaysRemux ||
newConf.HLSVariant != p.conf.HLSVariant ||
newConf.HLSSegmentCount != p.conf.HLSSegmentCount ||
newConf.HLSSegmentDuration != p.conf.HLSSegmentDuration ||
newConf.HLSPartDuration != p.conf.HLSPartDuration ||
newConf.HLSSegmentMaxSize != p.conf.HLSSegmentMaxSize ||
newConf.HLSDirectory != p.conf.HLSDirectory ||
newConf.ReadTimeout != p.conf.ReadTimeout ||
newConf.WriteTimeout != p.conf.WriteTimeout ||
newConf.HLSMuxerCloseAfter != p.conf.HLSMuxerCloseAfter ||
newConf.DumpPackets != p.conf.DumpPackets ||
closePathManager ||
closeMetrics ||
closeLogger
closeWebRTCServer := newConf == nil ||
newConf.WebRTC != p.conf.WebRTC ||
newConf.WebRTCAddress != p.conf.WebRTCAddress ||
newConf.WebRTCEncryption != p.conf.WebRTCEncryption ||
newConf.WebRTCServerKey != p.conf.WebRTCServerKey ||
newConf.WebRTCServerCert != p.conf.WebRTCServerCert ||
!slices.Equal(newConf.WebRTCAllowOrigins, p.conf.WebRTCAllowOrigins) ||
!reflect.DeepEqual(newConf.WebRTCTrustedProxies, p.conf.WebRTCTrustedProxies) ||
newConf.ReadTimeout != p.conf.ReadTimeout ||
newConf.WriteTimeout != p.conf.WriteTimeout ||
newConf.UDPReadBufferSize != p.conf.UDPReadBufferSize ||
newConf.WebRTCLocalUDPAddress != p.conf.WebRTCLocalUDPAddress ||
newConf.WebRTCLocalTCPAddress != p.conf.WebRTCLocalTCPAddress ||
newConf.WebRTCIPsFromInterfaces != p.conf.WebRTCIPsFromInterfaces ||
!reflect.DeepEqual(newConf.WebRTCIPsFromInterfacesList, p.conf.WebRTCIPsFromInterfacesList) ||
!reflect.DeepEqual(newConf.WebRTCAdditionalHosts, p.conf.WebRTCAdditionalHosts) ||
!reflect.DeepEqual(newConf.WebRTCICEServers2, p.conf.WebRTCICEServers2) ||
newConf.WebRTCSTUNGatherTimeout != p.conf.WebRTCSTUNGatherTimeout ||
newConf.WebRTCHandshakeTimeout != p.conf.WebRTCHandshakeTimeout ||
newConf.WebRTCTrackGatherTimeout != p.conf.WebRTCTrackGatherTimeout ||
newConf.DumpPackets != p.conf.DumpPackets ||
closeMetrics ||
closePathManager ||
closeLogger
closeSRTServer := newConf == nil ||
newConf.SRT != p.conf.SRT ||
newConf.SRTAddress != p.conf.SRTAddress ||
newConf.RTSPAddress != p.conf.RTSPAddress ||
newConf.ReadTimeout != p.conf.ReadTimeout ||
newConf.WriteTimeout != p.conf.WriteTimeout ||
newConf.UDPMaxPayloadSize != p.conf.UDPMaxPayloadSize ||
newConf.RunOnConnect != p.conf.RunOnConnect ||
newConf.RunOnConnectRestart != p.conf.RunOnConnectRestart ||
newConf.RunOnDisconnect != p.conf.RunOnDisconnect ||
closePathManager ||
closeLogger
closeAPI := newConf == nil ||
newConf.API != p.conf.API ||
newConf.APIAddress != p.conf.APIAddress ||
newConf.APIEncryption != p.conf.APIEncryption ||
newConf.APIServerKey != p.conf.APIServerKey ||
newConf.APIServerCert != p.conf.APIServerCert ||
!slices.Equal(newConf.APIAllowOrigins, p.conf.APIAllowOrigins) ||
!reflect.DeepEqual(newConf.APITrustedProxies, p.conf.APITrustedProxies) ||
newConf.ReadTimeout != p.conf.ReadTimeout ||
newConf.WriteTimeout != p.conf.WriteTimeout ||
newConf.DumpPackets != p.conf.DumpPackets ||
closeAuthManager ||
closePathManager ||
closeRTSPServer ||
closeRTSPSServer ||
closeRTMPServer ||
closeHLSServer ||
closeWebRTCServer ||
closeSRTServer ||
closeLogger
if newConf == nil && p.confWatcher != nil {
p.confWatcher.Close()
p.confWatcher = nil
}
if p.api != nil {
if closeAPI {
p.api.Close()
p.api = nil
} else if !calledByAPI { // avoid a loop
p.api.ReloadConf(newConf)
}
}
if closeSRTServer && p.srtServer != nil {
p.srtServer.Close()
p.srtServer = nil
}
if closeWebRTCServer && p.webRTCServer != nil {
p.webRTCServer.Close()
p.webRTCServer = nil
}
if closeHLSServer && p.hlsServer != nil {
p.hlsServer.Close()
p.hlsServer = nil
}
if closeRTMPSServer && p.rtmpsServer != nil {
p.rtmpsServer.Close()
p.rtmpsServer = nil
}
if closeRTMPServer && p.rtmpServer != nil {
p.rtmpServer.Close()
p.rtmpServer = nil
}
if closeRTSPSServer && p.rtspsServer != nil {
p.rtspsServer.Close()
p.rtspsServer = nil
}
if closeRTSPServer && p.rtspServer != nil {
p.rtspServer.Close()
p.rtspServer = nil
}
if closePathManager && p.pathManager != nil {
p.pathManager.close()
p.pathManager = nil
}
if closePlaybackServer && p.playbackServer != nil {
p.playbackServer.Close()
p.playbackServer = nil
}
if closeRecorderCleaner && p.recordCleaner != nil {
p.recordCleaner.Close()
p.recordCleaner = nil
}
if closePPROF && p.pprof != nil {
p.pprof.Close()
p.pprof = nil
}
if closeMetrics && p.metrics != nil {
p.metrics.Close()
p.metrics = nil
}
if closeAuthManager && p.authManager != nil {
p.authManager = nil
}
if newConf == nil && p.externalCmdPool != nil {
p.Log(logger.Info, "waiting for running hooks")
p.externalCmdPool.Close()
}
if closeLogger && p.logger != nil {
if newConf == nil {
p.logger.Close()
}
p.logger = nil
}
}
func (p *Core) reloadConf(newConf *conf.Conf, calledByAPI bool) error {
oldLogger := p.logger
p.closeResources(newConf, calledByAPI)
p.conf = newConf
err := p.createResources(false)
if err != nil {
p.logger = oldLogger
return err
}
if p.logger != oldLogger {
oldLogger.Close()
}
return nil
}
// APIConfigSet is called by api.
func (p *Core) APIConfigSet(conf *conf.Conf) {
select {
case p.chAPIConfigSet <- conf:
case <-p.ctx.Done():
}
}
================================================
FILE: internal/core/core_test.go
================================================
package core
import (
"os"
"path/filepath"
"testing"
"time"
"github.com/bluenviron/gortsplib/v5"
"github.com/bluenviron/gortsplib/v5/pkg/description"
"github.com/bluenviron/mediamtx/internal/test"
"github.com/stretchr/testify/require"
)
func newInstance(conf string) (*Core, bool) {
if conf == "" {
return New([]string{})
}
tmpf, err := test.CreateTempFile([]byte(conf))
if err != nil {
return nil, false
}
defer os.Remove(tmpf)
return New([]string{tmpf})
}
func TestCoreErrors(t *testing.T) {
for _, ca := range []struct {
name string
conf string
}{
{
"logger",
"logDestinations: [file]\n" +
"logFile: /nonexisting/nonexist\n" +
"sysLogPrefix: /mediamtx\n",
},
{
"metrics",
"metrics: yes\n" +
"metricsAddress: invalid\n",
},
{
"pprof",
"pprof: yes\n" +
"pprofAddress: invalid\n",
},
{
"playback",
"playback: yes\n" +
"playbackAddress: invalid\n",
},
{
"rtsp",
"rtspAddress: invalid\n",
},
{
"rtsps",
"rtspEncryption: strict\n" +
"rtspAddress: invalid\n",
},
{
"rtmp",
"rtmpAddress: invalid\n",
},
{
"rtmps",
"rtmpEncryption: strict\n" +
"rtmpAddress: invalid\n",
},
{
"hls",
"hlsAddress: invalid\n",
},
{
"webrtc",
"webrtcAddress: invalid\n",
},
{
"srt",
"srtAddress: invalid\n",
},
{
"api",
"api: yes\n" +
"apiAddress: invalid\n",
},
} {
t.Run(ca.name, func(t *testing.T) {
_, ok := newInstance(ca.conf)
require.Equal(t, false, ok)
})
}
}
func TestCoreHotReloading(t *testing.T) {
confPath := filepath.Join(os.TempDir(), "rtsp-conf")
err := os.WriteFile(confPath, []byte("paths:\n"+
" test1:\n"+
" publishUser: myuser\n"+
" publishPass: mypass\n"),
0o644)
require.NoError(t, err)
defer os.Remove(confPath)
p, ok := New([]string{confPath})
require.Equal(t, true, ok)
defer p.Close()
func() {
c := gortsplib.Client{}
err = c.StartRecording("rtsp://localhost:8554/test1",
&description.Session{Medias: []*description.Media{test.UniqueMediaH264()}})
require.EqualError(t, err, "bad status code: 401 (Unauthorized)")
}()
err = os.WriteFile(confPath, []byte("paths:\n"+
" test1:\n"),
0o644)
require.NoError(t, err)
time.Sleep(1 * time.Second)
func() {
conn := gortsplib.Client{}
err = conn.StartRecording("rtsp://localhost:8554/test1",
&description.Session{Medias: []*description.Media{test.UniqueMediaH264()}})
require.NoError(t, err)
defer conn.Close()
}()
}
func TestCoreHotReloadingAndLoggerError(t *testing.T) {
confPath := filepath.Join(os.TempDir(), "rtsp-conf")
err := os.WriteFile(confPath, []byte(""),
0o644)
require.NoError(t, err)
defer os.Remove(confPath)
p, ok := New([]string{confPath})
require.Equal(t, true, ok)
defer p.Close()
err = os.WriteFile(confPath, []byte("logDestinations: [file]\n"+
"logFile: /nonexisting/nonexist\n"),
0o644)
require.NoError(t, err)
p.Wait()
}
================================================
FILE: internal/core/metrics_test.go
================================================
package core
import (
"bufio"
"context"
"crypto/tls"
"io"
"net/http"
"net/url"
"os"
"sync"
"testing"
"time"
"github.com/bluenviron/gortmplib"
rtmpcodecs "github.com/bluenviron/gortmplib/pkg/codecs"
"github.com/bluenviron/gortsplib/v5"
"github.com/bluenviron/gortsplib/v5/pkg/description"
"github.com/bluenviron/mediacommon/v2/pkg/formats/mpegts"
tscodecs "github.com/bluenviron/mediacommon/v2/pkg/formats/mpegts/codecs"
srt "github.com/datarhei/gosrt"
"github.com/pion/rtp"
pwebrtc "github.com/pion/webrtc/v4"
"github.com/stretchr/testify/require"
"github.com/bluenviron/mediamtx/internal/protocols/webrtc"
"github.com/bluenviron/mediamtx/internal/protocols/whip"
"github.com/bluenviron/mediamtx/internal/test"
)
func httpPullFile(t *testing.T, hc *http.Client, u string) []byte {
res, err := hc.Get(u)
require.NoError(t, err)
defer res.Body.Close()
if res.StatusCode != http.StatusOK {
t.Errorf("bad status code: %v", res.StatusCode)
}
byts, err := io.ReadAll(res.Body)
require.NoError(t, err)
return byts
}
func TestMetrics(t *testing.T) {
serverCertFpath, err := test.CreateTempFile(test.TLSCertPub)
require.NoError(t, err)
defer os.Remove(serverCertFpath)
serverKeyFpath, err := test.CreateTempFile(test.TLSCertKey)
require.NoError(t, err)
defer os.Remove(serverKeyFpath)
p, ok := newInstance("api: yes\n" +
"hlsAlwaysRemux: yes\n" +
"metrics: yes\n" +
"webrtcServerCert: " + serverCertFpath + "\n" +
"webrtcServerKey: " + serverKeyFpath + "\n" +
"rtspEncryption: optional\n" +
"rtspServerCert: " + serverCertFpath + "\n" +
"rtspServerKey: " + serverKeyFpath + "\n" +
"rtmpEncryption: optional\n" +
"rtmpServerCert: " + serverCertFpath + "\n" +
"rtmpServerKey: " + serverKeyFpath + "\n" +
"paths:\n" +
" all_others:\n")
require.Equal(t, true, ok)
defer p.Close()
tr := &http.Transport{}
defer tr.CloseIdleConnections()
hc := &http.Client{Transport: tr}
t.Run("initial", func(t *testing.T) {
bo := httpPullFile(t, hc, "http://localhost:9998/metrics")
require.Equal(t, `paths 0
paths_inbound_bytes 0
paths_outbound_bytes 0
paths_inbound_frames_in_error 0
paths_bytes_received 0
paths_bytes_sent 0
paths_readers 0
hls_muxers 0
hls_muxers_outbound_bytes 0
hls_muxers_outbound_frames_discarded 0
hls_muxers_bytes_sent 0
rtsp_conns 0
rtsp_conns_inbound_bytes 0
rtsp_conns_outbound_bytes 0
rtsp_conns_bytes_received 0
rtsp_conns_bytes_sent 0
rtsp_sessions 0
rtsp_sessions_inbound_bytes 0
rtsp_sessions_inbound_rtp_packets 0
rtsp_sessions_inbound_rtp_packets_lost 0
rtsp_sessions_inbound_rtp_packets_in_error 0
rtsp_sessions_inbound_rtp_packets_jitter 0
rtsp_sessions_inbound_rtcp_packets 0
rtsp_sessions_inbound_rtcp_packets_in_error 0
rtsp_sessions_outbound_bytes 0
rtsp_sessions_outbound_rtp_packets 0
rtsp_sessions_outbound_rtp_packets_reported_lost 0
rtsp_sessions_outbound_rtp_packets_discarded 0
rtsp_sessions_outbound_rtcp_packets 0
rtsp_sessions_bytes_received 0
rtsp_sessions_bytes_sent 0
rtsp_sessions_rtp_packets_received 0
rtsp_sessions_rtp_packets_sent 0
rtsp_sessions_rtp_packets_lost 0
rtsp_sessions_rtp_packets_in_error 0
rtsp_sessions_rtp_packets_jitter 0
rtsp_sessions_rtcp_packets_received 0
rtsp_sessions_rtcp_packets_sent 0
rtsp_sessions_rtcp_packets_in_error 0
rtsps_conns 0
rtsps_conns_inbound_bytes 0
rtsps_conns_outbound_bytes 0
rtsps_conns_bytes_received 0
rtsps_conns_bytes_sent 0
rtsps_sessions 0
rtsps_sessions_inbound_bytes 0
rtsps_sessions_inbound_rtp_packets 0
rtsps_sessions_inbound_rtp_packets_lost 0
rtsps_sessions_inbound_rtp_packets_in_error 0
rtsps_sessions_inbound_rtp_packets_jitter 0
rtsps_sessions_inbound_rtcp_packets 0
rtsps_sessions_inbound_rtcp_packets_in_error 0
rtsps_sessions_outbound_bytes 0
rtsps_sessions_outbound_rtp_packets 0
rtsps_sessions_outbound_rtp_packets_reported_lost 0
rtsps_sessions_outbound_rtp_packets_discarded 0
rtsps_sessions_outbound_rtcp_packets 0
rtsps_sessions_bytes_received 0
rtsps_sessions_bytes_sent 0
rtsps_sessions_rtp_packets_received 0
rtsps_sessions_rtp_packets_sent 0
rtsps_sessions_rtp_packets_lost 0
rtsps_sessions_rtp_packets_in_error 0
rtsps_sessions_rtp_packets_jitter 0
rtsps_sessions_rtcp_packets_received 0
rtsps_sessions_rtcp_packets_sent 0
rtsps_sessions_rtcp_packets_in_error 0
rtmp_conns 0
rtmp_conns_inbound_bytes 0
rtmp_conns_outbound_bytes 0
rtmp_conns_outbound_frames_discarded 0
rtmp_conns_bytes_received 0
rtmp_conns_bytes_sent 0
rtmps_conns 0
rtmps_conns_inbound_bytes 0
rtmps_conns_outbound_bytes 0
rtmps_conns_outbound_frames_discarded 0
rtmps_conns_bytes_received 0
rtmps_conns_bytes_sent 0
srt_conns 0
srt_conns_packets_sent 0
srt_conns_packets_received 0
srt_conns_packets_sent_unique 0
srt_conns_packets_received_unique 0
srt_conns_packets_send_loss 0
srt_conns_packets_received_loss 0
srt_conns_packets_retrans 0
srt_conns_packets_received_retrans 0
srt_conns_packets_sent_ack 0
srt_conns_packets_received_ack 0
srt_conns_packets_sent_nak 0
srt_conns_packets_received_nak 0
srt_conns_packets_sent_km 0
srt_conns_packets_received_km 0
srt_conns_us_snd_duration 0
srt_conns_packets_received_belated 0
srt_conns_packets_send_drop 0
srt_conns_packets_received_drop 0
srt_conns_packets_received_undecrypt 0
srt_conns_bytes_sent 0
srt_conns_bytes_received 0
srt_conns_bytes_sent_unique 0
srt_conns_bytes_received_unique 0
srt_conns_bytes_received_loss 0
srt_conns_bytes_retrans 0
srt_conns_bytes_received_retrans 0
srt_conns_bytes_received_belated 0
srt_conns_bytes_send_drop 0
srt_conns_bytes_received_drop 0
srt_conns_bytes_received_undecrypt 0
srt_conns_us_packets_send_period 0
srt_conns_packets_flow_window 0
srt_conns_packets_flight_size 0
srt_conns_ms_rtt 0
srt_conns_mbps_send_rate 0
srt_conns_mbps_receive_rate 0
srt_conns_mbps_link_capacity 0
srt_conns_bytes_avail_send_buf 0
srt_conns_bytes_avail_receive_buf 0
srt_conns_mbps_max_bw 0
srt_conns_bytes_mss 0
srt_conns_packets_send_buf 0
srt_conns_bytes_send_buf 0
srt_conns_ms_send_buf 0
srt_conns_ms_send_tsb_pd_delay 0
srt_conns_packets_receive_buf 0
srt_conns_bytes_receive_buf 0
srt_conns_ms_receive_buf 0
srt_conns_ms_receive_tsb_pd_delay 0
srt_conns_packets_reorder_tolerance 0
srt_conns_packets_received_avg_belated_time 0
srt_conns_packets_send_loss_rate 0
srt_conns_packets_received_loss_rate 0
srt_conns_outbound_frames_discarded 0
webrtc_sessions 0
webrtc_sessions_inbound_bytes 0
webrtc_sessions_inbound_rtp_packets 0
webrtc_sessions_inbound_rtp_packets_lost 0
webrtc_sessions_inbound_rtp_packets_jitter 0
webrtc_sessions_inbound_rtcp_packets 0
webrtc_sessions_outbound_bytes 0
webrtc_sessions_outbound_rtp_packets 0
webrtc_sessions_outbound_rtcp_packets 0
webrtc_sessions_outbound_frames_discarded 0
webrtc_sessions_bytes_received 0
webrtc_sessions_bytes_sent 0
webrtc_sessions_rtp_packets_received 0
webrtc_sessions_rtp_packets_sent 0
webrtc_sessions_rtp_packets_lost 0
webrtc_sessions_rtp_packets_jitter 0
webrtc_sessions_rtcp_packets_received 0
webrtc_sessions_rtcp_packets_sent 0
`, string(bo))
})
t.Run("with data", func(t *testing.T) {
terminate := make(chan struct{})
var wg sync.WaitGroup
wg.Add(6)
go func() {
defer wg.Done()
source := gortsplib.Client{}
err2 := source.StartRecording("rtsp://localhost:8554/rtsp_path",
&description.Session{Medias: []*description.Media{test.UniqueMediaH264()}})
require.NoError(t, err2)
defer source.Close()
<-terminate
}()
go func() {
defer wg.Done()
source2 := gortsplib.Client{TLSConfig: &tls.Config{InsecureSkipVerify: true}}
err2 := source2.StartRecording("rtsps://localhost:8322/rtsps_path",
&description.Session{Medias: []*description.Media{test.UniqueMediaH264()}})
require.NoError(t, err2)
defer source2.Close()
<-terminate
}()
go func() {
defer wg.Done()
u, err2 := url.Parse("rtmp://localhost:1935/rtmp_path")
require.NoError(t, err2)
conn := &gortmplib.Client{
URL: u,
Publish: true,
}
err2 = conn.Initialize(context.Background())
require.NoError(t, err2)
defer conn.Close()
track := &gortmplib.Track{
Codec: &rtmpcodecs.H264{
SPS: test.FormatH264.SPS,
PPS: test.FormatH264.PPS,
},
}
w := &gortmplib.Writer{
Conn: conn,
Tracks: []*gortmplib.Track{track},
}
err2 = w.Initialize()
require.NoError(t, err2)
err2 = w.WriteH264(track, 2*time.Second, 2*time.Second, [][]byte{{5, 2, 3, 4}})
require.NoError(t, err2)
<-terminate
}()
go func() {
defer wg.Done()
u, err2 := url.Parse("rtmps://localhost:1936/rtmps_path")
require.NoError(t, err2)
conn := &gortmplib.Client{
URL: u,
TLSConfig: &tls.Config{InsecureSkipVerify: true},
Publish: true,
}
err2 = conn.Initialize(context.Background())
require.NoError(t, err2)
defer conn.Close()
track := &gortmplib.Track{
Codec: &rtmpcodecs.H264{
SPS: test.FormatH264.SPS,
PPS: test.FormatH264.PPS,
},
}
w := &gortmplib.Writer{
Conn: conn,
Tracks: []*gortmplib.Track{track},
}
err2 = w.Initialize()
require.NoError(t, err2)
err2 = w.WriteH264(track, 2*time.Second, 2*time.Second, [][]byte{{5, 2, 3, 4}})
require.NoError(t, err2)
<-terminate
}()
go func() {
defer wg.Done()
su, err2 := url.Parse("http://localhost:8889/webrtc_path/whip")
require.NoError(t, err2)
tr2 := &http.Transport{}
defer tr2.CloseIdleConnections()
hc2 := &http.Client{Transport: tr2}
track := &webrtc.OutgoingTrack{
Caps: pwebrtc.RTPCodecCapability{
MimeType: pwebrtc.MimeTypeH264,
ClockRate: 90000,
SDPFmtpLine: "level-asymmetry-allowed=1;packetization-mode=1;profile-level-id=42e01f",
},
}
s := &whip.Client{
HTTPClient: hc2,
URL: su,
Log: test.NilLogger,
Publish: true,
OutgoingTracks: []*webrtc.OutgoingTrack{track},
}
err2 = s.Initialize(context.Background())
require.NoError(t, err2)
defer checkClose(t, s.Close)
err2 = track.WriteRTP(&rtp.Packet{
Header: rtp.Header{
Version: 2,
Marker: true,
PayloadType: 96,
SequenceNumber: 123,
Timestamp: 45343,
SSRC: 563423,
},
Payload: []byte{1},
})
require.NoError(t, err2)
<-terminate
}()
go func() {
defer wg.Done()
srtConf := srt.DefaultConfig()
address, err2 := srtConf.UnmarshalURL("srt://localhost:8890?streamid=publish:srt_path")
require.NoError(t, err2)
err2 = srtConf.Validate()
require.NoError(t, err2)
publisher, err2 := srt.Dial("srt", address, srtConf)
require.NoError(t, err2)
defer publisher.Close()
track := &mpegts.Track{
Codec: &tscodecs.H264{},
}
bw := bufio.NewWriter(publisher)
w := &mpegts.Writer{W: bw, Tracks: []*mpegts.Track{track}}
err2 = w.Initialize()
require.NoError(t, err2)
err2 = w.WriteH264(track, 0, 0, [][]byte{
test.FormatH264.SPS,
test.FormatH264.PPS,
{0x05, 1}, // IDR
})
require.NoError(t, err2)
err2 = bw.Flush()
require.NoError(t, err2)
<-terminate
}()
time.Sleep(500*time.Millisecond + 2*time.Second)
bo := httpPullFile(t, hc, "http://localhost:9998/metrics")
require.Regexp(t,
`^paths\{name=".*?",state="ready"\} 1`+"\n"+
`paths_inbound_bytes\{name=".*?",state="ready"\} [0-9]+`+"\n"+
`paths_outbound_bytes\{name=".*?",state="ready"\} [0-9]+`+"\n"+
`paths_inbound_frames_in_error\{name=".*?",state="ready"\} [0-9]+`+"\n"+
`paths_bytes_received\{name=".*?",state="ready"\} [0-9]+`+"\n"+
`paths_bytes_sent\{name=".*?",state="ready"\} [0-9]+`+"\n"+
`paths_readers\{name=".*?",state="ready"\} [0-9]+`+"\n"+
`paths\{name=".*?",state="ready"\} 1`+"\n"+
`paths_inbound_bytes\{name=".*?",state="ready"\} [0-9]+`+"\n"+
`paths_outbound_bytes\{name=".*?",state="ready"\} [0-9]+`+"\n"+
`paths_inbound_frames_in_error\{name=".*?",state="ready"\} [0-9]+`+"\n"+
`paths_bytes_received\{name=".*?",state="ready"\} [0-9]+`+"\n"+
`paths_bytes_sent\{name=".*?",state="ready"\} [0-9]+`+"\n"+
`paths_readers\{name=".*?",state="ready"\} [0-9]+`+"\n"+
`paths\{name=".*?",state="ready"\} 1`+"\n"+
`paths_inbound_bytes\{name=".*?",state="ready"\} [0-9]+`+"\n"+
`paths_outbound_bytes\{name=".*?",state="ready"\} [0-9]+`+"\n"+
`paths_inbound_frames_in_error\{name=".*?",state="ready"\} [0-9]+`+"\n"+
`paths_bytes_received\{name=".*?",state="ready"\} [0-9]+`+"\n"+
`paths_bytes_sent\{name=".*?",state="ready"\} [0-9]+`+"\n"+
`paths_readers\{name=".*?",state="ready"\} [0-9]+`+"\n"+
`paths\{name=".*?",state="ready"\} 1`+"\n"+
`paths_inbound_bytes\{name=".*?",state="ready"\} [0-9]+`+"\n"+
`paths_outbound_bytes\{name=".*?",state="ready"\} [0-9]+`+"\n"+
`paths_inbound_frames_in_error\{name=".*?",state="ready"\} [0-9]+`+"\n"+
`paths_bytes_received\{name=".*?",state="ready"\} [0-9]+`+"\n"+
`paths_bytes_sent\{name=".*?",state="ready"\} [0-9]+`+"\n"+
`paths_readers\{name=".*?",state="ready"\} [0-9]+`+"\n"+
`paths\{name=".*?",state="ready"\} 1`+"\n"+
`paths_inbound_bytes\{name=".*?",state="ready"\} [0-9]+`+"\n"+
`paths_outbound_bytes\{name=".*?",state="ready"\} [0-9]+`+"\n"+
`paths_inbound_frames_in_error\{name=".*?",state="ready"\} [0-9]+`+"\n"+
`paths_bytes_received\{name=".*?",state="ready"\} [0-9]+`+"\n"+
`paths_bytes_sent\{name=".*?",state="ready"\} [0-9]+`+"\n"+
`paths_readers\{name=".*?",state="ready"\} [0-9]+`+"\n"+
`paths\{name=".*?",state="ready"\} 1`+"\n"+
`paths_inbound_bytes\{name=".*?",state="ready"\} [0-9]+`+"\n"+
`paths_outbound_bytes\{name=".*?",state="ready"\} [0-9]+`+"\n"+
`paths_inbound_frames_in_error\{name=".*?",state="ready"\} [0-9]+`+"\n"+
`paths_bytes_received\{name=".*?",state="ready"\} [0-9]+`+"\n"+
`paths_bytes_sent\{name=".*?",state="ready"\} [0-9]+`+"\n"+
`paths_readers\{name=".*?",state="ready"\} [0-9]+`+"\n"+
`hls_muxers\{name=".*?"\} 1`+"\n"+
`hls_muxers_outbound_bytes\{name=".*?"\} 0`+"\n"+
`hls_muxers_outbound_frames_discarded\{name=".*?"\} 0`+"\n"+
`hls_muxers_bytes_sent\{name=".*?"\} 0`+"\n"+
`hls_muxers\{name=".*?"\} 1`+"\n"+
`hls_muxers_outbound_bytes\{name=".*?"\} 0`+"\n"+
`hls_muxers_outbound_frames_discarded\{name=".*?"\} 0`+"\n"+
`hls_muxers_bytes_sent\{name=".*?"\} 0`+"\n"+
`hls_muxers\{name=".*?"\} 1`+"\n"+
`hls_muxers_outbound_bytes\{name=".*?"\} 0`+"\n"+
`hls_muxers_outbound_frames_discarded\{name=".*?"\} 0`+"\n"+
`hls_muxers_bytes_sent\{name=".*?"\} 0`+"\n"+
`hls_muxers\{name=".*?"\} 1`+"\n"+
`hls_muxers_outbound_bytes\{name=".*?"\} 0`+"\n"+
`hls_muxers_outbound_frames_discarded\{name=".*?"\} 0`+"\n"+
`hls_muxers_bytes_sent\{name=".*?"\} 0`+"\n"+
`hls_muxers\{name=".*?"\} 1`+"\n"+
`hls_muxers_outbound_bytes\{name=".*?"\} 0`+"\n"+
`hls_muxers_outbound_frames_discarded\{name=".*?"\} 0`+"\n"+
`hls_muxers_bytes_sent\{name=".*?"\} 0`+"\n"+
`hls_muxers\{name=".*?"\} 1`+"\n"+
`hls_muxers_outbound_bytes\{name=".*?"\} 0`+"\n"+
`hls_muxers_outbound_frames_discarded\{name=".*?"\} 0`+"\n"+
`hls_muxers_bytes_sent\{name=".*?"\} 0`+"\n"+
`rtsp_conns\{id=".*?"\} 1`+"\n"+
`rtsp_conns_inbound_bytes\{id=".*?"\} [0-9]+`+"\n"+
`rtsp_conns_outbound_bytes\{id=".*?"\} [0-9]+`+"\n"+
`rtsp_conns_bytes_received\{id=".*?"\} [0-9]+`+"\n"+
`rtsp_conns_bytes_sent\{id=".*?"\} [0-9]+`+"\n"+
`rtsp_sessions\{id=".*?",path=".*?",remoteAddr=".*?",state="publish"\} 1`+"\n"+
`rtsp_sessions_inbound_bytes\{id=".*?",path=".*?",remoteAddr=".*?",state="publish"\} [0-9]+`+"\n"+
`rtsp_sessions_inbound_rtp_packets\{id=".*?",path=".*?",remoteAddr=".*?",state="publish"\} [0-9]+`+"\n"+
`rtsp_sessions_inbound_rtp_packets_lost\{id=".*?",path=".*?",remoteAddr=".*?",state="publish"\} [0-9]+`+"\n"+
`rtsp_sessions_inbound_rtp_packets_in_error\{id=".*?",path=".*?",remoteAddr=".*?",state="publish"\} [0-9]+`+"\n"+
`rtsp_sessions_inbound_rtp_packets_jitter\{id=".*?",path=".*?",remoteAddr=".*?",state="publish"\} [0-9]+`+"\n"+
`rtsp_sessions_inbound_rtcp_packets\{id=".*?",path=".*?",remoteAddr=".*?",state="publish"\} [0-9]+`+"\n"+
`rtsp_sessions_inbound_rtcp_packets_in_error\{id=".*?",path=".*?",remoteAddr=".*?",state="publish"\} [0-9]+`+"\n"+
`rtsp_sessions_outbound_bytes\{id=".*?",path=".*?",remoteAddr=".*?",state="publish"\} [0-9]+`+"\n"+
`rtsp_sessions_outbound_rtp_packets\{id=".*?",path=".*?",remoteAddr=".*?",state="publish"\} [0-9]+`+"\n"+
`rtsp_sessions_outbound_rtp_packets_reported_lost\{id=".*?",path=".*?",`+
`remoteAddr=".*?",state="publish"\} [0-9]+`+"\n"+
`rtsp_sessions_outbound_rtp_packets_discarded\{id=".*?",path=".*?",`+
`remoteAddr=".*?",state="publish"\} [0-9]+`+"\n"+
`rtsp_sessions_outbound_rtcp_packets\{id=".*?",path=".*?",remoteAddr=".*?",state="publish"\} [0-9]+`+"\n"+
`rtsp_sessions_bytes_received\{id=".*?",path=".*?",remoteAddr=".*?",state="publish"\} 0`+"\n"+
`rtsp_sessions_bytes_sent\{id=".*?",path=".*?",remoteAddr=".*?",state="publish"\} [0-9]+`+"\n"+
`rtsp_sessions_rtp_packets_received\{id=".*?",path=".*?",remoteAddr=".*?",state="publish"\} [0-9]+`+"\n"+
`rtsp_sessions_rtp_packets_sent\{id=".*?",path=".*?",remoteAddr=".*?",state="publish"\} [0-9]+`+"\n"+
`rtsp_sessions_rtp_packets_lost\{id=".*?",path=".*?",remoteAddr=".*?",state="publish"\} [0-9]+`+"\n"+
`rtsp_sessions_rtp_packets_in_error\{id=".*?",path=".*?",remoteAddr=".*?",state="publish"\} [0-9]+`+"\n"+
`rtsp_sessions_rtp_packets_jitter\{id=".*?",path=".*?",remoteAddr=".*?",state="publish"\} [0-9]+`+"\n"+
`rtsp_sessions_rtcp_packets_received\{id=".*?",path=".*?",remoteAddr=".*?",state="publish"\} [0-9]+`+"\n"+
`rtsp_sessions_rtcp_packets_sent\{id=".*?",path=".*?",remoteAddr=".*?",state="publish"\} [0-9]+`+"\n"+
`rtsp_sessions_rtcp_packets_in_error\{id=".*?",path=".*?",remoteAddr=".*?",state="publish"\} [0-9]+`+"\n"+
`rtsps_conns\{id=".*?"\} 1`+"\n"+
`rtsps_conns_inbound_bytes\{id=".*?"\} [0-9]+`+"\n"+
`rtsps_conns_outbound_bytes\{id=".*?"\} [0-9]+`+"\n"+
`rtsps_conns_bytes_received\{id=".*?"\} [0-9]+`+"\n"+
`rtsps_conns_bytes_sent\{id=".*?"\} [0-9]+`+"\n"+
`rtsps_sessions\{id=".*?",path=".*?",remoteAddr=".*?",state="publish"\} 1`+"\n"+
`rtsps_sessions_inbound_bytes\{id=".*?",path=".*?",remoteAddr=".*?",state="publish"\} [0-9]+`+"\n"+
`rtsps_sessions_inbound_rtp_packets\{id=".*?",path=".*?",remoteAddr=".*?",state="publish"\} [0-9]+`+"\n"+
`rtsps_sessions_inbound_rtp_packets_lost\{id=".*?",path=".*?",remoteAddr=".*?",state="publish"\} [0-9]+`+"\n"+
`rtsps_sessions_inbound_rtp_packets_in_error\{id=".*?",path=".*?",remoteAddr=".*?",state="publish"\} [0-9]+`+"\n"+
`rtsps_sessions_inbound_rtp_packets_jitter\{id=".*?",path=".*?",remoteAddr=".*?",state="publish"\} [0-9]+`+"\n"+
`rtsps_sessions_inbound_rtcp_packets\{id=".*?",path=".*?",remoteAddr=".*?",state="publish"\} [0-9]+`+"\n"+
`rtsps_sessions_inbound_rtcp_packets_in_error\{id=".*?",path=".*?",remoteAddr=".*?",state="publish"\} [0-9]+`+"\n"+
`rtsps_sessions_outbound_bytes\{id=".*?",path=".*?",remoteAddr=".*?",state="publish"\} [0-9]+`+"\n"+
`rtsps_sessions_outbound_rtp_packets\{id=".*?",path=".*?",remoteAddr=".*?",state="publish"\} [0-9]+`+"\n"+
`rtsps_sessions_outbound_rtp_packets_reported_lost\{id=".*?",path=".*?",`+
`remoteAddr=".*?",state="publish"\} [0-9]+`+"\n"+
`rtsps_sessions_outbound_rtp_packets_discarded\{id=".*?",path=".*?",`+
`remoteAddr=".*?",state="publish"\} [0-9]+`+"\n"+
`rtsps_sessions_outbound_rtcp_packets\{id=".*?",path=".*?",remoteAddr=".*?",state="publish"\} [0-9]+`+"\n"+
`rtsps_sessions_bytes_received\{id=".*?",path=".*?",remoteAddr=".*?",state="publish"\} 0`+"\n"+
`rtsps_sessions_bytes_sent\{id=".*?",path=".*?",remoteAddr=".*?",state="publish"\} [0-9]+`+"\n"+
`rtsps_sessions_rtp_packets_received\{id=".*?",path=".*?",remoteAddr=".*?",state="publish"\} [0-9]+`+"\n"+
`rtsps_sessions_rtp_packets_sent\{id=".*?",path=".*?",remoteAddr=".*?",state="publish"\} [0-9]+`+"\n"+
`rtsps_sessions_rtp_packets_lost\{id=".*?",path=".*?",remoteAddr=".*?",state="publish"\} [0-9]+`+"\n"+
`rtsps_sessions_rtp_packets_in_error\{id=".*?",path=".*?",remoteAddr=".*?",state="publish"\} [0-9]+`+"\n"+
`rtsps_sessions_rtp_packets_jitter\{id=".*?",path=".*?",remoteAddr=".*?",state="publish"\} [0-9]+`+"\n"+
`rtsps_sessions_rtcp_packets_received\{id=".*?",path=".*?",remoteAddr=".*?",state="publish"\} [0-9]+`+"\n"+
`rtsps_sessions_rtcp_packets_sent\{id=".*?",path=".*?",remoteAddr=".*?",state="publish"\} [0-9]+`+"\n"+
`rtsps_sessions_rtcp_packets_in_error\{id=".*?",path=".*?",remoteAddr=".*?",state="publish"\} [0-9]+`+"\n"+
`rtmp_conns\{id=".*?",path=".*?",remoteAddr=".*?",state="publish"\} 1`+"\n"+
`rtmp_conns_inbound_bytes\{id=".*?",path=".*?",remoteAddr=".*?",state="publish"\} [0-9]+`+"\n"+
`rtmp_conns_outbound_bytes\{id=".*?",path=".*?",remoteAddr=".*?",state="publish"\} [0-9]+`+"\n"+
`rtmp_conns_outbound_frames_discarded\{id=".*?",path=".*?",remoteAddr=".*?",state="publish"\} [0-9]+`+"\n"+
`rtmp_conns_bytes_received\{id=".*?",path=".*?",remoteAddr=".*?",state="publish"\} [0-9]+`+"\n"+
`rtmp_conns_bytes_sent\{id=".*?",path=".*?",remoteAddr=".*?",state="publish"\} [0-9]+`+"\n"+
`rtmps_conns\{id=".*?",path=".*?",remoteAddr=".*?",state="publish"\} 1`+"\n"+
`rtmps_conns_inbound_bytes\{id=".*?",path=".*?",remoteAddr=".*?",state="publish"\} [0-9]+`+"\n"+
`rtmps_conns_outbound_bytes\{id=".*?",path=".*?",remoteAddr=".*?",state="publish"\} [0-9]+`+"\n"+
`rtmps_conns_outbound_frames_discarded\{id=".*?",path=".*?",remoteAddr=".*?",state="publish"\} [0-9]+`+"\n"+
`rtmps_conns_bytes_received\{id=".*?",path=".*?",remoteAddr=".*?",state="publish"\} [0-9]+`+"\n"+
`rtmps_conns_bytes_sent\{id=".*?",path=".*?",remoteAddr=".*?",state="publish"\} [0-9]+`+"\n"+
`srt_conns\{id=".*?",path=".*?",remoteAddr=".*?",state="publish"\} 1`+"\n"+
`srt_conns_packets_sent\{id=".*?",path=".*?",remoteAddr=".*?",state="publish"\} [0-9]+`+"\n"+
`srt_conns_packets_received\{id=".*?",path=".*?",remoteAddr=".*?",state="publish"\} [0-9]+`+"\n"+
`srt_conns_packets_sent_unique\{id=".*?",path=".*?",remoteAddr=".*?",state="publish"\} [0-9]+`+"\n"+
`srt_conns_packets_received_unique\{id=".*?",path=".*?",remoteAddr=".*?",state="publish"\} 1`+"\n"+
`srt_conns_packets_send_loss\{id=".*?",path=".*?",remoteAddr=".*?",state="publish"\} [0-9]+`+"\n"+
`srt_conns_packets_received_loss\{id=".*?",path=".*?",remoteAddr=".*?",state="publish"\} [0-9]+`+"\n"+
`srt_conns_packets_retrans\{id=".*?",path=".*?",remoteAddr=".*?",state="publish"\} [0-9]+`+"\n"+
`srt_conns_packets_received_retrans\{id=".*?",path=".*?",remoteAddr=".*?",state="publish"\} [0-9]+`+"\n"+
`srt_conns_packets_sent_ack\{id=".*?",path=".*?",remoteAddr=".*?",state="publish"\} [0-9]+`+"\n"+
`srt_conns_packets_received_ack\{id=".*?",path=".*?",remoteAddr=".*?",state="publish"\} [0-9]+`+"\n"+
`srt_conns_packets_sent_nak\{id=".*?",path=".*?",remoteAddr=".*?",state="publish"\} [0-9]+`+"\n"+
`srt_conns_packets_received_nak\{id=".*?",path=".*?",remoteAddr=".*?",state="publish"\} [0-9]+`+"\n"+
`srt_conns_packets_sent_km\{id=".*?",path=".*?",remoteAddr=".*?",state="publish"\} [0-9]+`+"\n"+
`srt_conns_packets_received_km\{id=".*?",path=".*?",remoteAddr=".*?",state="publish"\} [0-9]+`+"\n"+
`srt_conns_us_snd_duration\{id=".*?",path=".*?",remoteAddr=".*?",state="publish"\} [0-9]+`+"\n"+
`srt_conns_packets_received_belated\{id=".*?",path=".*?",remoteAddr=".*?",state="publish"\} [0-9]+`+"\n"+
`srt_conns_packets_send_drop\{id=".*?",path=".*?",remoteAddr=".*?",state="publish"\} [0-9]+`+"\n"+
`srt_conns_packets_received_drop\{id=".*?",path=".*?",remoteAddr=".*?",state="publish"\} [0-9]+`+"\n"+
`srt_conns_packets_received_undecrypt\{id=".*?",path=".*?",remoteAddr=".*?",state="publish"\} [0-9]+`+"\n"+
`srt_conns_bytes_sent\{id=".*?",path=".*?",remoteAddr=".*?",state="publish"\} 0`+"\n"+
`srt_conns_bytes_received\{id=".*?",path=".*?",remoteAddr=".*?",state="publish"\} [0-9]+`+"\n"+
`srt_conns_bytes_sent_unique\{id=".*?",path=".*?",remoteAddr=".*?",state="publish"\} [0-9]+`+"\n"+
`srt_conns_bytes_received_unique\{id=".*?",path=".*?",remoteAddr=".*?",state="publish"\} [0-9]+`+"\n"+
`srt_conns_bytes_received_loss\{id=".*?",path=".*?",remoteAddr=".*?",state="publish"\} [0-9]+`+"\n"+
`srt_conns_bytes_retrans\{id=".*?",path=".*?",remoteAddr=".*?",state="publish"\} [0-9]+`+"\n"+
`srt_conns_bytes_received_retrans\{id=".*?",path=".*?",remoteAddr=".*?",state="publish"\} [0-9]+`+"\n"+
`srt_conns_bytes_received_belated\{id=".*?",path=".*?",remoteAddr=".*?",state="publish"\} [0-9]+`+"\n"+
`srt_conns_bytes_send_drop\{id=".*?",path=".*?",remoteAddr=".*?",state="publish"\} [0-9]+`+"\n"+
`srt_conns_bytes_received_drop\{id=".*?",path=".*?",remoteAddr=".*?",state="publish"\} [0-9]+`+"\n"+
`srt_conns_bytes_received_undecrypt\{id=".*?",path=".*?",remoteAddr=".*?",state="publish"\} [0-9]+`+"\n"+
`srt_conns_us_packets_send_period\{id=".*?",path=".*?",remoteAddr=".*?",state="publish"\} \d+\.\d+`+"\n"+
`srt_conns_packets_flow_window\{id=".*?",path=".*?",remoteAddr=".*?",state="publish"\} [0-9]+`+"\n"+
`srt_conns_packets_flight_size\{id=".*?",path=".*?",remoteAddr=".*?",state="publish"\} [0-9]+`+"\n"+
`srt_conns_ms_rtt\{id=".*?",path=".*?",remoteAddr=".*?",state="publish"\} \d+\.\d+`+"\n"+
`srt_conns_mbps_send_rate\{id=".*?",path=".*?",remoteAddr=".*?",state="publish"\} [0-9]+`+"\n"+
`srt_conns_mbps_receive_rate\{id=".*?",path=".*?",remoteAddr=".*?",state="publish"\} [0-9]+`+"\n"+
`srt_conns_mbps_link_capacity\{id=".*?",path=".*?",remoteAddr=".*?",state="publish"\} [0-9]+`+"\n"+
`srt_conns_bytes_avail_send_buf\{id=".*?",path=".*?",remoteAddr=".*?",state="publish"\} [0-9]+`+"\n"+
`srt_conns_bytes_avail_receive_buf\{id=".*?",path=".*?",remoteAddr=".*?",state="publish"\} [0-9]+`+"\n"+
`srt_conns_mbps_max_bw\{id=".*?",path=".*?",remoteAddr=".*?",state="publish"\} -1`+"\n"+
`srt_conns_bytes_mss\{id=".*?",path=".*?",remoteAddr=".*?",state="publish"\} [0-9]+`+"\n"+
`srt_conns_packets_send_buf\{id=".*?",path=".*?",remoteAddr=".*?",state="publish"\} [0-9]+`+"\n"+
`srt_conns_bytes_send_buf\{id=".*?",path=".*?",remoteAddr=".*?",state="publish"\} [0-9]+`+"\n"+
`srt_conns_ms_send_buf\{id=".*?",path=".*?",remoteAddr=".*?",state="publish"\} [0-9]+`+"\n"+
`srt_conns_ms_send_tsb_pd_delay\{id=".*?",path=".*?",remoteAddr=".*?",state="publish"\} [0-9]+`+"\n"+
`srt_conns_packets_receive_buf\{id=".*?",path=".*?",remoteAddr=".*?",state="publish"\} [0-9]+`+"\n"+
`srt_conns_bytes_receive_buf\{id=".*?",path=".*?",remoteAddr=".*?",state="publish"\} [0-9]+`+"\n"+
`srt_conns_ms_receive_buf\{id=".*?",path=".*?",remoteAddr=".*?",state="publish"\} [0-9]+`+"\n"+
`srt_conns_ms_receive_tsb_pd_delay\{id=".*?",path=".*?",remoteAddr=".*?",state="publish"\} [0-9]+`+"\n"+
`srt_conns_packets_reorder_tolerance\{id=".*?",path=".*?",remoteAddr=".*?",state="publish"\} [0-9]+`+"\n"+
`srt_conns_packets_received_avg_belated_time\{id=".*?",path=".*?",remoteAddr=".*?",state="publish"\} [0-9]+`+"\n"+
`srt_conns_packets_send_loss_rate\{id=".*?",path=".*?",remoteAddr=".*?",state="publish"\} [0-9]+`+"\n"+
`srt_conns_packets_received_loss_rate\{id=".*?",path=".*?",remoteAddr=".*?",state="publish"\} [0-9]+`+"\n"+
`srt_conns_outbound_frames_discarded\{id=".*?",path=".*?",remoteAddr=".*?",state="publish"\} [0-9]+`+"\n"+
`webrtc_sessions\{id=".*?",path=".*?",remoteAddr=".*?",state="publish"\} 1`+"\n"+
`webrtc_sessions_inbound_bytes\{id=".*?",path=".*?",remoteAddr=".*?",state="publish"\} [0-9]+`+"\n"+
`webrtc_sessions_inbound_rtp_packets\{id=".*?",path=".*?",remoteAddr=".*?",state="publish"\} [0-9]+`+"\n"+
`webrtc_sessions_inbound_rtp_packets_lost\{id=".*?",path=".*?",remoteAddr=".*?",state="publish"\} [0-9]+`+"\n"+
`webrtc_sessions_inbound_rtp_packets_jitter\{id=".*?",path=".*?",remoteAddr=".*?",state="publish"\} [0-9]+`+"\n"+
`webrtc_sessions_inbound_rtcp_packets\{id=".*?",path=".*?",remoteAddr=".*?",state="publish"\} [0-9]+`+"\n"+
`webrtc_sessions_outbound_bytes\{id=".*?",path=".*?",remoteAddr=".*?",state="publish"\} [0-9]+`+"\n"+
`webrtc_sessions_outbound_rtp_packets\{id=".*?",path=".*?",remoteAddr=".*?",state="publish"\} [0-9]+`+"\n"+
`webrtc_sessions_outbound_rtcp_packets\{id=".*?",path=".*?",remoteAddr=".*?",state="publish"\} [0-9]+`+"\n"+
`webrtc_sessions_outbound_frames_discarded\{id=".*?",path=".*?",remoteAddr=".*?",state="publish"\} [0-9]+`+"\n"+
`webrtc_sessions_bytes_received\{id=".*?",path=".*?",remoteAddr=".*?",state="publish"\} [0-9]+`+"\n"+
`webrtc_sessions_bytes_sent\{id=".*?",path=".*?",remoteAddr=".*?",state="publish"\} [0-9]+`+"\n"+
`webrtc_sessions_rtp_packets_received\{id=".*?",path=".*?",remoteAddr=".*?",state="publish"\} [0-9]+`+"\n"+
`webrtc_sessions_rtp_packets_sent\{id=".*?",path=".*?",remoteAddr=".*?",state="publish"\} [0-9]+`+"\n"+
`webrtc_sessions_rtp_packets_lost\{id=".*?",path=".*?",remoteAddr=".*?",state="publish"\} [0-9]+`+"\n"+
`webrtc_sessions_rtp_packets_jitter\{id=".*?",path=".*?",remoteAddr=".*?",state="publish"\} [0-9]+`+"\n"+
`webrtc_sessions_rtcp_packets_received\{id=".*?",path=".*?",remoteAddr=".*?",state="publish"\} [0-9]+`+"\n"+
`webrtc_sessions_rtcp_packets_sent\{id=".*?",path=".*?",remoteAddr=".*?",state="publish"\} [0-9]+`+"\n"+
"$",
string(bo))
close(terminate)
wg.Wait()
})
t.Run("servers disabled", func(t *testing.T) {
httpRequest(t, hc, http.MethodPatch, "http://localhost:9997/v3/config/global/patch", map[string]any{
"rtsp": false,
"rtmp": false,
"srt": false,
"hls": false,
"webrtc": false,
}, nil)
time.Sleep(500 * time.Millisecond)
bo := httpPullFile(t, hc, "http://localhost:9998/metrics")
require.Equal(t, "paths 0\n"+
"paths_inbound_bytes 0\n"+
"paths_outbound_bytes 0\n"+
"paths_inbound_frames_in_error 0\n"+
"paths_bytes_received 0\n"+
"paths_bytes_sent 0\n"+
"paths_readers 0\n",
string(bo))
})
}
================================================
FILE: internal/core/path.go
================================================
package core
import (
"context"
"fmt"
"net"
"strconv"
"sync"
"sync/atomic"
"time"
"github.com/bluenviron/gortsplib/v5/pkg/description"
"github.com/bluenviron/mediamtx/internal/conf"
"github.com/bluenviron/mediamtx/internal/defs"
"github.com/bluenviron/mediamtx/internal/externalcmd"
"github.com/bluenviron/mediamtx/internal/hooks"
"github.com/bluenviron/mediamtx/internal/logger"
"github.com/bluenviron/mediamtx/internal/recorder"
"github.com/bluenviron/mediamtx/internal/staticsources"
"github.com/bluenviron/mediamtx/internal/stream"
)
func emptyTimer() *time.Timer {
t := time.NewTimer(0)
<-t.C
return t
}
type pathParent interface {
logger.Writer
setPathReady(*path)
setPathNotReady(*path)
closePathIfIdle(*path)
removePath(*path)
AddReader(req defs.PathAddReaderReq) (*defs.PathAddReaderRes, error)
}
type pathOnDemandState int
const (
pathOnDemandStateInitial pathOnDemandState = iota
pathOnDemandStateWaitingReady
pathOnDemandStateReady
pathOnDemandStateClosing
)
type pathAPIPathsListRes struct {
data *defs.APIPathList
paths map[string]*path
}
type pathAPIPathsListReq struct {
res chan pathAPIPathsListRes
}
type pathAPIPathsGetRes struct {
path *path
data *defs.APIPath
err error
}
type pathAPIPathsGetReq struct {
name string
res chan pathAPIPathsGetRes
}
type path struct {
parentCtx context.Context
logLevel conf.LogLevel
dumpPackets bool
rtspAddress string
readTimeout conf.Duration
writeTimeout conf.Duration
writeQueueSize int
udpReadBufferSize uint
rtpMaxPayloadSize int
conf *conf.Path
name string
matches []string
wg *sync.WaitGroup
externalCmdPool *externalcmd.Pool
parent pathParent
// accessed by pathManager only
ready bool
confName string
ctx context.Context
ctxCancel func()
pendingRequests *int64
confMutex sync.RWMutex
source defs.Source
stream *stream.Stream
recorder *recorder.Recorder
availableTime time.Time
onlineTime time.Time
onUnDemandHook func(string)
onNotReadyHook func()
readers map[defs.Reader]struct{}
describeRequestsOnHold []defs.PathDescribeReq
readerAddRequestsOnHold []defs.PathAddReaderReq
onDemandStaticSourceState pathOnDemandState
onDemandStaticSourceReadyTimer *time.Timer
onDemandStaticSourceCloseTimer *time.Timer
onDemandPublisherState pathOnDemandState
onDemandPublisherReadyTimer *time.Timer
onDemandPublisherCloseTimer *time.Timer
// in
chReloadConf chan *conf.Path
chStaticSourceSetReady chan defs.PathSourceStaticSetReadyReq
chStaticSourceSetNotReady chan defs.PathSourceStaticSetNotReadyReq
chDescribe chan defs.PathDescribeReq
chAddPublisher chan defs.PathAddPublisherReq
chRemovePublisher chan defs.PathRemovePublisherReq
chAddReader chan defs.PathAddReaderReq
chRemoveReader chan defs.PathRemoveReaderReq
chAPIPathsGet chan pathAPIPathsGetReq
// out
done chan struct{}
}
func (pa *path) initialize() {
ctx, ctxCancel := context.WithCancel(pa.parentCtx)
pa.confName = pa.conf.Name
pa.ctx = ctx
pa.ctxCancel = ctxCancel
pa.pendingRequests = new(int64)
pa.readers = make(map[defs.Reader]struct{})
pa.onDemandStaticSourceReadyTimer = emptyTimer()
pa.onDemandStaticSourceCloseTimer = emptyTimer()
pa.onDemandPublisherReadyTimer = emptyTimer()
pa.onDemandPublisherCloseTimer = emptyTimer()
pa.chReloadConf = make(chan *conf.Path)
pa.chStaticSourceSetReady = make(chan defs.PathSourceStaticSetReadyReq)
pa.chStaticSourceSetNotReady = make(chan defs.PathSourceStaticSetNotReadyReq)
pa.chDescribe = make(chan defs.PathDescribeReq)
pa.chAddPublisher = make(chan defs.PathAddPublisherReq)
pa.chRemovePublisher = make(chan defs.PathRemovePublisherReq)
pa.chAddReader = make(chan defs.PathAddReaderReq)
pa.chRemoveReader = make(chan defs.PathRemoveReaderReq)
pa.chAPIPathsGet = make(chan pathAPIPathsGetReq)
pa.done = make(chan struct{})
pa.Log(logger.Debug, "created")
pa.wg.Add(1)
go pa.run()
}
func (pa *path) close() {
pa.ctxCancel()
}
func (pa *path) wait() {
<-pa.done
}
// Log implements logger.Writer.
func (pa *path) Log(level logger.Level, format string, args ...any) {
pa.parent.Log(level, "[path "+pa.name+"] "+format, args...)
}
func (pa *path) Name() string {
return pa.name
}
func (pa *path) isAvailable() bool {
return pa.stream != nil
}
func (pa *path) isOnline() bool {
return pa.source != nil
}
func (pa *path) run() {
defer close(pa.done)
defer pa.wg.Done()
if pa.conf.AlwaysAvailable {
err := pa.setAvailable(nil, "", nil, true)
if err != nil {
panic(err)
}
}
if pa.conf.Source == "redirect" {
pa.source = &sourceRedirect{}
} else if pa.conf.HasStaticSource() {
pa.source = &staticsources.Handler{
Conf: pa.conf,
LogLevel: pa.logLevel,
DumpPackets: pa.dumpPackets,
ReadTimeout: pa.readTimeout,
WriteTimeout: pa.writeTimeout,
WriteQueueSize: pa.writeQueueSize,
UDPReadBufferSize: pa.udpReadBufferSize,
RTPMaxPayloadSize: pa.rtpMaxPayloadSize,
Matches: pa.matches,
PathManager: pa.parent,
Parent: pa,
}
pa.source.(*staticsources.Handler).Initialize()
if !pa.conf.SourceOnDemand {
pa.source.(*staticsources.Handler).Start(false, "")
}
}
onUnInitHook := hooks.OnInit(hooks.OnInitParams{
Logger: pa,
ExternalCmdPool: pa.externalCmdPool,
Conf: pa.conf,
ExternalCmdEnv: pa.ExternalCmdEnv(),
})
err := pa.runInner()
// call before destroying context
pa.parent.removePath(pa)
pa.ctxCancel()
pa.onDemandStaticSourceReadyTimer.Stop()
pa.onDemandStaticSourceCloseTimer.Stop()
pa.onDemandPublisherReadyTimer.Stop()
pa.onDemandPublisherCloseTimer.Stop()
onUnInitHook()
for _, req := range pa.describeRequestsOnHold {
req.Res <- defs.PathDescribeRes{Err: fmt.Errorf("terminated")}
}
for _, req := range pa.readerAddRequestsOnHold {
req.Res <- defs.PathAddReaderRes{Err: fmt.Errorf("terminated")}
}
if pa.stream != nil {
pa.setNotAvailable()
}
if pa.source != nil {
if source, ok := pa.source.(*staticsources.Handler); ok {
if !pa.conf.SourceOnDemand || pa.onDemandStaticSourceState != pathOnDemandStateInitial {
source.Close("path is closing")
}
} else if source, ok2 := pa.source.(defs.Publisher); ok2 {
source.Close()
}
}
if pa.onUnDemandHook != nil {
pa.onUnDemandHook("path destroyed")
}
pa.Log(logger.Debug, "destroyed: %v", err)
}
func (pa *path) runInner() error {
for {
select {
case <-pa.onDemandStaticSourceReadyTimer.C:
pa.doOnDemandStaticSourceReadyTimer()
if pa.shouldClose() {
pa.parent.closePathIfIdle(pa)
}
case <-pa.onDemandStaticSourceCloseTimer.C:
pa.doOnDemandStaticSourceCloseTimer()
if pa.shouldClose() {
pa.parent.closePathIfIdle(pa)
}
case <-pa.onDemandPublisherReadyTimer.C:
pa.doOnDemandPublisherReadyTimer()
if pa.shouldClose() {
pa.parent.closePathIfIdle(pa)
}
case <-pa.onDemandPublisherCloseTimer.C:
pa.doOnDemandPublisherCloseTimer()
case newConf := <-pa.chReloadConf:
pa.doReloadConf(newConf)
case req := <-pa.chStaticSourceSetReady:
pa.doSourceStaticSetReady(req)
case req := <-pa.chStaticSourceSetNotReady:
pa.doSourceStaticSetNotReady(req)
if pa.shouldClose() {
pa.parent.closePathIfIdle(pa)
}
case req := <-pa.chDescribe:
pa.doDescribe(req)
atomic.AddInt64(pa.pendingRequests, -1)
if pa.shouldClose() {
pa.parent.closePathIfIdle(pa)
}
case req := <-pa.chAddPublisher:
pa.doAddPublisher(req)
atomic.AddInt64(pa.pendingRequests, -1)
if pa.shouldClose() {
pa.parent.closePathIfIdle(pa)
}
case req := <-pa.chRemovePublisher:
pa.doRemovePublisher(req)
if pa.shouldClose() {
pa.parent.closePathIfIdle(pa)
}
case req := <-pa.chAddReader:
pa.doAddReader(req)
atomic.AddInt64(pa.pendingRequests, -1)
if pa.shouldClose() {
pa.parent.closePathIfIdle(pa)
}
case req := <-pa.chRemoveReader:
pa.doRemoveReader(req)
case req := <-pa.chAPIPathsGet:
pa.doAPIPathsGet(req)
case <-pa.ctx.Done():
return fmt.Errorf("terminated")
}
}
}
func (pa *path) doOnDemandStaticSourceReadyTimer() {
for _, req := range pa.describeRequestsOnHold {
req.Res <- defs.PathDescribeRes{Err: fmt.Errorf("source of path '%s' has timed out", pa.name)}
}
pa.describeRequestsOnHold = nil
for _, req := range pa.readerAddRequestsOnHold {
req.Res <- defs.PathAddReaderRes{Err: fmt.Errorf("source of path '%s' has timed out", pa.name)}
}
pa.readerAddRequestsOnHold = nil
pa.onDemandStaticSourceStop("timed out")
}
func (pa *path) doOnDemandStaticSourceCloseTimer() {
if pa.conf.AlwaysAvailable {
panic("should not happen")
}
pa.setNotAvailable()
pa.onDemandStaticSourceStop("not needed by anyone")
}
func (pa *path) doOnDemandPublisherReadyTimer() {
for _, req := range pa.describeRequestsOnHold {
req.Res <- defs.PathDescribeRes{Err: fmt.Errorf("source of path '%s' has timed out", pa.name)}
}
pa.describeRequestsOnHold = nil
for _, req := range pa.readerAddRequestsOnHold {
req.Res <- defs.PathAddReaderRes{Err: fmt.Errorf("source of path '%s' has timed out", pa.name)}
}
pa.readerAddRequestsOnHold = nil
pa.onDemandPublisherStop("timed out")
}
func (pa *path) doOnDemandPublisherCloseTimer() {
pa.onDemandPublisherStop("not needed by anyone")
}
func (pa *path) doReloadConf(newConf *conf.Path) {
pa.confMutex.Lock()
oldConf := pa.conf
pa.conf = newConf
pa.confMutex.Unlock()
if pa.conf.HasStaticSource() {
pa.source.(*staticsources.Handler).ReloadConf(newConf)
}
if pa.recorder != nil &&
(newConf.Record != oldConf.Record ||
newConf.RecordPath != oldConf.RecordPath ||
newConf.RecordFormat != oldConf.RecordFormat ||
newConf.RecordPartDuration != oldConf.RecordPartDuration ||
newConf.RecordMaxPartSize != oldConf.RecordMaxPartSize ||
newConf.RecordSegmentDuration != oldConf.RecordSegmentDuration ||
newConf.RecordDeleteAfter != oldConf.RecordDeleteAfter) {
pa.recorder.Close()
pa.recorder = nil
}
if newConf.Record && pa.stream != nil && pa.recorder == nil {
pa.startRecording()
}
}
func (pa *path) doSourceStaticSetReady(req defs.PathSourceStaticSetReadyReq) {
if !pa.conf.AlwaysAvailable {
err := pa.setAvailable(pa.source, "", req.Desc, req.ReplaceNTP)
if err != nil {
req.Res <- defs.PathSourceStaticSetReadyRes{Err: err}
return
}
}
subStream := &stream.SubStream{
Stream: pa.stream,
UseRTPPackets: req.UseRTPPackets,
}
if pa.conf.AlwaysAvailable {
subStream.CurDesc = req.Desc
}
err := subStream.Initialize()
if err != nil {
req.Res <- defs.PathSourceStaticSetReadyRes{Err: err}
return
}
if pa.conf.AlwaysAvailable {
pa.onlineTime = time.Now()
}
if pa.conf.HasOnDemandStaticSource() {
pa.onDemandStaticSourceReadyTimer.Stop()
pa.onDemandStaticSourceReadyTimer = emptyTimer()
pa.onDemandStaticSourceScheduleClose()
}
pa.consumeOnHoldRequests()
req.Res <- defs.PathSourceStaticSetReadyRes{SubStream: subStream}
}
func (pa *path) doSourceStaticSetNotReady(req defs.PathSourceStaticSetNotReadyReq) {
if !pa.conf.AlwaysAvailable {
pa.setNotAvailable()
} else {
err := pa.stream.StartOfflineSubStream()
if err != nil {
panic("should not happen")
}
}
// send response before calling onDemandStaticSourceStop()
// in order to avoid a deadlock due to staticsources.Handler.stop()
close(req.Res)
if pa.conf.HasOnDemandStaticSource() && pa.onDemandStaticSourceState != pathOnDemandStateInitial {
pa.onDemandStaticSourceStop("an error occurred")
}
}
func (pa *path) doDescribe(req defs.PathDescribeReq) {
if _, ok := pa.source.(*sourceRedirect); ok {
req.Res <- defs.PathDescribeRes{
Redirect: pa.conf.SourceRedirect,
}
return
}
if pa.stream != nil {
req.Res <- defs.PathDescribeRes{
Stream: pa.stream,
}
return
}
if pa.conf.HasOnDemandStaticSource() {
if pa.onDemandStaticSourceState == pathOnDemandStateInitial {
pa.onDemandStaticSourceStart(req.AccessRequest.Query)
}
pa.describeRequestsOnHold = append(pa.describeRequestsOnHold, req)
return
}
if pa.conf.HasOnDemandPublisher() {
if pa.onDemandPublisherState == pathOnDemandStateInitial {
pa.onDemandPublisherStart(req.AccessRequest.Query)
}
pa.describeRequestsOnHold = append(pa.describeRequestsOnHold, req)
return
}
if pa.conf.Fallback != nil {
req.Res <- defs.PathDescribeRes{Redirect: *pa.conf.Fallback}
return
}
req.Res <- defs.PathDescribeRes{Err: defs.PathNoStreamAvailableError{PathName: pa.name}}
}
func (pa *path) doRemovePublisher(req defs.PathRemovePublisherReq) {
if pa.source == req.Author {
pa.executeRemovePublisher()
}
close(req.Res)
}
func (pa *path) doAddPublisher(req defs.PathAddPublisherReq) {
if pa.conf.Source != "publisher" {
req.Res <- defs.PathAddPublisherRes{
Err: fmt.Errorf("can't publish to path '%s' since 'source' is not 'publisher'", pa.name),
}
return
}
if pa.source != nil {
if !pa.conf.OverridePublisher {
req.Res <- defs.PathAddPublisherRes{Err: fmt.Errorf("someone is already publishing to path '%s'", pa.name)}
return
}
pa.Log(logger.Info, "closing existing publisher")
pa.source.(defs.Publisher).Close()
pa.executeRemovePublisher()
}
if !pa.conf.AlwaysAvailable {
err := pa.setAvailable(req.Author, req.AccessRequest.Query, req.Desc, req.ReplaceNTP)
if err != nil {
req.Res <- defs.PathAddPublisherRes{Err: err}
return
}
}
subStream := &stream.SubStream{
Stream: pa.stream,
UseRTPPackets: req.UseRTPPackets,
}
if pa.conf.AlwaysAvailable {
subStream.CurDesc = req.Desc
}
err := subStream.Initialize()
if err != nil {
req.Res <- defs.PathAddPublisherRes{Err: err}
return
}
pa.source = req.Author
req.Author.Log(logger.Info, "is publishing to path '%s'",
pa.name)
if pa.conf.AlwaysAvailable {
pa.onlineTime = time.Now()
}
if pa.conf.HasOnDemandPublisher() && pa.onDemandPublisherState != pathOnDemandStateInitial {
pa.onDemandPublisherReadyTimer.Stop()
pa.onDemandPublisherReadyTimer = emptyTimer()
pa.onDemandPublisherScheduleClose()
}
pa.consumeOnHoldRequests()
req.Res <- defs.PathAddPublisherRes{SubStream: subStream}
}
func (pa *path) doAddReader(req defs.PathAddReaderReq) {
if pa.stream != nil {
pa.addReaderPost(req)
return
}
if pa.conf.HasOnDemandStaticSource() {
if pa.onDemandStaticSourceState == pathOnDemandStateInitial {
pa.onDemandStaticSourceStart(req.AccessRequest.Query)
}
pa.readerAddRequestsOnHold = append(pa.readerAddRequestsOnHold, req)
return
}
if pa.conf.HasOnDemandPublisher() {
if pa.onDemandPublisherState == pathOnDemandStateInitial {
pa.onDemandPublisherStart(req.AccessRequest.Query)
}
pa.readerAddRequestsOnHold = append(pa.readerAddRequestsOnHold, req)
return
}
req.Res <- defs.PathAddReaderRes{Err: defs.PathNoStreamAvailableError{PathName: pa.name}}
}
func (pa *path) doRemoveReader(req defs.PathRemoveReaderReq) {
if _, ok := pa.readers[req.Author]; ok {
pa.executeRemoveReader(req.Author)
}
close(req.Res)
if len(pa.readers) == 0 {
if pa.conf.HasOnDemandStaticSource() {
if pa.onDemandStaticSourceState == pathOnDemandStateReady {
pa.onDemandStaticSourceScheduleClose()
}
} else if pa.conf.HasOnDemandPublisher() {
if pa.onDemandPublisherState == pathOnDemandStateReady {
pa.onDemandPublisherScheduleClose()
}
}
}
}
func (pa *path) doAPIPathsGet(req pathAPIPathsGetReq) {
req.res <- pathAPIPathsGetRes{
data: &defs.APIPath{
Name: pa.name,
ConfName: pa.conf.Name,
Ready: pa.isAvailable(),
ReadyTime: func() *time.Time {
if !pa.isAvailable() {
return nil
}
v := pa.availableTime
return &v
}(),
Available: pa.isAvailable(),
AvailableTime: func() *time.Time {
if !pa.isAvailable() {
return nil
}
v := pa.availableTime
return &v
}(),
Online: pa.isOnline(),
OnlineTime: func() *time.Time {
if !pa.isOnline() {
return nil
}
v := pa.onlineTime
return &v
}(),
Source: func() *defs.APIPathSource {
if pa.source == nil {
return nil
}
v := pa.source.APISourceDescribe()
return v
}(),
Tracks: func() []defs.APIPathTrackCodec {
if !pa.isAvailable() {
return []defs.APIPathTrackCodec{}
}
return defs.MediasToCodecs(pa.stream.Desc.Medias)
}(),
Tracks2: func() []defs.APIPathTrack {
if !pa.isAvailable() {
return []defs.APIPathTrack{}
}
return defs.MediasToTracks(pa.stream.Desc.Medias)
}(),
InboundBytes: func() uint64 {
if !pa.isAvailable() {
return 0
}
return pa.stream.InboundBytes()
}(),
OutboundBytes: func() uint64 {
if !pa.isAvailable() {
return 0
}
return pa.stream.OutboundBytes()
}(),
InboundFramesInError: func() uint64 {
if !pa.isAvailable() {
return 0
}
return pa.stream.InboundFramesInError()
}(),
BytesReceived: func() uint64 {
if !pa.isAvailable() {
return 0
}
return pa.stream.InboundBytes()
}(),
BytesSent: func() uint64 {
if !pa.isAvailable() {
return 0
}
return pa.stream.OutboundBytes()
}(),
Readers: func() []defs.APIPathReader {
ret := make([]defs.APIPathReader, len(pa.readers))
i := 0
for r := range pa.readers {
ret[i] = *r.APIReaderDescribe()
i++
}
return ret
}(),
},
}
}
func (pa *path) SafeConf() *conf.Path {
pa.confMutex.RLock()
defer pa.confMutex.RUnlock()
return pa.conf
}
func (pa *path) ExternalCmdEnv() externalcmd.Environment {
_, port, _ := net.SplitHostPort(pa.rtspAddress)
env := externalcmd.Environment{
"MTX_PATH": pa.name,
"RTSP_PATH": pa.name, // deprecated
"RTSP_PORT": port,
}
if len(pa.matches) > 1 {
for i, ma := range pa.matches[1:] {
env["G"+strconv.FormatInt(int64(i+1), 10)] = ma
}
}
return env
}
func (pa *path) shouldClose() bool {
return pa.conf.Regexp != nil &&
pa.source == nil &&
len(pa.readers) == 0 &&
len(pa.describeRequestsOnHold) == 0 &&
len(pa.readerAddRequestsOnHold) == 0
}
func (pa *path) onDemandStaticSourceStart(query string) {
pa.source.(*staticsources.Handler).Start(true, query)
pa.onDemandStaticSourceReadyTimer.Stop()
pa.onDemandStaticSourceReadyTimer = time.NewTimer(time.Duration(pa.conf.SourceOnDemandStartTimeout))
pa.onDemandStaticSourceState = pathOnDemandStateWaitingReady
}
func (pa *path) onDemandStaticSourceScheduleClose() {
pa.onDemandStaticSourceCloseTimer.Stop()
pa.onDemandStaticSourceCloseTimer = time.NewTimer(time.Duration(pa.conf.SourceOnDemandCloseAfter))
pa.onDemandStaticSourceState = pathOnDemandStateClosing
}
func (pa *path) onDemandStaticSourceStop(reason string) {
if pa.onDemandStaticSourceState == pathOnDemandStateClosing {
pa.onDemandStaticSourceCloseTimer.Stop()
pa.onDemandStaticSourceCloseTimer = emptyTimer()
}
pa.onDemandStaticSourceState = pathOnDemandStateInitial
pa.source.(*staticsources.Handler).Stop(reason)
}
func (pa *path) onDemandPublisherStart(query string) {
pa.onUnDemandHook = hooks.OnDemand(hooks.OnDemandParams{
Logger: pa,
ExternalCmdPool: pa.externalCmdPool,
Conf: pa.conf,
ExternalCmdEnv: pa.ExternalCmdEnv(),
Query: query,
})
pa.onDemandPublisherReadyTimer.Stop()
pa.onDemandPublisherReadyTimer = time.NewTimer(time.Duration(pa.conf.RunOnDemandStartTimeout))
pa.onDemandPublisherState = pathOnDemandStateWaitingReady
}
func (pa *path) onDemandPublisherScheduleClose() {
pa.onDemandPublisherCloseTimer.Stop()
pa.onDemandPublisherCloseTimer = time.NewTimer(time.Duration(pa.conf.RunOnDemandCloseAfter))
pa.onDemandPublisherState = pathOnDemandStateClosing
}
func (pa *path) onDemandPublisherStop(reason string) {
if pa.onDemandPublisherState == pathOnDemandStateClosing {
pa.onDemandPublisherCloseTimer.Stop()
pa.onDemandPublisherCloseTimer = emptyTimer()
}
pa.onUnDemandHook(reason)
pa.onUnDemandHook = nil
pa.onDemandPublisherState = pathOnDemandStateInitial
}
func (pa *path) setAvailable(
source defs.Source,
publisherQuery string,
desc *description.Session,
replaceNTP bool,
) error {
pa.stream = &stream.Stream{
Desc: desc,
AlwaysAvailable: pa.conf.AlwaysAvailable,
AlwaysAvailableTracks: pa.conf.AlwaysAvailableTracks,
AlwaysAvailableFile: pa.conf.AlwaysAvailableFile,
WriteQueueSize: pa.writeQueueSize,
RTPMaxPayloadSize: pa.rtpMaxPayloadSize,
ReplaceNTP: replaceNTP,
Parent: pa,
}
err := pa.stream.Initialize()
if err != nil {
return err
}
pa.availableTime = time.Now()
if !pa.conf.AlwaysAvailable {
pa.onlineTime = time.Now()
}
if pa.conf.Record {
pa.startRecording()
}
var sourceDesc *defs.APIPathSource
if source != nil {
sourceDesc = source.APISourceDescribe()
}
pa.onNotReadyHook = hooks.OnReady(hooks.OnReadyParams{
Logger: pa,
ExternalCmdPool: pa.externalCmdPool,
Conf: pa.conf,
ExternalCmdEnv: pa.ExternalCmdEnv(),
Desc: sourceDesc,
Query: publisherQuery,
})
if pa.conf.AlwaysAvailable {
pa.Log(logger.Info, "stream is available, %s", defs.MediasInfo(pa.stream.Desc.Medias))
} else {
pa.Log(logger.Info, "stream is available and online, %s", defs.MediasInfo(pa.stream.Desc.Medias))
}
pa.parent.setPathReady(pa)
return nil
}
func (pa *path) consumeOnHoldRequests() {
for _, req := range pa.describeRequestsOnHold {
req.Res <- defs.PathDescribeRes{
Stream: pa.stream,
}
}
pa.describeRequestsOnHold = nil
for _, req := range pa.readerAddRequestsOnHold {
pa.addReaderPost(req)
}
pa.readerAddRequestsOnHold = nil
}
func (pa *path) setNotAvailable() {
pa.parent.setPathNotReady(pa)
for r := range pa.readers {
pa.executeRemoveReader(r)
r.Close()
}
pa.onNotReadyHook()
if pa.recorder != nil {
pa.recorder.Close()
pa.recorder = nil
}
if pa.stream != nil {
pa.stream.Close()
pa.stream = nil
}
}
func (pa *path) startRecording() {
pa.recorder = &recorder.Recorder{
PathFormat: pa.conf.RecordPath,
Format: pa.conf.RecordFormat,
PartDuration: time.Duration(pa.conf.RecordPartDuration),
MaxPartSize: pa.conf.RecordMaxPartSize,
SegmentDuration: time.Duration(pa.conf.RecordSegmentDuration),
PathName: pa.name,
Stream: pa.stream,
OnSegmentCreate: func(segmentPath string) {
if pa.conf.RunOnRecordSegmentCreate != "" {
env := pa.ExternalCmdEnv()
env["MTX_SEGMENT_PATH"] = segmentPath
pa.Log(logger.Info, "runOnRecordSegmentCreate command launched")
externalcmd.NewCmd(
pa.externalCmdPool,
pa.conf.RunOnRecordSegmentCreate,
false,
env,
nil)
}
},
OnSegmentComplete: func(segmentPath string, segmentDuration time.Duration) {
if pa.conf.RunOnRecordSegmentComplete != "" {
env := pa.ExternalCmdEnv()
env["MTX_SEGMENT_PATH"] = segmentPath
env["MTX_SEGMENT_DURATION"] = strconv.FormatFloat(segmentDuration.Seconds(), 'f', -1, 64)
pa.Log(logger.Info, "runOnRecordSegmentComplete command launched")
externalcmd.NewCmd(
pa.externalCmdPool,
pa.conf.RunOnRecordSegmentComplete,
false,
env,
nil)
}
},
Parent: pa,
}
pa.recorder.Initialize()
}
func (pa *path) executeRemoveReader(r defs.Reader) {
delete(pa.readers, r)
}
func (pa *path) executeRemovePublisher() {
if !pa.conf.AlwaysAvailable {
pa.setNotAvailable()
} else {
err := pa.stream.StartOfflineSubStream()
if err != nil {
panic("should not happen")
}
}
pa.source = nil
}
func (pa *path) addReaderPost(req defs.PathAddReaderReq) {
if _, ok := pa.readers[req.Author]; ok {
req.Res <- defs.PathAddReaderRes{Stream: pa.stream}
return
}
if pa.conf.MaxReaders != 0 && len(pa.readers) >= pa.conf.MaxReaders {
req.Res <- defs.PathAddReaderRes{Err: fmt.Errorf("maximum reader count reached")}
return
}
pa.readers[req.Author] = struct{}{}
if pa.conf.HasOnDemandStaticSource() {
if pa.onDemandStaticSourceState == pathOnDemandStateClosing {
pa.onDemandStaticSourceState = pathOnDemandStateReady
pa.onDemandStaticSourceCloseTimer.Stop()
pa.onDemandStaticSourceCloseTimer = emptyTimer()
}
} else if pa.conf.HasOnDemandPublisher() {
if pa.onDemandPublisherState == pathOnDemandStateClosing {
pa.onDemandPublisherState = pathOnDemandStateReady
pa.onDemandPublisherCloseTimer.Stop()
pa.onDemandPublisherCloseTimer = emptyTimer()
}
}
req.Res <- defs.PathAddReaderRes{Stream: pa.stream}
}
// reloadConf is called by pathManager.
func (pa *path) reloadConf(newConf *conf.Path) {
select {
case pa.chReloadConf <- newConf:
case <-pa.ctx.Done():
}
}
// StaticSourceHandlerSetReady is called by staticsources.Handler.
func (pa *path) StaticSourceHandlerSetReady(
ctx context.Context, req defs.PathSourceStaticSetReadyReq,
) {
select {
case pa.chStaticSourceSetReady <- req:
case <-pa.ctx.Done():
req.Res <- defs.PathSourceStaticSetReadyRes{Err: fmt.Errorf("terminated")}
// this avoids:
// - invalid requests sent after the source has been terminated
// - deadlocks caused by <-done inside stop()
case <-ctx.Done():
req.Res <- defs.PathSourceStaticSetReadyRes{Err: fmt.Errorf("terminated")}
}
}
// StaticSourceHandlerSetNotReady is called by staticsources.Handler.
func (pa *path) StaticSourceHandlerSetNotReady(
ctx context.Context, req defs.PathSourceStaticSetNotReadyReq,
) {
select {
case pa.chStaticSourceSetNotReady <- req:
case <-pa.ctx.Done():
close(req.Res)
// this avoids:
// - invalid requests sent after the source has been terminated
// - deadlocks caused by <-done inside stop()
case <-ctx.Done():
close(req.Res)
}
}
// describe is called by a reader or publisher through pathManager.
func (pa *path) describe(req defs.PathDescribeReq) defs.PathDescribeRes {
select {
case pa.chDescribe <- req:
return <-req.Res
case <-pa.ctx.Done():
return defs.PathDescribeRes{Err: fmt.Errorf("terminated")}
}
}
// addPublisher is called by a publisher through pathManager.
func (pa *path) addPublisher(req defs.PathAddPublisherReq) (*defs.PathAddPublisherRes, error) {
select {
case pa.chAddPublisher <- req:
res := <-req.Res
return &res, res.Err
case <-pa.ctx.Done():
return nil, fmt.Errorf("terminated")
}
}
// RemovePublisher is called by a publisher.
func (pa *path) RemovePublisher(req defs.PathRemovePublisherReq) {
req.Res = make(chan struct{})
select {
case pa.chRemovePublisher <- req:
<-req.Res
case <-pa.ctx.Done():
}
}
// addReader is called by a reader through pathManager.
func (pa *path) addReader(req defs.PathAddReaderReq) (*defs.PathAddReaderRes, error) {
select {
case pa.chAddReader <- req:
res := <-req.Res
return &res, res.Err
case <-pa.ctx.Done():
return nil, fmt.Errorf("terminated")
}
}
// RemoveReader is called by a reader.
func (pa *path) RemoveReader(req defs.PathRemoveReaderReq) {
req.Res = make(chan struct{})
select {
case pa.chRemoveReader <- req:
<-req.Res
case <-pa.ctx.Done():
}
}
// APIPathsGet is called by api.
func (pa *path) APIPathsGet(req pathAPIPathsGetReq) (*defs.APIPath, error) {
req.res = make(chan pathAPIPathsGetRes)
select {
case pa.chAPIPathsGet <- req:
res := <-req.res
return res.data, res.err
case <-pa.ctx.Done():
return nil, fmt.Errorf("terminated")
}
}
================================================
FILE: internal/core/path_manager.go
================================================
package core
import (
"context"
"fmt"
"maps"
"sort"
"sync"
"sync/atomic"
"github.com/bluenviron/mediamtx/internal/auth"
"github.com/bluenviron/mediamtx/internal/conf"
"github.com/bluenviron/mediamtx/internal/defs"
"github.com/bluenviron/mediamtx/internal/externalcmd"
"github.com/bluenviron/mediamtx/internal/logger"
"github.com/bluenviron/mediamtx/internal/metrics"
"github.com/bluenviron/mediamtx/internal/servers/hls"
)
func pathConfCanBeUpdated(oldPathConf *conf.Path, newPathConf *conf.Path) bool {
clone := oldPathConf.Clone()
clone.Name = newPathConf.Name
clone.Regexp = newPathConf.Regexp
clone.Record = newPathConf.Record
clone.RecordPath = newPathConf.RecordPath
clone.RecordFormat = newPathConf.RecordFormat
clone.RecordPartDuration = newPathConf.RecordPartDuration
clone.RecordMaxPartSize = newPathConf.RecordMaxPartSize
clone.RecordSegmentDuration = newPathConf.RecordSegmentDuration
clone.RecordDeleteAfter = newPathConf.RecordDeleteAfter
clone.RPICameraBrightness = newPathConf.RPICameraBrightness
clone.RPICameraContrast = newPathConf.RPICameraContrast
clone.RPICameraSaturation = newPathConf.RPICameraSaturation
clone.RPICameraSharpness = newPathConf.RPICameraSharpness
clone.RPICameraExposure = newPathConf.RPICameraExposure
clone.RPICameraFlickerPeriod = newPathConf.RPICameraFlickerPeriod
clone.RPICameraAWB = newPathConf.RPICameraAWB
clone.RPICameraAWBGains = newPathConf.RPICameraAWBGains
clone.RPICameraDenoise = newPathConf.RPICameraDenoise
clone.RPICameraShutter = newPathConf.RPICameraShutter
clone.RPICameraMetering = newPathConf.RPICameraMetering
clone.RPICameraGain = newPathConf.RPICameraGain
clone.RPICameraEV = newPathConf.RPICameraEV
clone.RPICameraFPS = newPathConf.RPICameraFPS
clone.RPICameraIDRPeriod = newPathConf.RPICameraIDRPeriod
clone.RPICameraBitrate = newPathConf.RPICameraBitrate
return newPathConf.Equal(clone)
}
type pathSetHLSServerRes struct {
readyPaths []defs.Path
}
type pathSetHLSServerReq struct {
s *hls.Server
res chan pathSetHLSServerRes
}
type pathManagerAuthManager interface {
Authenticate(req *auth.Request) (string, *auth.Error)
}
type pathManagerParent interface {
logger.Writer
}
type pathManager struct {
logLevel conf.LogLevel
rtspAddress string
dumpPackets bool
readTimeout conf.Duration
writeTimeout conf.Duration
writeQueueSize int
udpReadBufferSize uint
rtpMaxPayloadSize int
pathConfs map[string]*conf.Path
authManager pathManagerAuthManager
externalCmdPool *externalcmd.Pool
metrics *metrics.Metrics
parent pathManagerParent
ctx context.Context
ctxCancel func()
wg sync.WaitGroup
hlsServer *hls.Server
paths map[string]*path
// in
chReloadConf chan map[string]*conf.Path
chSetHLSServer chan pathSetHLSServerReq
chRemovePath chan *path
chClosePathIfIdle chan *path
chSetPathReady chan *path
chSetPathNotReady chan *path
chFindPathConf chan defs.PathFindPathConfReq
chDescribe chan defs.PathDescribeReq
chAddReader chan defs.PathAddReaderReq
chAddPublisher chan defs.PathAddPublisherReq
chAPIPathsList chan pathAPIPathsListReq
chAPIPathsGet chan pathAPIPathsGetReq
}
func (pm *pathManager) initialize() {
ctx, ctxCancel := context.WithCancel(context.Background())
pm.ctx = ctx
pm.ctxCancel = ctxCancel
pm.paths = make(map[string]*path)
pm.chReloadConf = make(chan map[string]*conf.Path)
pm.chSetHLSServer = make(chan pathSetHLSServerReq)
pm.chRemovePath = make(chan *path)
pm.chClosePathIfIdle = make(chan *path)
pm.chSetPathReady = make(chan *path)
pm.chSetPathNotReady = make(chan *path)
pm.chFindPathConf = make(chan defs.PathFindPathConfReq)
pm.chDescribe = make(chan defs.PathDescribeReq)
pm.chAddReader = make(chan defs.PathAddReaderReq)
pm.chAddPublisher = make(chan defs.PathAddPublisherReq)
pm.chAPIPathsList = make(chan pathAPIPathsListReq)
pm.chAPIPathsGet = make(chan pathAPIPathsGetReq)
for _, pathConf := range pm.pathConfs {
if pathConf.Regexp == nil {
pm.createPath(pathConf, pathConf.Name, nil)
}
}
pm.Log(logger.Debug, "path manager created")
pm.wg.Add(1)
go pm.run()
if pm.metrics != nil {
pm.metrics.SetPathManager(pm)
}
}
func (pm *pathManager) close() {
pm.Log(logger.Debug, "path manager is shutting down")
if pm.metrics != nil {
pm.metrics.SetPathManager(nil)
}
pm.ctxCancel()
pm.wg.Wait()
}
// Log implements logger.Writer.
func (pm *pathManager) Log(level logger.Level, format string, args ...any) {
pm.parent.Log(level, format, args...)
}
func (pm *pathManager) run() {
defer pm.wg.Done()
outer:
for {
select {
case newPaths := <-pm.chReloadConf:
pm.doReloadConf(newPaths)
case req := <-pm.chSetHLSServer:
readyPaths := pm.doSetHLSServer(req.s)
req.res <- pathSetHLSServerRes{readyPaths: readyPaths}
case pa := <-pm.chRemovePath:
if pa2, ok := pm.paths[pa.name]; ok && pa2 == pa {
delete(pm.paths, pa.name)
}
case pa := <-pm.chClosePathIfIdle:
if atomic.LoadInt64(pa.pendingRequests) == 0 {
pm.doClosePath(pa)
}
case pa := <-pm.chSetPathReady:
pm.doSetPathReady(pa)
case pa := <-pm.chSetPathNotReady:
pm.doSetPathNotReady(pa)
case req := <-pm.chFindPathConf:
pm.doFindPathConf(req)
case req := <-pm.chDescribe:
pm.doDescribe(req)
case req := <-pm.chAddReader:
pm.doAddReader(req)
case req := <-pm.chAddPublisher:
pm.doAddPublisher(req)
case req := <-pm.chAPIPathsList:
pm.doAPIPathsList(req)
case req := <-pm.chAPIPathsGet:
pm.doAPIPathsGet(req)
case <-pm.ctx.Done():
break outer
}
}
pm.ctxCancel()
}
func (pm *pathManager) doReloadConf(newPaths map[string]*conf.Path) {
confsToRecreate := make(map[string]struct{})
confsToReload := make(map[string]struct{})
for confName, pathConf := range pm.pathConfs {
if newPath, ok := newPaths[confName]; ok {
if !newPath.Equal(pathConf) {
if pathConfCanBeUpdated(pathConf, newPath) {
confsToReload[confName] = struct{}{}
} else {
confsToRecreate[confName] = struct{}{}
}
}
}
}
// process existing paths
for pathName, pa := range pm.paths {
newPathConf, _, err := conf.FindPathConf(newPaths, pathName)
// path does not have a config anymore: delete it
if err != nil {
pm.doClosePath(pa)
continue
}
// path now belongs to a different config
if newPathConf.Name != pa.confName {
// path config can be hot reloaded
oldPathConf := pm.pathConfs[pa.confName]
if pathConfCanBeUpdated(oldPathConf, newPathConf) {
pa.confName = newPathConf.Name
go pa.reloadConf(newPathConf)
continue
}
// Configuration cannot be hot reloaded: delete the path
pm.doClosePath(pa)
continue
}
// path configuration has changed and cannot be hot reloaded: delete path
if _, ok := confsToRecreate[newPathConf.Name]; ok {
pm.doClosePath(pa)
continue
}
// path configuration has changed but can be hot reloaded: reload it
if _, ok := confsToReload[newPathConf.Name]; ok {
go pa.reloadConf(newPathConf)
}
}
pm.pathConfs = newPaths
// create new static paths
for pathConfName, pathConf := range newPaths {
if pathConf.Regexp == nil {
if _, ok := pm.paths[pathConfName]; !ok {
pm.createPath(pathConf, pathConfName, nil)
}
}
}
}
func (pm *pathManager) doClosePath(pa *path) {
delete(pm.paths, pa.name)
pa.close()
pa.wait() // avoid conflicts between sources
}
func (pm *pathManager) doSetHLSServer(m *hls.Server) []defs.Path {
pm.hlsServer = m
var ret []defs.Path
for _, pa := range pm.paths {
if pa.ready {
ret = append(ret, pa)
}
}
return ret
}
func (pm *pathManager) doSetPathReady(pa *path) {
if pa2, ok := pm.paths[pa.name]; !ok || pa2 != pa {
return
}
pm.paths[pa.name].ready = true
if pm.hlsServer != nil {
pm.hlsServer.PathReady(pa)
}
}
func (pm *pathManager) doSetPathNotReady(pa *path) {
if pa2, ok := pm.paths[pa.name]; !ok || pa2 != pa {
return
}
pm.paths[pa.name].ready = false
if pm.hlsServer != nil {
pm.hlsServer.PathNotReady(pa)
}
}
func (pm *pathManager) doFindPathConf(req defs.PathFindPathConfReq) {
pathConf, _, err := conf.FindPathConf(pm.pathConfs, req.AccessRequest.Name)
if err != nil {
req.Res <- defs.PathFindPathConfRes{Err: err}
return
}
user, err2 := pm.authManager.Authenticate(req.AccessRequest.ToAuthRequest())
if err2 != nil {
req.Res <- defs.PathFindPathConfRes{Err: err2}
return
}
req.Res <- defs.PathFindPathConfRes{
Conf: pathConf,
User: user,
}
}
func (pm *pathManager) doDescribe(req defs.PathDescribeReq) {
pathConf, pathMatches, err := conf.FindPathConf(pm.pathConfs, req.AccessRequest.Name)
if err != nil {
req.Res <- defs.PathDescribeRes{Err: err}
return
}
_, err2 := pm.authManager.Authenticate(req.AccessRequest.ToAuthRequest())
if err2 != nil {
req.Res <- defs.PathDescribeRes{Err: err2}
return
}
// create path if it doesn't exist
if _, ok := pm.paths[req.AccessRequest.Name]; !ok {
pm.createPath(pathConf, req.AccessRequest.Name, pathMatches)
}
pa := pm.paths[req.AccessRequest.Name]
atomic.AddInt64(pa.pendingRequests, 1)
req.Res <- defs.PathDescribeRes{Path: pa}
}
func (pm *pathManager) doAddReader(req defs.PathAddReaderReq) {
pathConf, pathMatches, err := conf.FindPathConf(pm.pathConfs, req.AccessRequest.Name)
if err != nil {
req.Res <- defs.PathAddReaderRes{Err: err}
return
}
var user string
if !req.AccessRequest.SkipAuth {
var authErr *auth.Error
user, authErr = pm.authManager.Authenticate(req.AccessRequest.ToAuthRequest())
if authErr != nil {
req.Res <- defs.PathAddReaderRes{Err: authErr}
return
}
}
// create path if it doesn't exist
if _, ok := pm.paths[req.AccessRequest.Name]; !ok {
pm.createPath(pathConf, req.AccessRequest.Name, pathMatches)
}
pa := pm.paths[req.AccessRequest.Name]
atomic.AddInt64(pa.pendingRequests, 1)
req.Res <- defs.PathAddReaderRes{
Path: pa,
User: user,
}
}
func (pm *pathManager) doAddPublisher(req defs.PathAddPublisherReq) {
pathConf, pathMatches, err := conf.FindPathConf(pm.pathConfs, req.AccessRequest.Name)
if err != nil {
req.Res <- defs.PathAddPublisherRes{Err: err}
return
}
if req.ConfToCompare != nil && !pathConf.Equal(req.ConfToCompare) {
req.Res <- defs.PathAddPublisherRes{Err: fmt.Errorf("configuration has changed")}
return
}
var user string
if !req.AccessRequest.SkipAuth {
var authErr *auth.Error
user, authErr = pm.authManager.Authenticate(req.AccessRequest.ToAuthRequest())
if authErr != nil {
req.Res <- defs.PathAddPublisherRes{Err: authErr}
return
}
}
// create path if it doesn't exist
if _, ok := pm.paths[req.AccessRequest.Name]; !ok {
pm.createPath(pathConf, req.AccessRequest.Name, pathMatches)
}
pa := pm.paths[req.AccessRequest.Name]
atomic.AddInt64(pa.pendingRequests, 1)
req.Res <- defs.PathAddPublisherRes{
Path: pa,
User: user,
}
}
func (pm *pathManager) doAPIPathsList(req pathAPIPathsListReq) {
paths := make(map[string]*path)
maps.Copy(paths, pm.paths)
req.res <- pathAPIPathsListRes{paths: paths}
}
func (pm *pathManager) doAPIPathsGet(req pathAPIPathsGetReq) {
pa, ok := pm.paths[req.name]
if !ok {
req.res <- pathAPIPathsGetRes{err: conf.ErrPathNotFound}
return
}
req.res <- pathAPIPathsGetRes{path: pa}
}
func (pm *pathManager) createPath(
pathConf *conf.Path,
name string,
matches []string,
) {
pa := &path{
parentCtx: pm.ctx,
logLevel: pm.logLevel,
dumpPackets: pm.dumpPackets,
rtspAddress: pm.rtspAddress,
readTimeout: pm.readTimeout,
writeTimeout: pm.writeTimeout,
writeQueueSize: pm.writeQueueSize,
udpReadBufferSize: pm.udpReadBufferSize,
rtpMaxPayloadSize: pm.rtpMaxPayloadSize,
conf: pathConf,
name: name,
matches: matches,
wg: &pm.wg,
externalCmdPool: pm.externalCmdPool,
parent: pm,
}
pa.initialize()
pm.paths[name] = pa
}
// ReloadPathConfs is called by core.
func (pm *pathManager) ReloadPathConfs(pathConfs map[string]*conf.Path) {
select {
case pm.chReloadConf <- pathConfs:
case <-pm.ctx.Done():
}
}
// setPathReady is called by path.
func (pm *pathManager) setPathReady(pa *path) {
select {
case pm.chSetPathReady <- pa:
case <-pm.ctx.Done():
case <-pa.ctx.Done(): // in case pathManager is blocked by path.wait()
}
}
// setPathNotReady is called by path.
func (pm *pathManager) setPathNotReady(pa *path) {
select {
case pm.chSetPathNotReady <- pa:
case <-pm.ctx.Done():
case <-pa.ctx.Done(): // in case pathManager is blocked by path.wait()
}
}
// removePath is called by path.
func (pm *pathManager) removePath(pa *path) {
select {
case pm.chRemovePath <- pa:
case <-pm.ctx.Done():
case <-pa.ctx.Done(): // in case pathManager is blocked by path.wait()
}
}
// closePath is called by path.
func (pm *pathManager) closePathIfIdle(pa *path) {
select {
case pm.chClosePathIfIdle <- pa:
case <-pm.ctx.Done():
case <-pa.ctx.Done(): // in case pathManager is blocked by path.wait()
}
}
// FindPathConf is called by a reader or publisher.
func (pm *pathManager) FindPathConf(req defs.PathFindPathConfReq) (*defs.PathFindPathConfRes, error) {
req.Res = make(chan defs.PathFindPathConfRes)
select {
case pm.chFindPathConf <- req:
res := <-req.Res
return &res, res.Err
case <-pm.ctx.Done():
return nil, fmt.Errorf("terminated")
}
}
// Describe is called by a reader or publisher.
func (pm *pathManager) Describe(req defs.PathDescribeReq) defs.PathDescribeRes {
req.Res = make(chan defs.PathDescribeRes)
select {
case pm.chDescribe <- req:
res1 := <-req.Res
if res1.Err != nil {
return res1
}
res2 := res1.Path.(*path).describe(req)
if res2.Err != nil {
return res2
}
res2.Path = res1.Path
return res2
case <-pm.ctx.Done():
return defs.PathDescribeRes{Err: fmt.Errorf("terminated")}
}
}
// AddPublisher is called by a publisher.
func (pm *pathManager) AddPublisher(req defs.PathAddPublisherReq) (*defs.PathAddPublisherRes, error) {
req.Res = make(chan defs.PathAddPublisherRes)
select {
case pm.chAddPublisher <- req:
res1 := <-req.Res
if res1.Err != nil {
return nil, res1.Err
}
res2, err := res1.Path.(*path).addPublisher(req)
if err != nil {
return nil, err
}
res2.Path = res1.Path
res2.User = res1.User
return res2, nil
case <-pm.ctx.Done():
return nil, fmt.Errorf("terminated")
}
}
// AddReader is called by a reader.
func (pm *pathManager) AddReader(req defs.PathAddReaderReq) (*defs.PathAddReaderRes, error) {
req.Res = make(chan defs.PathAddReaderRes)
select {
case pm.chAddReader <- req:
res1 := <-req.Res
if res1.Err != nil {
return nil, res1.Err
}
res2, err := res1.Path.(*path).addReader(req)
if err != nil {
return nil, err
}
res2.Path = res1.Path
res2.User = res1.User
return res2, nil
case <-pm.ctx.Done():
return nil, fmt.Errorf("terminated")
}
}
// SetHLSServer is called by hls.Server.
func (pm *pathManager) SetHLSServer(s *hls.Server) []defs.Path {
req := pathSetHLSServerReq{
s: s,
res: make(chan pathSetHLSServerRes),
}
select {
case pm.chSetHLSServer <- req:
res := <-req.res
return res.readyPaths
case <-pm.ctx.Done():
return nil
}
}
// APIPathsList is called by api.
func (pm *pathManager) APIPathsList() (*defs.APIPathList, error) {
req := pathAPIPathsListReq{
res: make(chan pathAPIPathsListRes),
}
select {
case pm.chAPIPathsList <- req:
res := <-req.res
res.data = &defs.APIPathList{
Items: []defs.APIPath{},
}
for _, pa := range res.paths {
item, err := pa.APIPathsGet(pathAPIPathsGetReq{})
if err == nil {
res.data.Items = append(res.data.Items, *item)
}
}
sort.Slice(res.data.Items, func(i, j int) bool {
return res.data.Items[i].Name < res.data.Items[j].Name
})
return res.data, nil
case <-pm.ctx.Done():
return nil, fmt.Errorf("terminated")
}
}
// APIPathsGet is called by api.
func (pm *pathManager) APIPathsGet(name string) (*defs.APIPath, error) {
req := pathAPIPathsGetReq{
name: name,
res: make(chan pathAPIPathsGetRes),
}
select {
case pm.chAPIPathsGet <- req:
res := <-req.res
if res.err != nil {
return nil, res.err
}
data, err := res.path.APIPathsGet(req)
return data, err
case <-pm.ctx.Done():
return nil, fmt.Errorf("terminated")
}
}
================================================
FILE: internal/core/path_manager_test.go
================================================
package core
import (
"net/http"
"regexp"
"testing"
"time"
"github.com/bluenviron/gortsplib/v5"
"github.com/bluenviron/gortsplib/v5/pkg/description"
"github.com/pion/rtp"
"github.com/stretchr/testify/require"
"github.com/bluenviron/mediamtx/internal/conf"
"github.com/bluenviron/mediamtx/internal/defs"
"github.com/bluenviron/mediamtx/internal/logger"
"github.com/bluenviron/mediamtx/internal/test"
)
type dummyPublisher struct{}
func (d *dummyPublisher) Close() {}
func (d *dummyPublisher) Log(_ logger.Level, _ string, _ ...any) {}
func (d *dummyPublisher) APISourceDescribe() *defs.APIPathSource {
return nil
}
type dummyReader struct{}
func (d *dummyReader) Close() {}
func (d *dummyReader) Log(_ logger.Level, _ string, _ ...any) {}
func (d *dummyReader) APIReaderDescribe() *defs.APIPathReader {
return nil
}
func TestPathManagerDynamicPathAutoDeletion(t *testing.T) {
for _, ca := range []string{"describe", "add reader"} {
t.Run(ca, func(t *testing.T) {
pathConfs := map[string]*conf.Path{
"all_others": {
Regexp: regexp.MustCompile("^.*$"),
Name: "all_others",
Source: "publisher",
},
}
pm := &pathManager{
authManager: test.NilAuthManager,
pathConfs: pathConfs,
parent: test.NilLogger,
}
pm.initialize()
defer pm.close()
func() {
if ca == "describe" {
res := pm.Describe(defs.PathDescribeReq{
AccessRequest: defs.PathAccessRequest{
Name: "mypath",
},
})
require.EqualError(t, res.Err, "no stream is available on path 'mypath'")
} else {
_, err := pm.AddReader(defs.PathAddReaderReq{
Author: &dummyReader{},
AccessRequest: defs.PathAccessRequest{
Name: "mypath",
},
})
require.EqualError(t, err, "no stream is available on path 'mypath'")
}
}()
time.Sleep(100 * time.Millisecond)
data, err := pm.APIPathsList()
require.NoError(t, err)
require.Empty(t, data.Items)
})
}
}
func TestPathManagerDynamicPathDescribeAndPublish(t *testing.T) {
pathConfs := map[string]*conf.Path{
"all_others": {
Regexp: regexp.MustCompile("^.*$"),
Name: "all_others",
Source: "publisher",
},
}
pm := &pathManager{
authManager: test.NilAuthManager,
pathConfs: pathConfs,
parent: test.NilLogger,
}
pm.initialize()
defer pm.close()
go func() {
for range 10 {
pm.Describe(defs.PathDescribeReq{
AccessRequest: defs.PathAccessRequest{
Name: "mypath",
},
})
}
}()
_, err := pm.AddPublisher(defs.PathAddPublisherReq{
Author: &dummyPublisher{},
Desc: &description.Session{},
AccessRequest: defs.PathAccessRequest{
Name: "mypath",
},
})
require.NoError(t, err)
}
func TestPathManagerConfigHotReload(t *testing.T) {
// Start MediaMTX with basic configuration
p, ok := newInstance("api: yes\n" +
"paths:\n" +
" all:\n" +
" record: no\n")
require.Equal(t, true, ok)
defer p.Close()
// Set up HTTP client for API calls
tr := &http.Transport{}
defer tr.CloseIdleConnections()
hc := &http.Client{Transport: tr}
// Create a publisher that will use the "all" configuration
media0 := test.UniqueMediaH264()
source := gortsplib.Client{}
err := source.StartRecording(
"rtsp://localhost:8554/undefined_stream",
&description.Session{Medias: []*description.Media{media0}})
require.NoError(t, err)
defer source.Close()
// Send some data to establish the stream
err = source.WritePacketRTP(media0, &rtp.Packet{
Header: rtp.Header{
Version: 2,
PayloadType: 96,
},
Payload: []byte{5, 1, 2, 3, 4},
})
require.NoError(t, err)
time.Sleep(100 * time.Millisecond)
// Verify the path exists and is using the "all" configuration
pathData, err := p.pathManager.APIPathsGet("undefined_stream")
require.NoError(t, err)
require.Equal(t, "undefined_stream", pathData.Name)
require.Equal(t, "all", pathData.ConfName)
// Check the current configuration via API
var allConfig map[string]any
httpRequest(t, hc, http.MethodGet, "http://localhost:9997/v3/config/paths/get/all", nil, &allConfig)
require.Equal(t, false, allConfig["record"]) // Should be false from "all" config
// Add a new specific configuration for "undefined_stream" with record enabled
httpRequest(t, hc, http.MethodPost, "http://localhost:9997/v3/config/paths/add/undefined_stream",
map[string]any{
"record": true,
}, nil)
// Give the system time to process the configuration change
time.Sleep(200 * time.Millisecond)
// Verify the path now uses the new specific configuration
pathData, err = p.pathManager.APIPathsGet("undefined_stream")
require.NoError(t, err)
require.Equal(t, "undefined_stream", pathData.Name)
require.Equal(t, "undefined_stream", pathData.ConfName) // Should now use the specific config
// Check the new configuration via API
var newConfig map[string]any
httpRequest(t, hc, http.MethodGet, "http://localhost:9997/v3/config/paths/get/undefined_stream", nil, &newConfig)
require.Equal(t, true, newConfig["record"]) // Should be true from new config
// Verify the stream is still active and working
err = source.WritePacketRTP(media0, &rtp.Packet{
Header: rtp.Header{
Version: 2,
PayloadType: 96,
SequenceNumber: 2,
},
Payload: []byte{5, 1, 2, 3, 4},
})
require.NoError(t, err)
// Verify the path is still ready and functional
require.Equal(t, true, pathData.Ready)
// revert configuration
httpRequest(t, hc, http.MethodDelete, "http://localhost:9997/v3/config/paths/delete/undefined_stream",
nil, nil)
// Give the system time to process the configuration change
time.Sleep(200 * time.Millisecond)
// Verify the path now uses the old configuration
pathData, err = p.pathManager.APIPathsGet("undefined_stream")
require.NoError(t, err)
require.Equal(t, "undefined_stream", pathData.Name)
require.Equal(t, "all", pathData.ConfName)
}
================================================
FILE: internal/core/path_test.go
================================================
package core
import (
"bufio"
"context"
"crypto/tls"
"fmt"
"net"
"net/http"
"net/url"
"os"
"path/filepath"
"strings"
"testing"
"time"
"github.com/bluenviron/gortmplib"
"github.com/bluenviron/gortsplib/v5"
"github.com/bluenviron/gortsplib/v5/pkg/base"
"github.com/bluenviron/gortsplib/v5/pkg/description"
"github.com/bluenviron/gortsplib/v5/pkg/headers"
"github.com/bluenviron/gortsplib/v5/pkg/sdp"
srt "github.com/datarhei/gosrt"
"github.com/pion/rtp"
"github.com/stretchr/testify/require"
"github.com/bluenviron/mediamtx/internal/defs"
"github.com/bluenviron/mediamtx/internal/protocols/whip"
"github.com/bluenviron/mediamtx/internal/test"
)
type testServer struct {
onDescribe func(*gortsplib.ServerHandlerOnDescribeCtx) (*base.Response, *gortsplib.ServerStream, error)
onSetup func(*gortsplib.ServerHandlerOnSetupCtx) (*base.Response, *gortsplib.ServerStream, error)
onPlay func(*gortsplib.ServerHandlerOnPlayCtx) (*base.Response, error)
}
func (sh *testServer) OnDescribe(ctx *gortsplib.ServerHandlerOnDescribeCtx,
) (*base.Response, *gortsplib.ServerStream, error) {
return sh.onDescribe(ctx)
}
func (sh *testServer) OnSetup(ctx *gortsplib.ServerHandlerOnSetupCtx) (*base.Response, *gortsplib.ServerStream, error) {
return sh.onSetup(ctx)
}
func (sh *testServer) OnPlay(ctx *gortsplib.ServerHandlerOnPlayCtx) (*base.Response, error) {
return sh.onPlay(ctx)
}
var _ defs.Path = &path{}
func TestPathRunOnDemand(t *testing.T) {
onDemand := filepath.Join(os.TempDir(), "on_demand")
onUnDemand := filepath.Join(os.TempDir(), "on_undemand")
for _, ca := range []string{"describe", "setup", "describe and setup"} {
t.Run(ca, func(t *testing.T) {
defer os.Remove(onDemand)
defer os.Remove(onUnDemand)
p1, ok := newInstance(fmt.Sprintf("rtmp: no\n"+
"hls: no\n"+
"webrtc: no\n"+
"paths:\n"+
" '~^(on)demand$':\n"+
" runOnDemand: sh -c \"ON_DEMAND=%s go run ./test_on_demand/main.go\"\n"+
" runOnDemandCloseAfter: 1s\n"+
" runOnUnDemand: touch %s\n", onDemand, onUnDemand))
require.Equal(t, true, ok)
defer p1.Close()
var control string
func() {
conn, err := net.Dial("tcp", "localhost:8554")
require.NoError(t, err)
defer conn.Close()
br := bufio.NewReader(conn)
if ca == "describe" || ca == "describe and setup" {
var u *base.URL
u, err = base.ParseURL("rtsp://localhost:8554/ondemand?param=value")
require.NoError(t, err)
byts, _ := base.Request{
Method: base.Describe,
URL: u,
Header: base.Header{
"CSeq": base.HeaderValue{"1"},
},
}.Marshal()
_, err = conn.Write(byts)
require.NoError(t, err)
var res base.Response
err = res.Unmarshal(br)
require.NoError(t, err)
require.Equal(t, base.StatusOK, res.StatusCode)
var desc sdp.SessionDescription
err = desc.Unmarshal(res.Body)
require.NoError(t, err)
control, _ = desc.MediaDescriptions[0].Attribute("control")
control = "rtsp://localhost:8554/ondemand?param=value/" + control
} else {
control = "rtsp://localhost:8554/ondemand?param=value/"
}
if ca == "setup" || ca == "describe and setup" {
var u *base.URL
u, err = base.ParseURL(control)
require.NoError(t, err)
byts, _ := base.Request{
Method: base.Setup,
URL: u,
Header: base.Header{
"CSeq": base.HeaderValue{"2"},
"Transport": headers.Transport{
Mode: func() *headers.TransportMode {
v := headers.TransportModePlay
return &v
}(),
Protocol: headers.TransportProtocolTCP,
InterleavedIDs: &[2]int{0, 1},
}.Marshal(),
},
}.Marshal()
_, err = conn.Write(byts)
require.NoError(t, err)
var res base.Response
err = res.Unmarshal(br)
require.NoError(t, err)
require.Equal(t, base.StatusOK, res.StatusCode)
}
}()
for {
_, err := os.Stat(onUnDemand)
if err == nil {
break
}
time.Sleep(100 * time.Millisecond)
}
_, err := os.Stat(onDemand)
require.NoError(t, err)
})
}
}
func TestPathRunOnConnect(t *testing.T) {
serverCertFpath, err := test.CreateTempFile(test.TLSCertPub)
require.NoError(t, err)
defer os.Remove(serverCertFpath)
serverKeyFpath, err := test.CreateTempFile(test.TLSCertKey)
require.NoError(t, err)
defer os.Remove(serverKeyFpath)
for _, ca := range []string{"rtsp", "rtsps", "rtmp", "rtmps", "srt"} {
t.Run(ca, func(t *testing.T) {
onConnect := filepath.Join(os.TempDir(), "on_connect")
defer os.Remove(onConnect)
onDisconnect := filepath.Join(os.TempDir(), "on_disconnect")
defer os.Remove(onDisconnect)
connType := ""
func() {
p, ok := newInstance(fmt.Sprintf(
"rtspEncryption: optional\n"+
"rtspServerCert: "+serverCertFpath+"\n"+
"rtspServerKey: "+serverKeyFpath+"\n"+
"rtmpEncryption: optional\n"+
"rtmpServerCert: "+serverCertFpath+"\n"+
"rtmpServerKey: "+serverKeyFpath+"\n"+
"paths:\n"+
" test:\n"+
"runOnConnect: sh -c 'echo \"$MTX_CONN_TYPE $MTX_CONN_ID $RTSP_PORT\" > %s'\n"+
"runOnDisconnect: sh -c 'echo \"$MTX_CONN_TYPE $MTX_CONN_ID $RTSP_PORT\" > %s'\n",
onConnect, onDisconnect))
require.Equal(t, true, ok)
defer p.Close()
switch ca {
case "rtsp":
connType = "rtspConn"
c := gortsplib.Client{}
err = c.StartRecording(
"rtsp://localhost:8554/test",
&description.Session{Medias: []*description.Media{test.UniqueMediaH264()}})
require.NoError(t, err)
defer c.Close()
case "rtsps":
connType = "rtspsConn"
c := gortsplib.Client{TLSConfig: &tls.Config{InsecureSkipVerify: true}}
err = c.StartRecording(
"rtsps://localhost:8322/test",
&description.Session{Medias: []*description.Media{test.UniqueMediaH264()}})
require.NoError(t, err)
defer c.Close()
case "rtmp":
connType = "rtmpConn"
var u *url.URL
u, err = url.Parse("rtmp://127.0.0.1:1935/test")
require.NoError(t, err)
conn := &gortmplib.Client{
URL: u,
Publish: true,
}
err = conn.Initialize(context.Background())
require.NoError(t, err)
defer conn.Close()
case "rtmps":
connType = "rtmpsConn"
var u *url.URL
u, err = url.Parse("rtmps://127.0.0.1:1936/test")
require.NoError(t, err)
conn := &gortmplib.Client{
URL: u,
Publish: true,
TLSConfig: &tls.Config{InsecureSkipVerify: true},
}
err = conn.Initialize(context.Background())
require.NoError(t, err)
defer conn.Close()
case "srt":
connType = "srtConn"
conf := srt.DefaultConfig()
var address string
address, err = conf.UnmarshalURL("srt://localhost:8890?streamid=publish:test")
require.NoError(t, err)
err = conf.Validate()
require.NoError(t, err)
var c srt.Conn
c, err = srt.Dial("srt", address, conf)
require.NoError(t, err)
defer c.Close()
}
time.Sleep(500 * time.Millisecond)
}()
var byts []byte
byts, err = os.ReadFile(onConnect)
require.NoError(t, err)
fields := strings.Split(string(byts[:len(byts)-1]), " ")
require.Equal(t, connType, fields[0])
require.NotEmpty(t, fields[1])
require.Equal(t, "8554", fields[2])
byts, err = os.ReadFile(onDisconnect)
require.NoError(t, err)
fields = strings.Split(string(byts[:len(byts)-1]), " ")
require.Equal(t, connType, fields[0])
require.NotEmpty(t, fields[1])
require.Equal(t, "8554", fields[2])
})
}
}
func TestPathRunOnReady(t *testing.T) {
onReady := filepath.Join(os.TempDir(), "on_ready")
defer os.Remove(onReady)
onNotReady := filepath.Join(os.TempDir(), "on_unready")
defer os.Remove(onNotReady)
func() {
p, ok := newInstance(fmt.Sprintf("rtmp: no\n"+
"hls: no\n"+
"webrtc: no\n"+
"paths:\n"+
" ~te(st):\n"+
" runOnReady: sh -c 'echo \"$MTX_PATH $MTX_QUERY $MTX_SOURCE_TYPE $MTX_SOURCE_ID $RTSP_PORT $G1\" > %s'\n"+
" runOnNotReady: sh -c 'echo \"$MTX_PATH $MTX_QUERY $MTX_SOURCE_TYPE $MTX_SOURCE_ID $RTSP_PORT $G1\" > %s'\n",
onReady, onNotReady))
require.Equal(t, true, ok)
defer p.Close()
c := gortsplib.Client{}
err := c.StartRecording(
"rtsp://localhost:8554/test?query=value",
&description.Session{Medias: []*description.Media{test.UniqueMediaH264()}})
require.NoError(t, err)
defer c.Close()
time.Sleep(500 * time.Millisecond)
}()
byts, err := os.ReadFile(onReady)
require.NoError(t, err)
fields := strings.Split(string(byts[:len(byts)-1]), " ")
require.Equal(t, "test", fields[0])
require.Equal(t, "query=value", fields[1])
require.Equal(t, "rtspSession", fields[2])
require.NotEmpty(t, fields[3])
require.Equal(t, "8554", fields[4])
require.Equal(t, "st", fields[5])
byts, err = os.ReadFile(onNotReady)
require.NoError(t, err)
fields = strings.Split(string(byts[:len(byts)-1]), " ")
require.Equal(t, "test", fields[0])
require.Equal(t, "query=value", fields[1])
require.Equal(t, "rtspSession", fields[2])
require.NotEmpty(t, fields[3])
require.Equal(t, "8554", fields[4])
require.Equal(t, "st", fields[5])
}
func TestPathRunOnRead(t *testing.T) {
serverCertFpath, err := test.CreateTempFile(test.TLSCertPub)
require.NoError(t, err)
defer os.Remove(serverCertFpath)
serverKeyFpath, err := test.CreateTempFile(test.TLSCertKey)
require.NoError(t, err)
defer os.Remove(serverKeyFpath)
for _, ca := range []string{"rtsp", "rtsps", "rtmp", "rtmps", "srt", "webrtc"} {
t.Run(ca, func(t *testing.T) {
onRead := filepath.Join(os.TempDir(), "on_read")
defer os.Remove(onRead)
onUnread := filepath.Join(os.TempDir(), "on_unread")
defer os.Remove(onUnread)
func() {
p, ok := newInstance(fmt.Sprintf(
"rtspEncryption: optional\n"+
"rtspServerCert: "+serverCertFpath+"\n"+
"rtspServerKey: "+serverKeyFpath+"\n"+
"rtmpEncryption: optional\n"+
"rtmpServerCert: "+serverCertFpath+"\n"+
"rtmpServerKey: "+serverKeyFpath+"\n"+
"paths:\n"+
" ~te(st):\n"+
" runOnRead: sh -c 'echo \"$MTX_PATH $MTX_QUERY $MTX_READER_TYPE $MTX_READER_ID $RTSP_PORT $G1\" > %s'\n"+
" runOnUnread: sh -c 'echo \"$MTX_PATH $MTX_QUERY $MTX_READER_TYPE $MTX_READER_ID $RTSP_PORT $G1\" > %s'\n",
onRead, onUnread))
require.Equal(t, true, ok)
defer p.Close()
media0 := test.UniqueMediaH264()
source := gortsplib.Client{}
err = source.StartRecording(
"rtsp://localhost:8554/test",
&description.Session{Medias: []*description.Media{media0}})
require.NoError(t, err)
defer source.Close()
writerDone := make(chan struct{})
defer func() { <-writerDone }()
writerTerminate := make(chan struct{})
defer close(writerTerminate)
go func() {
defer close(writerDone)
i := 0
for {
select {
case <-time.After(100 * time.Millisecond):
case <-writerTerminate:
return
}
err2 := source.WritePacketRTP(media0, &rtp.Packet{
Header: rtp.Header{
Version: 2,
Marker: true,
PayloadType: 96,
SequenceNumber: uint16(123 + i),
Timestamp: uint32(45343 + i*90000),
SSRC: 563423,
},
Payload: []byte{5},
})
require.NoError(t, err2)
i++
}
}()
switch ca {
case "rtsp":
var u *base.URL
u, err = base.ParseURL("rtsp://127.0.0.1:8554/test?query=value")
require.NoError(t, err)
reader := gortsplib.Client{
Scheme: u.Scheme,
Host: u.Host,
}
err = reader.Start()
require.NoError(t, err)
defer reader.Close()
var desc *description.Session
desc, _, err = reader.Describe(u)
require.NoError(t, err)
err = reader.SetupAll(desc.BaseURL, desc.Medias)
require.NoError(t, err)
_, err = reader.Play(nil)
require.NoError(t, err)
case "rtsps":
var u *base.URL
u, err = base.ParseURL("rtsps://127.0.0.1:8322/test?query=value")
require.NoError(t, err)
reader := gortsplib.Client{
Scheme: u.Scheme,
Host: u.Host,
TLSConfig: &tls.Config{InsecureSkipVerify: true},
}
err = reader.Start()
require.NoError(t, err)
defer reader.Close()
var desc *description.Session
desc, _, err = reader.Describe(u)
require.NoError(t, err)
err = reader.SetupAll(desc.BaseURL, desc.Medias)
require.NoError(t, err)
_, err = reader.Play(nil)
require.NoError(t, err)
case "rtmp":
var u *url.URL
u, err = url.Parse("rtmp://127.0.0.1:1935/test?query=value")
require.NoError(t, err)
conn := &gortmplib.Client{
URL: u,
Publish: false,
}
err = conn.Initialize(context.Background())
require.NoError(t, err)
defer conn.Close()
r := &gortmplib.Reader{
Conn: conn,
}
err = r.Initialize()
require.NoError(t, err)
case "rtmps":
var u *url.URL
u, err = url.Parse("rtmps://127.0.0.1:1936/test?query=value")
require.NoError(t, err)
conn := &gortmplib.Client{
URL: u,
Publish: false,
TLSConfig: &tls.Config{InsecureSkipVerify: true},
}
err = conn.Initialize(context.Background())
require.NoError(t, err)
defer conn.Close()
go func() {
for i := range uint16(3) {
err2 := source.WritePacketRTP(media0, &rtp.Packet{
Header: rtp.Header{
Version: 2,
Marker: true,
PayloadType: 96,
SequenceNumber: 123 + i,
Timestamp: 45343 + uint32(i)*2*90000,
SSRC: 563423,
},
Payload: []byte{5},
})
require.NoError(t, err2)
}
}()
r := &gortmplib.Reader{
Conn: conn,
}
err = r.Initialize()
require.NoError(t, err)
case "srt":
conf := srt.DefaultConfig()
var address string
address, err = conf.UnmarshalURL("srt://localhost:8890?streamid=read:test:query=value")
require.NoError(t, err)
err = conf.Validate()
require.NoError(t, err)
var reader srt.Conn
reader, err = srt.Dial("srt", address, conf)
require.NoError(t, err)
defer reader.Close()
case "webrtc":
tr := &http.Transport{}
defer tr.CloseIdleConnections()
hc := &http.Client{Transport: tr}
var u *url.URL
u, err = url.Parse("http://localhost:8889/test/whep?query=value")
require.NoError(t, err)
c := &whip.Client{
HTTPClient: hc,
URL: u,
Log: test.NilLogger,
}
err = c.Initialize(context.Background())
require.NoError(t, err)
defer checkClose(t, c.Close)
}
time.Sleep(500 * time.Millisecond)
}()
var readerType string
switch ca {
case "rtsp":
readerType = "rtspSession"
case "rtsps":
readerType = "rtspsSession"
case "rtmp":
readerType = "rtmpConn"
case "rtmps":
readerType = "rtmpsConn"
case "srt":
readerType = "srtConn"
case "webrtc":
readerType = "webRTCSession"
}
var byts []byte
byts, err = os.ReadFile(onRead)
require.NoError(t, err)
fields := strings.Split(string(byts[:len(byts)-1]), " ")
require.Equal(t, "test", fields[0])
require.Equal(t, "query=value", fields[1])
require.Equal(t, readerType, fields[2])
require.NotEmpty(t, fields[3])
require.Equal(t, "8554", fields[4])
require.Equal(t, "st", fields[5])
byts, err = os.ReadFile(onUnread)
require.NoError(t, err)
fields = strings.Split(string(byts[:len(byts)-1]), " ")
require.Equal(t, "test", fields[0])
require.Equal(t, "query=value", fields[1])
require.Equal(t, readerType, fields[2])
require.NotEmpty(t, fields[3])
require.Equal(t, "8554", fields[4])
require.Equal(t, "st", fields[5])
})
}
}
func TestPathRunOnRecordSegment(t *testing.T) {
onRecordSegmentCreate := filepath.Join(os.TempDir(), "on_record_segment_create")
defer os.Remove(onRecordSegmentCreate)
onRecordSegmentComplete := filepath.Join(os.TempDir(), "on_record_segment_complete")
defer os.Remove(onRecordSegmentComplete)
recordDir, err := os.MkdirTemp("", "rtsp-path-record")
require.NoError(t, err)
defer os.RemoveAll(recordDir)
func() {
p, ok := newInstance(fmt.Sprintf("record: yes\n"+
"recordPath: %s\n"+
"paths:\n"+
" test:\n"+
" runOnRecordSegmentCreate: sh -c 'echo \"$MTX_SEGMENT_PATH $RTSP_PORT\" > %s'\n"+
" runOnRecordSegmentComplete: sh -c 'echo \"$MTX_SEGMENT_PATH $MTX_SEGMENT_DURATION $RTSP_PORT\" > %s'\n",
filepath.Join(recordDir, "%path/%Y-%m-%d_%H-%M-%S-%f"),
onRecordSegmentCreate,
onRecordSegmentComplete,
))
require.Equal(t, true, ok)
defer p.Close()
media0 := test.UniqueMediaH264()
source := gortsplib.Client{}
err = source.StartRecording(
"rtsp://localhost:8554/test",
&description.Session{Medias: []*description.Media{media0}})
require.NoError(t, err)
defer source.Close()
for i := range 4 {
err = source.WritePacketRTP(media0, &rtp.Packet{
Header: rtp.Header{
Version: 2,
Marker: true,
PayloadType: 96,
SequenceNumber: 1123 + uint16(i),
Timestamp: 45343 + 90000*uint32(i),
SSRC: 563423,
},
Payload: []byte{5},
})
require.NoError(t, err)
}
time.Sleep(500 * time.Millisecond)
}()
byts, err := os.ReadFile(onRecordSegmentCreate)
require.NoError(t, err)
fields := strings.Split(string(byts[:len(byts)-1]), " ")
require.True(t, strings.HasPrefix(fields[0], recordDir))
require.Equal(t, "8554", fields[1])
byts, err = os.ReadFile(onRecordSegmentComplete)
require.NoError(t, err)
fields = strings.Split(string(byts[:len(byts)-1]), " ")
require.True(t, strings.HasPrefix(fields[0], recordDir))
require.Equal(t, "3", fields[1])
require.Equal(t, "8554", fields[2])
}
func TestPathMaxReaders(t *testing.T) {
p, ok := newInstance("paths:\n" +
" all_others:\n" +
" maxReaders: 1\n")
require.Equal(t, true, ok)
defer p.Close()
source := gortsplib.Client{}
err := source.StartRecording(
"rtsp://localhost:8554/mystream",
&description.Session{Medias: []*description.Media{
test.UniqueMediaH264(),
test.UniqueMediaMPEG4Audio(),
}})
require.NoError(t, err)
defer source.Close()
for i := range 2 {
var u *base.URL
u, err = base.ParseURL("rtsp://127.0.0.1:8554/mystream")
require.NoError(t, err)
reader := gortsplib.Client{
Scheme: u.Scheme,
Host: u.Host,
}
err = reader.Start()
require.NoError(t, err)
defer reader.Close()
var desc *description.Session
desc, _, err = reader.Describe(u)
require.NoError(t, err)
err = reader.SetupAll(desc.BaseURL, desc.Medias)
if i != 1 {
require.NoError(t, err)
} else {
require.Error(t, err)
}
}
}
func TestPathRecord(t *testing.T) {
dir, err := os.MkdirTemp("", "rtsp-path-record")
require.NoError(t, err)
defer os.RemoveAll(dir)
p, ok := newInstance("api: yes\n" +
"record: yes\n" +
"recordPath: " + filepath.Join(dir, "%path/%Y-%m-%d_%H-%M-%S-%f") + "\n" +
"paths:\n" +
" all_others:\n" +
" record: yes\n")
require.Equal(t, true, ok)
defer p.Close()
media0 := test.UniqueMediaH264()
source := gortsplib.Client{}
err = source.StartRecording(
"rtsp://localhost:8554/mystream",
&description.Session{Medias: []*description.Media{media0}})
require.NoError(t, err)
defer source.Close()
for i := range 4 {
err = source.WritePacketRTP(media0, &rtp.Packet{
Header: rtp.Header{
Version: 2,
Marker: true,
PayloadType: 96,
SequenceNumber: 1123 + uint16(i),
Timestamp: 45343 + 90000*uint32(i),
SSRC: 563423,
},
Payload: []byte{5},
})
require.NoError(t, err)
}
time.Sleep(500 * time.Millisecond)
files, err := os.ReadDir(filepath.Join(dir, "mystream"))
require.NoError(t, err)
require.Equal(t, 1, len(files))
tr := &http.Transport{}
defer tr.CloseIdleConnections()
hc := &http.Client{Transport: tr}
httpRequest(t, hc, http.MethodPatch, "http://localhost:9997/v3/config/paths/patch/all_others", map[string]any{
"record": false,
}, nil)
time.Sleep(500 * time.Millisecond)
httpRequest(t, hc, http.MethodPatch, "http://localhost:9997/v3/config/paths/patch/all_others", map[string]any{
"record": true,
}, nil)
time.Sleep(500 * time.Millisecond)
for i := 4; i < 8; i++ {
err = source.WritePacketRTP(media0, &rtp.Packet{
Header: rtp.Header{
Version: 2,
Marker: true,
PayloadType: 96,
SequenceNumber: 1123 + uint16(i),
Timestamp: 45343 + 90000*uint32(i),
SSRC: 563423,
},
Payload: []byte{5},
})
require.NoError(t, err)
}
time.Sleep(500 * time.Millisecond)
files, err = os.ReadDir(filepath.Join(dir, "mystream"))
require.NoError(t, err)
require.Equal(t, 2, len(files))
}
func TestPathFallback(t *testing.T) {
for _, ca := range []string{
"absolute",
"relative",
"source",
} {
t.Run(ca, func(t *testing.T) {
var cnf string
switch ca {
case "absolute":
cnf = "paths:\n" +
" path1:\n" +
" fallback: rtsp://localhost:8554/path2\n" +
" path2:\n"
case "relative":
cnf = "paths:\n" +
" path1:\n" +
" fallback: /path2\n" +
" path2:\n"
case "source":
cnf = "paths:\n" +
" path1:\n" +
" fallback: /path2\n" +
" source: rtsp://localhost:3333/nonexistent\n" +
" path2:\n"
}
p1, ok := newInstance(cnf)
require.Equal(t, true, ok)
defer p1.Close()
source := gortsplib.Client{}
err := source.StartRecording("rtsp://localhost:8554/path2",
&description.Session{Medias: []*description.Media{test.UniqueMediaH264()}})
require.NoError(t, err)
defer source.Close()
u, err := base.ParseURL("rtsp://localhost:8554/path1")
require.NoError(t, err)
dest := gortsplib.Client{
Scheme: u.Scheme,
Host: u.Host,
}
err = dest.Start()
require.NoError(t, err)
defer dest.Close()
desc, _, err := dest.Describe(u)
require.NoError(t, err)
require.Equal(t, 1, len(desc.Medias))
})
}
}
func TestPathResolveSource(t *testing.T) {
var strm *gortsplib.ServerStream
s := gortsplib.Server{
Handler: &testServer{
onDescribe: func(ctx *gortsplib.ServerHandlerOnDescribeCtx,
) (*base.Response, *gortsplib.ServerStream, error) {
require.Equal(t, "key=val", ctx.Query)
require.Equal(t, "/a", ctx.Path)
return &base.Response{
StatusCode: base.StatusOK,
}, strm, nil
},
onSetup: func(_ *gortsplib.ServerHandlerOnSetupCtx) (*base.Response, *gortsplib.ServerStream, error) {
return &base.Response{
StatusCode: base.StatusOK,
}, strm, nil
},
onPlay: func(_ *gortsplib.ServerHandlerOnPlayCtx) (*base.Response, error) {
return &base.Response{
StatusCode: base.StatusOK,
}, nil
},
},
RTSPAddress: "127.0.0.1:8555",
}
err := s.Start()
require.NoError(t, err)
defer s.Close()
strm = &gortsplib.ServerStream{
Server: &s,
Desc: &description.Session{Medias: []*description.Media{test.MediaH264}},
}
err = strm.Initialize()
require.NoError(t, err)
defer strm.Close()
p, ok := newInstance(
"paths:\n" +
" '~^test_(.+)$':\n" +
" source: rtsp://127.0.0.1:8555/$G1?$MTX_QUERY\n" +
" sourceOnDemand: yes\n" +
" 'all':\n")
require.Equal(t, true, ok)
defer p.Close()
u, err := base.ParseURL("rtsp://127.0.0.1:8554/test_a?key=val")
require.NoError(t, err)
reader := gortsplib.Client{
Scheme: u.Scheme,
Host: u.Host,
}
err = reader.Start()
require.NoError(t, err)
defer reader.Close()
_, _, err = reader.Describe(u)
require.NoError(t, err)
}
func TestPathOverridePublisher(t *testing.T) {
for _, ca := range []string{
"enabled",
"disabled",
} {
t.Run(ca, func(t *testing.T) {
cnf := "rtmp: no\n" +
"paths:\n" +
" all_others:\n"
if ca == "disabled" {
cnf += " overridePublisher: no\n"
}
p, ok := newInstance(cnf)
require.Equal(t, true, ok)
defer p.Close()
medi := test.UniqueMediaH264()
s1 := gortsplib.Client{}
err := s1.StartRecording("rtsp://localhost:8554/teststream",
&description.Session{Medias: []*description.Media{medi}})
require.NoError(t, err)
defer s1.Close()
s2 := gortsplib.Client{}
err = s2.StartRecording("rtsp://localhost:8554/teststream",
&description.Session{Medias: []*description.Media{medi}})
if ca == "enabled" {
require.NoError(t, err)
defer s2.Close()
} else {
require.Error(t, err)
}
frameRecv := make(chan struct{})
u, err := base.ParseURL("rtsp://localhost:8554/teststream")
require.NoError(t, err)
c := gortsplib.Client{
Scheme: u.Scheme,
Host: u.Host,
}
err = c.Start()
require.NoError(t, err)
defer c.Close()
desc, _, err := c.Describe(u)
require.NoError(t, err)
err = c.SetupAll(desc.BaseURL, desc.Medias)
require.NoError(t, err)
c.OnPacketRTP(desc.Medias[0], desc.Medias[0].Formats[0], func(pkt *rtp.Packet) {
if ca == "enabled" {
require.Equal(t, []byte{5, 15, 16, 17, 18}, pkt.Payload)
} else {
require.Equal(t, []byte{5, 11, 12, 13, 14}, pkt.Payload)
}
close(frameRecv)
})
_, err = c.Play(nil)
require.NoError(t, err)
if ca == "enabled" {
err = s1.Wait()
require.EqualError(t, err, "EOF")
err = s2.WritePacketRTP(medi, &rtp.Packet{
Header: rtp.Header{
Version: 0x02,
PayloadType: 96,
SequenceNumber: 57899,
Timestamp: 345234345,
SSRC: 978651231,
Marker: true,
},
Payload: []byte{5, 15, 16, 17, 18},
})
require.NoError(t, err)
} else {
err = s1.WritePacketRTP(medi, &rtp.Packet{
Header: rtp.Header{
Version: 0x02,
PayloadType: 96,
SequenceNumber: 57899,
Timestamp: 345234345,
SSRC: 978651231,
Marker: true,
},
Payload: []byte{5, 11, 12, 13, 14},
})
require.NoError(t, err)
}
<-frameRecv
})
}
}
================================================
FILE: internal/core/source_redirect.go
================================================
package core
import (
"github.com/bluenviron/mediamtx/internal/defs"
"github.com/bluenviron/mediamtx/internal/logger"
)
// sourceRedirect is a source that redirects to another one.
type sourceRedirect struct{}
func (*sourceRedirect) Log(logger.Level, string, ...any) {
}
// APISourceDescribe implements source.
func (*sourceRedirect) APISourceDescribe() *defs.APIPathSource {
return &defs.APIPathSource{
Type: defs.APIPathSourceTypeRedirect,
ID: "",
}
}
================================================
FILE: internal/core/test_on_demand/main.go
================================================
// This is used for testing purposes.
package main
import (
"os"
"os/signal"
"syscall"
"github.com/bluenviron/gortsplib/v5"
"github.com/bluenviron/gortsplib/v5/pkg/description"
"github.com/bluenviron/gortsplib/v5/pkg/format"
)
func main() {
if os.Getenv("MTX_QUERY") != "param=value" {
panic("unexpected MTX_QUERY")
}
if os.Getenv("G1") != "on" {
panic("unexpected G1")
}
medi := &description.Media{
Type: description.MediaTypeVideo,
Formats: []format.Format{&format.H264{
PayloadTyp: 96,
SPS: []byte{
0x67, 0x42, 0xc0, 0x28, 0xd9, 0x00, 0x78, 0x02,
0x27, 0xe5, 0x84, 0x00, 0x00, 0x03, 0x00, 0x04,
0x00, 0x00, 0x03, 0x00, 0xf0, 0x3c, 0x60, 0xc9, 0x20,
},
PPS: []byte{0x01, 0x02, 0x03, 0x04},
PacketizationMode: 1,
}},
}
source := gortsplib.Client{}
err := source.StartRecording(
"rtsp://localhost:"+os.Getenv("RTSP_PORT")+"/"+os.Getenv("MTX_PATH"),
&description.Session{Medias: []*description.Media{medi}})
if err != nil {
panic(err)
}
defer source.Close()
c := make(chan os.Signal, 1)
signal.Notify(c, syscall.SIGINT)
<-c
err = os.WriteFile(os.Getenv("ON_DEMAND"), []byte(""), 0o644)
if err != nil {
panic(err)
}
}
================================================
FILE: internal/core/upgrade.go
================================================
//go:build enable_upgrade
package core
import (
"archive/tar"
"archive/zip"
"bytes"
"compress/gzip"
"fmt"
"io"
"net/http"
"regexp"
"runtime"
"sort"
"github.com/Masterminds/semver/v3"
"github.com/go-git/go-git/v5"
"github.com/go-git/go-git/v5/config"
"github.com/go-git/go-git/v5/storage/memory"
"github.com/minio/selfupdate"
)
const (
gitRepo = "https://github.com/bluenviron/mediamtx"
downloadURL = "https://github.com/bluenviron/mediamtx/releases/download/%s/mediamtx_%s_%s_%s.%s"
executable = "mediamtx"
)
var (
tagsRegexp = regexp.MustCompile(`^refs/tags/(v1\.[0-9]+\.[0-9]+)$`)
currentRegexp = regexp.MustCompile(`^(v1\.[0-9]+\.[0-9]+)$`)
)
func latestRemoteVersion() (*semver.Version, error) {
rem := git.NewRemote(memory.NewStorage(), &config.RemoteConfig{
URLs: []string{gitRepo},
})
refs, err := rem.List(&git.ListOptions{})
if err != nil {
return nil, err
}
var versions []*semver.Version
for _, ref := range refs {
matches := tagsRegexp.FindStringSubmatch(ref.Name().String())
if matches != nil {
v, _ := semver.NewVersion(matches[1])
versions = append(versions, v)
}
}
if len(versions) == 0 {
return nil, fmt.Errorf("no versions found")
}
sort.Sort(sort.Reverse(semver.Collection(versions)))
return versions[0], nil
}
func extractExecutable(r io.Reader) ([]byte, error) {
gzReader, err := gzip.NewReader(r)
if err != nil {
return nil, err
}
defer gzReader.Close()
tarReader := tar.NewReader(gzReader)
for {
header, err := tarReader.Next()
if err == io.EOF {
return nil, fmt.Errorf("executable not found")
}
if err != nil {
return nil, err
}
if header.Name == executable {
buf, err := io.ReadAll(tarReader)
if err != nil {
return nil, err
}
return buf, nil
}
}
}
func extractExecutableWin(r io.Reader) ([]byte, error) {
data, err := io.ReadAll(r)
if err != nil {
return nil, err
}
zipReader, err := zip.NewReader(bytes.NewReader(data), int64(len(data)))
if err != nil {
return nil, err
}
for _, file := range zipReader.File {
if file.Name == executable+".exe" {
rc, err := file.Open()
if err != nil {
return nil, err
}
defer rc.Close()
buf, err := io.ReadAll(rc)
if err != nil {
return nil, err
}
return buf, nil
}
}
return nil, fmt.Errorf("executable not found")
}
func upgrade() error {
if !currentRegexp.MatchString(string(version)) {
return fmt.Errorf("current version (%v) is not official and cannot be upgraded", string(version))
}
fmt.Println("getting latest version...")
latest, err := latestRemoteVersion()
if err != nil {
return err
}
current, _ := semver.NewVersion(string(version))
if current.GreaterThanEqual(latest) {
fmt.Printf("current version (%v) is up to date\n", "v"+current.String())
return nil
}
fmt.Printf("downloading version %v...\n", "v"+latest.String())
var extension string
if runtime.GOOS == "windows" {
extension = "zip"
} else {
extension = "tar.gz"
}
ur := fmt.Sprintf(downloadURL, "v"+latest.String(), "v"+latest.String(), runtime.GOOS, getArch(), extension)
res, err := http.Get(ur)
if err != nil {
return err
}
defer res.Body.Close()
if res.StatusCode != http.StatusOK {
return fmt.Errorf("bad status code: %v", res.StatusCode)
}
var exe []byte
if runtime.GOOS == "windows" {
exe, err = extractExecutableWin(res.Body)
} else {
exe, err = extractExecutable(res.Body)
}
err = selfupdate.Apply(bytes.NewReader(exe), selfupdate.Options{})
if err != nil {
return err
}
fmt.Printf("MediaMTX upgraded successfully from %v to %v.\n", "v"+current.String(), "v"+latest.String())
return nil
}
================================================
FILE: internal/core/upgrade_disabled.go
================================================
//go:build !enable_upgrade
package core
import "fmt"
func upgrade() error {
return fmt.Errorf("upgrade command is not available")
}
================================================
FILE: internal/core/versiongetter/main.go
================================================
// Package main contains an utility to get the server version
package main
import (
"fmt"
"log"
"os"
"path/filepath"
"strconv"
"strings"
"github.com/go-git/go-billy/v5/osfs"
"github.com/go-git/go-git/v5"
"github.com/go-git/go-git/v5/plumbing"
"github.com/go-git/go-git/v5/plumbing/cache"
"github.com/go-git/go-git/v5/plumbing/object"
"github.com/go-git/go-git/v5/storage/filesystem"
)
// Golang version of git describe --tags
func gitDescribeTags(repo *git.Repository) (string, error) {
head, err := repo.Head()
if err != nil {
return "", fmt.Errorf("failed to get HEAD: %w", err)
}
tagIterator, err := repo.Tags()
if err != nil {
return "", fmt.Errorf("failed to get tags: %w", err)
}
defer tagIterator.Close()
tags := make(map[plumbing.Hash]*plumbing.Reference)
err = tagIterator.ForEach(func(t *plumbing.Reference) error {
if to, err2 := repo.TagObject(t.Hash()); err2 == nil {
tags[to.Target] = t
} else {
tags[t.Hash()] = t
}
return nil
})
if err != nil {
return "", fmt.Errorf("failed to iterate tags: %w", err)
}
cIter, err := repo.Log(&git.LogOptions{From: head.Hash()})
if err != nil {
return "", fmt.Errorf("failed to get log: %w", err)
}
i := 0
for {
var commit *object.Commit
commit, err = cIter.Next()
if err != nil {
return "", fmt.Errorf("failed to get next commit: %w", err)
}
if str, ok := tags[commit.Hash]; ok {
label := strings.TrimPrefix(string(str.Name()), "refs/tags/")
if i != 0 {
label += "-" + strconv.FormatInt(int64(i), 10) + "-" + head.Hash().String()[:8]
}
return label, nil
}
i++
}
}
func tagFromGit() error {
// [git.PlainOpen] uses a ChrootOS that limits filesystem access to the .git directory only.
//
// Unfortunately, this can cause issues with package build environments such as Arch Linux's,
// where .git/objects/info/alternates points to a directory outside of the .git directory.
//
// To work around this, specify an AlternatesFS that allows access to the entire filesystem.
dotGitAbs, _ := filepath.Abs("../../.git")
storerFs := osfs.New(dotGitAbs, osfs.WithBoundOS())
storer := filesystem.NewStorageWithOptions(storerFs, cache.NewObjectLRUDefault(), filesystem.Options{
AlternatesFS: osfs.New("/", osfs.WithBoundOS()),
})
workTreeAbs, _ := filepath.Abs("../../")
worktreeFs := osfs.New(workTreeAbs, osfs.WithBoundOS())
repo, err := git.Open(storer, worktreeFs)
if err != nil {
return fmt.Errorf("failed to open repository: %w", err)
}
version, err := gitDescribeTags(repo)
if err != nil {
return fmt.Errorf("failed to get version: %w", err)
}
wt, err := repo.Worktree()
if err != nil {
return fmt.Errorf("failed to get worktree: %w", err)
}
status, err := wt.Status()
if err != nil {
return fmt.Errorf("failed to get status: %w", err)
}
if !status.IsClean() {
version += "-dirty"
}
err = os.WriteFile("VERSION", []byte(version), 0o644)
if err != nil {
return fmt.Errorf("failed to write version file: %w", err)
}
log.Printf("ok (%s)", version)
return nil
}
func do() error {
log.Println("getting mediamtx version...")
err := tagFromGit()
if err != nil {
log.Println("WARN: cannot get tag from .git folder, using v0.0.0 as version")
err = os.WriteFile("VERSION", []byte("v0.0.0"), 0o644)
if err != nil {
return fmt.Errorf("failed to write version file: %w", err)
}
}
return nil
}
func main() {
err := do()
if err != nil {
log.Printf("ERR: %v", err)
os.Exit(1)
}
}
================================================
FILE: internal/counterdumper/dumper.go
================================================
// Package counterdumper contains a counter that that periodically invokes a callback if the counter is not zero.
package counterdumper
import (
"sync"
"time"
)
const (
callbackPeriod = 1 * time.Second
)
// Dumper is a counter that periodically invokes a callback if the counter is not zero.
type Dumper struct {
OnReport func(v uint64)
mutex sync.Mutex
counter uint64
absCounter uint64
terminate chan struct{}
done chan struct{}
}
// Start starts the counter.
func (c *Dumper) Start() {
c.terminate = make(chan struct{})
c.done = make(chan struct{})
go c.run()
}
// Stop stops the counter.
func (c *Dumper) Stop() {
close(c.terminate)
<-c.done
}
// Increase increases the counter value by 1.
func (c *Dumper) Increase() {
c.mutex.Lock()
defer c.mutex.Unlock()
c.counter++
c.absCounter++
}
// Add adds value to the counter.
func (c *Dumper) Add(v uint64) {
c.mutex.Lock()
defer c.mutex.Unlock()
c.counter += v
c.absCounter += v
}
// Get returns the counter value.
func (c *Dumper) Get() uint64 {
c.mutex.Lock()
defer c.mutex.Unlock()
return c.absCounter
}
func (c *Dumper) run() {
defer close(c.done)
t := time.NewTicker(callbackPeriod)
defer t.Stop()
for {
select {
case <-c.terminate:
return
case <-t.C:
c.mutex.Lock()
var v uint64
v, c.counter = c.counter, 0
c.mutex.Unlock()
if v != 0 {
c.OnReport(v)
}
}
}
}
================================================
FILE: internal/counterdumper/dumper_test.go
================================================
package counterdumper
import (
"testing"
"time"
"github.com/stretchr/testify/require"
)
func TestDumperReport(t *testing.T) {
done := make(chan struct{})
c := &Dumper{
OnReport: func(v uint64) {
require.Equal(t, uint64(3), v)
close(done)
},
}
c.Start()
defer c.Stop()
c.Add(2)
c.Increase()
select {
case <-done:
case <-time.After(2 * time.Second):
t.Errorf("should not happen")
}
}
func TestDumperDoNotReport(t *testing.T) {
c := &Dumper{
OnReport: func(_ uint64) {
t.Errorf("should not happen")
},
}
c.Start()
defer c.Stop()
<-time.After(2 * time.Second)
}
================================================
FILE: internal/defs/api.go
================================================
package defs
import (
"time"
"github.com/bluenviron/mediamtx/internal/conf"
)
// APIOKStatus is the status of a successful response.
type APIOKStatus string
// statuses.
const (
APIOKStatusOK APIOKStatus = "ok"
)
// APIErrorStatus is the status of an error response.
type APIErrorStatus string
// statuses.
const (
APIErrorStatusError APIErrorStatus = "error"
)
// APIOK is returned on success.
type APIOK struct {
Status APIOKStatus `json:"status"`
}
// APIError is a generic error.
type APIError struct {
Status APIErrorStatus `json:"status"`
Error string `json:"error"`
}
// APIInfo is a info response.
type APIInfo struct {
Version string `json:"version"`
Started time.Time `json:"started"`
}
// APIPathConfList is a list of path configurations.
type APIPathConfList struct {
ItemCount int `json:"itemCount"`
PageCount int `json:"pageCount"`
Items []conf.Path `json:"items"`
}
================================================
FILE: internal/defs/api_hls.go
================================================
package defs
import "time"
// APIHLSServer contains methods used by the API and Metrics server.
type APIHLSServer interface {
APIMuxersList() (*APIHLSMuxerList, error)
APIMuxersGet(string) (*APIHLSMuxer, error)
}
// APIHLSMuxer is an HLS muxer.
type APIHLSMuxer struct {
Path string `json:"path"`
Created time.Time `json:"created"`
LastRequest time.Time `json:"lastRequest"`
OutboundBytes uint64 `json:"outboundBytes"`
OutboundFramesDiscarded uint64 `json:"outboundFramesDiscarded"`
// deprecated
BytesSent uint64 `json:"bytesSent" deprecated:"true"`
}
// APIHLSMuxerList is a list of HLS muxers.
type APIHLSMuxerList struct {
ItemCount int `json:"itemCount"`
PageCount int `json:"pageCount"`
Items []APIHLSMuxer `json:"items"`
}
================================================
FILE: internal/defs/api_path.go
================================================
package defs
import (
"time"
)
// APIPathManager contains methods used by the API and Metrics server.
type APIPathManager interface {
APIPathsList() (*APIPathList, error)
APIPathsGet(string) (*APIPath, error)
}
// APIPathSourceType is the type of a path source.
type APIPathSourceType string
// source types.
const (
APIPathSourceTypeHLSSource APIPathSourceType = "hlsSource"
APIPathSourceTypeRedirect APIPathSourceType = "redirect"
APIPathSourceTypeRPICameraSource APIPathSourceType = "rpiCameraSource"
APIPathSourceTypeRTMPConn APIPathSourceType = "rtmpConn"
APIPathSourceTypeRTMPSConn APIPathSourceType = "rtmpsConn"
APIPathSourceTypeRTMPSource APIPathSourceType = "rtmpSource"
APIPathSourceTypeRTSPSession APIPathSourceType = "rtspSession"
APIPathSourceTypeRTSPSource APIPathSourceType = "rtspSource"
APIPathSourceTypeRTSPSSession APIPathSourceType = "rtspsSession"
APIPathSourceTypeSRTConn APIPathSourceType = "srtConn"
APIPathSourceTypeSRTSource APIPathSourceType = "srtSource"
APIPathSourceTypeMPEGTSSource APIPathSourceType = "mpegtsSource"
APIPathSourceTypeRTPSource APIPathSourceType = "rtpSource"
APIPathSourceTypeWebRTCSession APIPathSourceType = "webRTCSession"
APIPathSourceTypeWebRTCSource APIPathSourceType = "webRTCSource"
)
// APIPathSource is a source.
type APIPathSource struct {
Type APIPathSourceType `json:"type"`
ID string `json:"id"`
}
// APIPathReaderType is the type of a path reader.
type APIPathReaderType string
// reader types.
const (
APIPathReaderTypeHLSMuxer APIPathReaderType = "hlsMuxer"
APIPathReaderTypeRTMPConn APIPathReaderType = "rtmpConn"
APIPathReaderTypeRTMPSConn APIPathReaderType = "rtmpsConn"
APIPathReaderTypeRTSPConn APIPathReaderType = "rtspConn"
APIPathReaderTypeRPICameraSecondary APIPathReaderType = "rpiCameraSecondary"
APIPathReaderTypeRTSPSession APIPathReaderType = "rtspSession"
APIPathReaderTypeRTSPSConn APIPathReaderType = "rtspsConn"
APIPathReaderTypeRTSPSSession APIPathReaderType = "rtspsSession"
APIPathReaderTypeSRTConn APIPathReaderType = "srtConn"
APIPathReaderTypeWebRTCSession APIPathReaderType = "webRTCSession"
)
// APIPathReader is a reader.
type APIPathReader struct {
Type APIPathReaderType `json:"type"`
ID string `json:"id"`
}
// APIPath is a path.
type APIPath struct {
Name string `json:"name"`
ConfName string `json:"confName"`
Ready bool `json:"ready" deprecated:"true"`
ReadyTime *time.Time `json:"readyTime" deprecated:"true"`
Available bool `json:"available"`
AvailableTime *time.Time `json:"availableTime"`
Online bool `json:"online"`
OnlineTime *time.Time `json:"onlineTime"`
Source *APIPathSource `json:"source"`
Tracks []APIPathTrackCodec `json:"tracks" deprecated:"true"`
Tracks2 []APIPathTrack `json:"tracks2"`
Readers []APIPathReader `json:"readers"`
InboundBytes uint64 `json:"inboundBytes"`
OutboundBytes uint64 `json:"outboundBytes"`
InboundFramesInError uint64 `json:"inboundFramesInError"`
// deprecated
BytesReceived uint64 `json:"bytesReceived" deprecated:"true"`
BytesSent uint64 `json:"bytesSent" deprecated:"true"`
}
// APIPathList is a list of paths.
type APIPathList struct {
ItemCount int `json:"itemCount"`
PageCount int `json:"pageCount"`
Items []APIPath `json:"items"`
}
================================================
FILE: internal/defs/api_path_track.go
================================================
package defs
// APIPathTrack is a track.
type APIPathTrack struct {
Codec APIPathTrackCodec `json:"codec"`
CodecProps APIPathTrackCodecProps `json:"codecProps"`
}
================================================
FILE: internal/defs/api_path_track_codec.go
================================================
package defs
import (
"fmt"
"strconv"
"github.com/bluenviron/gortsplib/v5/pkg/description"
"github.com/bluenviron/gortsplib/v5/pkg/format"
codecsh264 "github.com/bluenviron/mediacommon/v2/pkg/codecs/h264"
codecsh265 "github.com/bluenviron/mediacommon/v2/pkg/codecs/h265"
)
// APIPathTrackCodec is a path track codec.
type APIPathTrackCodec string
// path track codecs.
const (
// video
APIPathTrackCodecAV1 APIPathTrackCodec = "AV1"
APIPathTrackCodecVP9 APIPathTrackCodec = "VP9"
APIPathTrackCodecVP8 APIPathTrackCodec = "VP8"
APIPathTrackCodecH265 APIPathTrackCodec = "H265"
APIPathTrackCodecH264 APIPathTrackCodec = "H264"
APIPathTrackCodecMPEG4Video APIPathTrackCodec = "MPEG-4 Video"
APIPathTrackCodecMPEG1Video APIPathTrackCodec = "MPEG-1 Video"
APIPathTrackCodecMJPEG APIPathTrackCodec = "MJPEG"
// audio
APIPathTrackCodecOpus APIPathTrackCodec = "Opus"
APIPathTrackCodecVorbis APIPathTrackCodec = "Vorbis"
APIPathTrackCodecMPEG4Audio APIPathTrackCodec = "MPEG-4 Audio"
APIPathTrackCodecMPEG4AudioLATM APIPathTrackCodec = "MPEG-4 Audio LATM"
APIPathTrackCodecMPEG1Audio APIPathTrackCodec = "MPEG-1 Audio"
APIPathTrackCodecAC3 APIPathTrackCodec = "AC3"
APIPathTrackCodecSpeex APIPathTrackCodec = "Speex"
APIPathTrackCodecG726 APIPathTrackCodec = "G726"
APIPathTrackCodecG722 APIPathTrackCodec = "G722"
APIPathTrackCodecG711 APIPathTrackCodec = "G711"
APIPathTrackCodecLPCM APIPathTrackCodec = "LPCM"
// other
APIPathTrackCodecMPEGTS APIPathTrackCodec = "MPEG-TS"
APIPathTrackCodecKLV APIPathTrackCodec = "KLV"
APIPathTrackCodecGeneric APIPathTrackCodec = "Generic"
)
func formatToCodec(forma format.Format) APIPathTrackCodec {
switch forma.(type) {
// video
case *format.AV1:
return APIPathTrackCodecAV1
case *format.VP9:
return APIPathTrackCodecVP9
case *format.VP8:
return APIPathTrackCodecVP8
case *format.H265:
return APIPathTrackCodecH265
case *format.H264:
return APIPathTrackCodecH264
case *format.MPEG4Video:
return APIPathTrackCodecMPEG4Video
case *format.MPEG1Video:
return APIPathTrackCodecMPEG1Video
case *format.MJPEG:
return APIPathTrackCodecMJPEG
// audio
case *format.Opus:
return APIPathTrackCodecOpus
case *format.Vorbis:
return APIPathTrackCodecVorbis
case *format.MPEG4Audio:
return APIPathTrackCodecMPEG4Audio
case *format.MPEG4AudioLATM:
return APIPathTrackCodecMPEG4AudioLATM
case *format.MPEG1Audio:
return APIPathTrackCodecMPEG1Audio
case *format.AC3:
return APIPathTrackCodecAC3
case *format.Speex:
return APIPathTrackCodecSpeex
case *format.G726:
return APIPathTrackCodecG726
case *format.G722:
return APIPathTrackCodecG722
case *format.G711:
return APIPathTrackCodecG711
case *format.LPCM:
return APIPathTrackCodecLPCM
// other
case *format.MPEGTS:
return APIPathTrackCodecMPEGTS
case *format.KLV:
return APIPathTrackCodecKLV
default:
return APIPathTrackCodecGeneric
}
}
func h264ProfileString(profileIdc uint8) string {
switch profileIdc {
case 66:
return "Baseline"
case 77:
return "Main"
case 88:
return "Extended"
case 100:
return "High"
case 110:
return "High 10"
case 122:
return "High 4:2:2"
case 244:
return "High 4:4:4 Predictive"
default:
return strconv.Itoa(int(profileIdc))
}
}
func h264LevelString(levelIdc uint8) string {
major := levelIdc / 10
minor := levelIdc % 10
if minor == 0 {
return fmt.Sprintf("%d", major)
}
return fmt.Sprintf("%d.%d", major, minor)
}
func h265ProfileString(profileIdc uint8) string {
switch profileIdc {
case 1:
return "Main"
case 2:
return "Main 10"
case 3:
return "Main Still Picture"
case 4:
return "Range Extensions"
case 5:
return "High Throughput"
case 6:
return "Multiview Main"
case 7:
return "Scalable Main"
case 8:
return "3D Main"
case 9:
return "Screen Content Coding Extensions"
case 10:
return "Scalable Range Extensions"
default:
return strconv.Itoa(int(profileIdc))
}
}
func h265LevelString(levelIdc uint8) string {
// H.265 level_idc = 30 * level, so 3.0 = 90, 4.0 = 120, 4.1 = 123
level := float64(levelIdc) / 30.0
// Check if it's a clean level like 3.0, 4.0
if levelIdc%30 == 0 {
return fmt.Sprintf("%.0f", level)
}
return fmt.Sprintf("%.1f", level)
}
// FormatsToCodecs returns codecs of given formats.
func FormatsToCodecs(formats []format.Format) []APIPathTrackCodec {
ret := make([]APIPathTrackCodec, len(formats))
for i, forma := range formats {
ret[i] = formatToCodec(forma)
}
return ret
}
func formatToTrack(forma format.Format) APIPathTrack {
return APIPathTrack{
Codec: formatToCodec(forma),
CodecProps: formatToTrackCodecProps(forma),
}
}
func formatToTrackCodecProps(forma format.Format) APIPathTrackCodecProps {
switch forma := forma.(type) {
case *format.AV1:
props := &APIPathTrackCodecPropsAV1{}
if forma.Profile != nil {
props.Profile = *forma.Profile
}
if forma.LevelIdx != nil {
props.Level = *forma.LevelIdx
}
if forma.Tier != nil {
props.Tier = *forma.Tier
}
return props
case *format.VP9:
props := &APIPathTrackCodecPropsVP9{}
if forma.ProfileID != nil {
props.Profile = *forma.ProfileID
}
return props
case *format.H265:
props := &APIPathTrackCodecPropsH265{}
_, sps, _ := forma.SafeParams()
if sps != nil {
var s codecsh265.SPS
if err := s.Unmarshal(sps); err == nil {
props.Width = s.Width()
props.Height = s.Height()
props.Profile = h265ProfileString(s.ProfileTierLevel.GeneralProfileIdc)
props.Level = h265LevelString(s.ProfileTierLevel.GeneralLevelIdc)
}
}
return props
case *format.H264:
props := &APIPathTrackCodecPropsH264{}
sps, _ := forma.SafeParams()
if sps != nil {
var s codecsh264.SPS
if err := s.Unmarshal(sps); err == nil {
props.Width = s.Width()
props.Height = s.Height()
props.Profile = h264ProfileString(s.ProfileIdc)
props.Level = h264LevelString(s.LevelIdc)
}
}
return props
case *format.Opus:
return &APIPathTrackCodecPropsOpus{
ChannelCount: forma.ChannelCount,
}
case *format.MPEG4Audio:
props := &APIPathTrackCodecPropsMPEG4Audio{}
if forma.Config != nil {
props.SampleRate = forma.Config.SampleRate
props.ChannelCount = int(forma.Config.ChannelConfig)
}
return props
case *format.AC3:
return &APIPathTrackCodecPropsAC3{
SampleRate: forma.SampleRate,
ChannelCount: forma.ChannelCount,
}
case *format.G711:
return &APIPathTrackCodecPropsG711{
MULaw: forma.MULaw,
SampleRate: forma.SampleRate,
ChannelCount: forma.ChannelCount,
}
case *format.LPCM:
return &APIPathTrackCodecPropsLPCM{
BitDepth: forma.BitDepth,
SampleRate: forma.SampleRate,
ChannelCount: forma.ChannelCount,
}
default:
return nil
}
}
func gatherFormats(medias []*description.Media) []format.Format {
n := 0
for _, media := range medias {
n += len(media.Formats)
}
if n == 0 {
return nil
}
formats := make([]format.Format, n)
n = 0
for _, media := range medias {
n += copy(formats[n:], media.Formats)
}
return formats
}
// MediasToCodecs returns codecs of given medias.
func MediasToCodecs(medias []*description.Media) []APIPathTrackCodec {
return FormatsToCodecs(gatherFormats(medias))
}
// FormatsToTracks returns tracks of given formats.
func FormatsToTracks(formats []format.Format) []APIPathTrack {
ret := make([]APIPathTrack, len(formats))
for i, forma := range formats {
ret[i] = formatToTrack(forma)
}
return ret
}
// MediasToTracks returns tracks of given medias.
func MediasToTracks(medias []*description.Media) []APIPathTrack {
return FormatsToTracks(gatherFormats(medias))
}
================================================
FILE: internal/defs/api_path_track_codec_props.go
================================================
package defs
// APIPathTrackCodecProps contains codec-specific properties.
type APIPathTrackCodecProps interface {
apiPathTrackCodecProps()
}
// APIPathTrackCodecPropsAV1 contains codec-specific properties of AV1.
type APIPathTrackCodecPropsAV1 struct {
Width int `json:"width"`
Height int `json:"height"`
Profile int `json:"profile"`
Level int `json:"level"`
Tier int `json:"tier"`
}
func (*APIPathTrackCodecPropsAV1) apiPathTrackCodecProps() {}
// APIPathTrackCodecPropsVP9 contains codec-specific properties of VP9.
type APIPathTrackCodecPropsVP9 struct {
Profile int `json:"profile"`
}
func (*APIPathTrackCodecPropsVP9) apiPathTrackCodecProps() {}
// APIPathTrackCodecPropsH265 contains codec-specific properties of H265.
type APIPathTrackCodecPropsH265 struct {
Width int `json:"width"`
Height int `json:"height"`
Profile string `json:"profile"`
Level string `json:"level"`
}
func (*APIPathTrackCodecPropsH265) apiPathTrackCodecProps() {}
// APIPathTrackCodecPropsH264 contains codec-specific properties of H264.
type APIPathTrackCodecPropsH264 struct {
Width int `json:"width"`
Height int `json:"height"`
Profile string `json:"profile"`
Level string `json:"level"`
}
func (*APIPathTrackCodecPropsH264) apiPathTrackCodecProps() {}
// APIPathTrackCodecPropsOpus contains codec-specific properties of Opus.
type APIPathTrackCodecPropsOpus struct {
ChannelCount int `json:"channelCount"`
}
func (*APIPathTrackCodecPropsOpus) apiPathTrackCodecProps() {}
// APIPathTrackCodecPropsMPEG4Audio contains codec-specific properties of MPEG4Audio.
type APIPathTrackCodecPropsMPEG4Audio struct {
SampleRate int `json:"sampleRate"`
ChannelCount int `json:"channelCount"`
}
func (*APIPathTrackCodecPropsMPEG4Audio) apiPathTrackCodecProps() {}
// APIPathTrackCodecPropsAC3 contains codec-specific properties of AC3.
type APIPathTrackCodecPropsAC3 struct {
SampleRate int `json:"sampleRate"`
ChannelCount int `json:"channelCount"`
}
func (*APIPathTrackCodecPropsAC3) apiPathTrackCodecProps() {}
// APIPathTrackCodecPropsG711 contains codec-specific properties of G711.
type APIPathTrackCodecPropsG711 struct {
MULaw bool `json:"muLaw"`
SampleRate int `json:"sampleRate"`
ChannelCount int `json:"channelCount"`
}
func (*APIPathTrackCodecPropsG711) apiPathTrackCodecProps() {}
// APIPathTrackCodecPropsLPCM contains codec-specific properties of LPCM.
type APIPathTrackCodecPropsLPCM struct {
BitDepth int `json:"bitDepth"`
SampleRate int `json:"sampleRate"`
ChannelCount int `json:"channelCount"`
}
func (*APIPathTrackCodecPropsLPCM) apiPathTrackCodecProps() {}
================================================
FILE: internal/defs/api_path_track_codec_test.go
================================================
package defs
import (
"testing"
"github.com/bluenviron/gortsplib/v5/pkg/description"
"github.com/bluenviron/gortsplib/v5/pkg/format"
"github.com/bluenviron/mediacommon/v2/pkg/codecs/mpeg4audio"
"github.com/stretchr/testify/require"
)
func ptr[T any](v T) *T {
return &v
}
func testFormatH264() *format.H264 {
return &format.H264{
PayloadTyp: 96,
SPS: []byte{
0x67, 0x42, 0xc0, 0x28, 0xd9, 0x00, 0x78, 0x02,
0x27, 0xe5, 0x84, 0x00, 0x00, 0x03, 0x00, 0x04,
0x00, 0x00, 0x03, 0x00, 0xf0, 0x3c, 0x60, 0xc9, 0x20,
},
PPS: []byte{0x08, 0x06, 0x07, 0x08},
PacketizationMode: 1,
}
}
func testFormatMPEG4Audio() *format.MPEG4Audio {
return &format.MPEG4Audio{
PayloadTyp: 96,
Config: &mpeg4audio.AudioSpecificConfig{
Type: 2,
SampleRate: 44100,
ChannelCount: 2,
ChannelConfig: 2,
},
SizeLength: 13,
IndexLength: 3,
IndexDeltaLength: 3,
}
}
func testFormatH265() *format.H265 {
return &format.H265{
PayloadTyp: 96,
VPS: []byte{
0x40, 0x01, 0x0c, 0x01, 0xff, 0xff, 0x02, 0x20,
0x00, 0x00, 0x03, 0x00, 0xb0, 0x00, 0x00, 0x03,
0x00, 0x00, 0x03, 0x00, 0x7b, 0x18, 0xb0, 0x24,
},
SPS: []byte{
0x42, 0x01, 0x01, 0x02, 0x20, 0x00, 0x00, 0x03,
0x00, 0xb0, 0x00, 0x00, 0x03, 0x00, 0x00, 0x03,
0x00, 0x7b, 0xa0, 0x07, 0x82, 0x00, 0x88, 0x7d,
0xb6, 0x71, 0x8b, 0x92, 0x44, 0x80, 0x53, 0x88,
0x88, 0x92, 0xcf, 0x24, 0xa6, 0x92, 0x72, 0xc9,
0x12, 0x49, 0x22, 0xdc, 0x91, 0xaa, 0x48, 0xfc,
0xa2, 0x23, 0xff, 0x00, 0x01, 0x00, 0x01, 0x6a,
0x02, 0x02, 0x02, 0x01,
},
PPS: []byte{
0x44, 0x01, 0xc0, 0x25, 0x2f, 0x05, 0x32, 0x40,
},
}
}
func TestFormatsToCodecs(t *testing.T) {
codecs := FormatsToCodecs([]format.Format{
&format.AV1{},
&format.VP9{},
&format.VP8{},
&format.H265{},
&format.H264{},
&format.MPEG4Video{},
&format.MPEG1Video{},
&format.MJPEG{},
&format.Opus{},
&format.Vorbis{},
&format.MPEG4Audio{},
&format.MPEG4AudioLATM{},
&format.MPEG1Audio{},
&format.AC3{},
&format.Speex{},
&format.G726{},
&format.G722{},
&format.G711{},
&format.LPCM{},
&format.MPEGTS{},
&format.KLV{},
&format.Generic{},
})
require.Equal(t, []APIPathTrackCodec{
APIPathTrackCodecAV1,
APIPathTrackCodecVP9,
APIPathTrackCodecVP8,
APIPathTrackCodecH265,
APIPathTrackCodecH264,
APIPathTrackCodecMPEG4Video,
APIPathTrackCodecMPEG1Video,
APIPathTrackCodecMJPEG,
APIPathTrackCodecOpus,
APIPathTrackCodecVorbis,
APIPathTrackCodecMPEG4Audio,
APIPathTrackCodecMPEG4AudioLATM,
APIPathTrackCodecMPEG1Audio,
APIPathTrackCodecAC3,
APIPathTrackCodecSpeex,
APIPathTrackCodecG726,
APIPathTrackCodecG722,
APIPathTrackCodecG711,
APIPathTrackCodecLPCM,
APIPathTrackCodecMPEGTS,
APIPathTrackCodecKLV,
APIPathTrackCodecGeneric,
}, codecs)
}
func TestMediasToTracks(t *testing.T) {
tracks := MediasToTracks([]*description.Media{
{Formats: []format.Format{testFormatH264()}},
{Formats: []format.Format{testFormatH265()}},
{
Formats: []format.Format{
&format.AV1{Profile: ptr(1), LevelIdx: ptr(9), Tier: ptr(0)},
&format.VP9{ProfileID: ptr(2)},
&format.MJPEG{},
&format.Opus{ChannelCount: 2},
&format.G711{MULaw: true, SampleRate: 8000, ChannelCount: 1},
&format.LPCM{BitDepth: 16, SampleRate: 48000, ChannelCount: 2},
},
},
{
Formats: []format.Format{testFormatMPEG4Audio()},
},
})
require.Equal(t, []APIPathTrack{
{
Codec: APIPathTrackCodecH264,
CodecProps: &APIPathTrackCodecPropsH264{
Width: 1920,
Height: 1080,
Profile: "Baseline",
Level: "4",
},
},
{
Codec: APIPathTrackCodecH265,
CodecProps: &APIPathTrackCodecPropsH265{
Width: 960,
Height: 540,
Profile: "Main 10",
Level: "4.1",
},
},
{
Codec: APIPathTrackCodecAV1,
CodecProps: &APIPathTrackCodecPropsAV1{
Profile: 1,
Level: 9,
Tier: 0,
},
},
{
Codec: APIPathTrackCodecVP9,
CodecProps: &APIPathTrackCodecPropsVP9{
Profile: 2,
},
},
{
Codec: APIPathTrackCodecMJPEG,
CodecProps: nil,
},
{
Codec: APIPathTrackCodecOpus,
CodecProps: &APIPathTrackCodecPropsOpus{
ChannelCount: 2,
},
},
{
Codec: APIPathTrackCodecG711,
CodecProps: &APIPathTrackCodecPropsG711{
MULaw: true,
SampleRate: 8000,
ChannelCount: 1,
},
},
{
Codec: APIPathTrackCodecLPCM,
CodecProps: &APIPathTrackCodecPropsLPCM{
BitDepth: 16,
SampleRate: 48000,
ChannelCount: 2,
},
},
{
Codec: APIPathTrackCodecMPEG4Audio,
CodecProps: &APIPathTrackCodecPropsMPEG4Audio{
SampleRate: 44100,
ChannelCount: 2,
},
},
}, tracks)
}
================================================
FILE: internal/defs/api_recording.go
================================================
package defs
import "time"
// APIRecordingSegment is a recording segment.
type APIRecordingSegment struct {
Start time.Time `json:"start"`
}
// APIRecording is a recording.
type APIRecording struct {
Name string `json:"name"`
Segments []APIRecordingSegment `json:"segments"`
}
// APIRecordingList is a list of recordings.
type APIRecordingList struct {
ItemCount int `json:"itemCount"`
PageCount int `json:"pageCount"`
Items []APIRecording `json:"items"`
}
================================================
FILE: internal/defs/api_rtmp.go
================================================
package defs
import (
"time"
"github.com/google/uuid"
)
// APIRTMPServer contains methods used by the API and Metrics server.
type APIRTMPServer interface {
APIConnsList() (*APIRTMPConnList, error)
APIConnsGet(uuid.UUID) (*APIRTMPConn, error)
APIConnsKick(uuid.UUID) error
}
// APIRTMPConnState is the state of a RTMP connection.
type APIRTMPConnState string
// states.
const (
APIRTMPConnStateIdle APIRTMPConnState = "idle"
APIRTMPConnStateRead APIRTMPConnState = "read"
APIRTMPConnStatePublish APIRTMPConnState = "publish"
)
// APIRTMPConn is a RTMP connection.
type APIRTMPConn struct {
ID uuid.UUID `json:"id"`
Created time.Time `json:"created"`
RemoteAddr string `json:"remoteAddr"`
State APIRTMPConnState `json:"state"`
Path string `json:"path"`
Query string `json:"query"`
User string `json:"user"`
InboundBytes uint64 `json:"inboundBytes"`
OutboundBytes uint64 `json:"outboundBytes"`
OutboundFramesDiscarded uint64 `json:"outboundFramesDiscarded"`
// deprecated
BytesReceived uint64 `json:"bytesReceived" deprecated:"true"`
BytesSent uint64 `json:"bytesSent" deprecated:"true"`
}
// APIRTMPConnList is a list of RTMP connections.
type APIRTMPConnList struct {
ItemCount int `json:"itemCount"`
PageCount int `json:"pageCount"`
Items []APIRTMPConn `json:"items"`
}
================================================
FILE: internal/defs/api_rtsp.go
================================================
package defs
import (
"time"
"github.com/google/uuid"
)
// APIRTSPServer contains methods used by the API and Metrics server.
type APIRTSPServer interface {
APIConnsList() (*APIRTSPConnsList, error)
APIConnsGet(uuid.UUID) (*APIRTSPConn, error)
APISessionsList() (*APIRTSPSessionList, error)
APISessionsGet(uuid.UUID) (*APIRTSPSession, error)
APISessionsKick(uuid.UUID) error
}
// APIRTSPConn is a RTSP connection.
type APIRTSPConn struct {
ID uuid.UUID `json:"id"`
Created time.Time `json:"created"`
RemoteAddr string `json:"remoteAddr"`
Session *uuid.UUID `json:"session"`
Tunnel string `json:"tunnel"`
InboundBytes uint64 `json:"inboundBytes"`
OutboundBytes uint64 `json:"outboundBytes"`
BytesReceived uint64 `json:"bytesReceived" deprecated:"true"`
BytesSent uint64 `json:"bytesSent" deprecated:"true"`
}
// APIRTSPConnsList is a list of RTSP connections.
type APIRTSPConnsList struct {
ItemCount int `json:"itemCount"`
PageCount int `json:"pageCount"`
Items []APIRTSPConn `json:"items"`
}
// APIRTSPSessionState is the state of a RTSP session.
type APIRTSPSessionState string
// states.
const (
APIRTSPSessionStateIdle APIRTSPSessionState = "idle"
APIRTSPSessionStateRead APIRTSPSessionState = "read"
APIRTSPSessionStatePublish APIRTSPSessionState = "publish"
)
// APIRTSPSession is a RTSP session.
type APIRTSPSession struct {
ID uuid.UUID `json:"id"`
Created time.Time `json:"created"`
RemoteAddr string `json:"remoteAddr"`
State APIRTSPSessionState `json:"state"`
Path string `json:"path"`
Query string `json:"query"`
User string `json:"user"`
Transport *string `json:"transport"`
Profile *string `json:"profile"`
Conns []uuid.UUID `json:"conns"`
InboundBytes uint64 `json:"inboundBytes"`
InboundRTPPackets uint64 `json:"inboundRTPPackets"`
InboundRTPPacketsLost uint64 `json:"inboundRTPPacketsLost"`
InboundRTPPacketsInError uint64 `json:"inboundRTPPacketsInError"`
InboundRTPPacketsJitter float64 `json:"inboundRTPPacketsJitter"`
InboundRTCPPackets uint64 `json:"inboundRTCPPackets"`
InboundRTCPPacketsInError uint64 `json:"inboundRTCPPacketsInError"`
OutboundBytes uint64 `json:"outboundBytes"`
OutboundRTPPackets uint64 `json:"outboundRTPPackets"`
OutboundRTPPacketsReportedLost uint64 `json:"outboundRTPPacketsReportedLost"`
OutboundRTPPacketsDiscarded uint64 `json:"outboundRTPPacketsDiscarded"`
OutboundRTCPPackets uint64 `json:"outboundRTCPPackets"`
// deprecated
BytesReceived uint64 `json:"bytesReceived" deprecated:"true"`
BytesSent uint64 `json:"bytesSent" deprecated:"true"`
RTPPacketsReceived uint64 `json:"rtpPacketsReceived" deprecated:"true"`
RTPPacketsSent uint64 `json:"rtpPacketsSent" deprecated:"true"`
RTPPacketsLost uint64 `json:"rtpPacketsLost" deprecated:"true"`
RTPPacketsInError uint64 `json:"rtpPacketsInError" deprecated:"true"`
RTPPacketsJitter float64 `json:"rtpPacketsJitter" deprecated:"true"`
RTCPPacketsReceived uint64 `json:"rtcpPacketsReceived" deprecated:"true"`
RTCPPacketsSent uint64 `json:"rtcpPacketsSent" deprecated:"true"`
RTCPPacketsInError uint64 `json:"rtcpPacketsInError" deprecated:"true"`
}
// APIRTSPSessionList is a list of RTSP sessions.
type APIRTSPSessionList struct {
ItemCount int `json:"itemCount"`
PageCount int `json:"pageCount"`
Items []APIRTSPSession `json:"items"`
}
================================================
FILE: internal/defs/api_srt.go
================================================
package defs
import (
"time"
"github.com/google/uuid"
)
// APISRTServer contains methods used by the API and Metrics server.
type APISRTServer interface {
APIConnsList() (*APISRTConnList, error)
APIConnsGet(uuid.UUID) (*APISRTConn, error)
APIConnsKick(uuid.UUID) error
}
// APISRTConnState is the state of a SRT connection.
type APISRTConnState string
// states.
const (
APISRTConnStateIdle APISRTConnState = "idle"
APISRTConnStateRead APISRTConnState = "read"
APISRTConnStatePublish APISRTConnState = "publish"
)
// APISRTConn is a SRT connection.
type APISRTConn struct {
ID uuid.UUID `json:"id"`
Created time.Time `json:"created"`
RemoteAddr string `json:"remoteAddr"`
State APISRTConnState `json:"state"`
Path string `json:"path"`
Query string `json:"query"`
User string `json:"user"`
// The metric names/comments are pulled from GoSRT
// The total number of sent DATA packets, including retransmitted packets
PacketsSent uint64 `json:"packetsSent"`
// The total number of received DATA packets, including retransmitted packets
PacketsReceived uint64 `json:"packetsReceived"`
// The total number of unique DATA packets sent by the SRT sender
PacketsSentUnique uint64 `json:"packetsSentUnique"`
// The total number of unique original, retransmitted or recovered by the packet filter DATA packets
// received in time, decrypted without errors and, as a result, scheduled for delivery to the
// upstream application by the SRT receiver.
PacketsReceivedUnique uint64 `json:"packetsReceivedUnique"`
// The total number of data packets considered or reported as lost at the sender side.
// Does not correspond to the packets detected as lost at the receiver side.
PacketsSendLoss uint64 `json:"packetsSendLoss"`
// The total number of SRT DATA packets detected as presently missing (either reordered or lost) at the receiver side
PacketsReceivedLoss uint64 `json:"packetsReceivedLoss"`
// The total number of retransmitted packets sent by the SRT sender
PacketsRetrans uint64 `json:"packetsRetrans"`
// The total number of retransmitted packets registered at the receiver side
PacketsReceivedRetrans uint64 `json:"packetsReceivedRetrans"`
// The total number of sent ACK (Acknowledgement) control packets
PacketsSentACK uint64 `json:"packetsSentACK"`
// The total number of received ACK (Acknowledgement) control packets
PacketsReceivedACK uint64 `json:"packetsReceivedACK"`
// The total number of sent NAK (Negative Acknowledgement) control packets
PacketsSentNAK uint64 `json:"packetsSentNAK"`
// The total number of received NAK (Negative Acknowledgement) control packets
PacketsReceivedNAK uint64 `json:"packetsReceivedNAK"`
// The total number of sent KM (Key Material) control packets
PacketsSentKM uint64 `json:"packetsSentKM"`
// The total number of received KM (Key Material) control packets
PacketsReceivedKM uint64 `json:"packetsReceivedKM"`
// The total accumulated time in microseconds, during which the SRT sender has some data to transmit,
// including packets that have been sent, but not yet acknowledged
UsSndDuration uint64 `json:"usSndDuration"`
// ??
PacketsReceivedBelated uint64 `json:"packetsReceivedBelated"`
// The total number of dropped by the SRT sender DATA packets that have no chance to be delivered in time
PacketsSendDrop uint64 `json:"packetsSendDrop"`
// The total number of dropped by the SRT receiver and, as a result,
// not delivered to the upstream application DATA packets
PacketsReceivedDrop uint64 `json:"packetsReceivedDrop"`
// The total number of packets that failed to be decrypted at the receiver side
PacketsReceivedUndecrypt uint64 `json:"packetsReceivedUndecrypt"`
// Same as packetsReceived, but expressed in bytes, including payload and all the headers (IP, TCP, SRT)
BytesReceived uint64 `json:"bytesReceived"`
// Same as packetsSent, but expressed in bytes, including payload and all the headers (IP, TCP, SRT)
BytesSent uint64 `json:"bytesSent"`
// Same as packetsSentUnique, but expressed in bytes, including payload and all the headers (IP, TCP, SRT)
BytesSentUnique uint64 `json:"bytesSentUnique"`
// Same as packetsReceivedUnique, but expressed in bytes, including payload and all the headers (IP, TCP, SRT)
BytesReceivedUnique uint64 `json:"bytesReceivedUnique"`
// Same as packetsReceivedLoss, but expressed in bytes, including payload and all the headers (IP, TCP, SRT),
// bytes for the presently missing (either reordered or lost) packets' payloads are estimated
// based on the average packet size
BytesReceivedLoss uint64 `json:"bytesReceivedLoss"`
// Same as packetsRetrans, but expressed in bytes, including payload and all the headers (IP, TCP, SRT)
BytesRetrans uint64 `json:"bytesRetrans"`
// Same as packetsReceivedRetrans, but expressed in bytes, including payload and all the headers (IP, TCP, SRT)
BytesReceivedRetrans uint64 `json:"bytesReceivedRetrans"`
// Same as PacketsReceivedBelated, but expressed in bytes, including payload and all the headers (IP, TCP, SRT)
BytesReceivedBelated uint64 `json:"bytesReceivedBelated"`
// Same as packetsSendDrop, but expressed in bytes, including payload and all the headers (IP, TCP, SRT)
BytesSendDrop uint64 `json:"bytesSendDrop"`
// Same as packetsReceivedDrop, but expressed in bytes, including payload and all the headers (IP, TCP, SRT)
BytesReceivedDrop uint64 `json:"bytesReceivedDrop"`
// Same as packetsReceivedUndecrypt, but expressed in bytes, including payload and all the headers (IP, TCP, SRT)
BytesReceivedUndecrypt uint64 `json:"bytesReceivedUndecrypt"`
// Current minimum time interval between which consecutive packets are sent, in microseconds
UsPacketsSendPeriod float64 `json:"usPacketsSendPeriod"`
// The maximum number of packets that can be "in flight"
PacketsFlowWindow uint64 `json:"packetsFlowWindow"`
// The number of packets in flight
PacketsFlightSize uint64 `json:"packetsFlightSize"`
// Smoothed round-trip time (SRTT), an exponentially-weighted moving average (EWMA)
// of an endpoint's RTT samples, in milliseconds
MsRTT float64 `json:"msRTT"`
// Current transmission bandwidth, in Mbps
MbpsSendRate float64 `json:"mbpsSendRate"`
// Current receiving bandwidth, in Mbps
MbpsReceiveRate float64 `json:"mbpsReceiveRate"`
// Estimated capacity of the network link, in Mbps
MbpsLinkCapacity float64 `json:"mbpsLinkCapacity"`
// The available space in the sender's buffer, in bytes
BytesAvailSendBuf uint64 `json:"bytesAvailSendBuf"`
// The available space in the receiver's buffer, in bytes
BytesAvailReceiveBuf uint64 `json:"bytesAvailReceiveBuf"`
// Transmission bandwidth limit, in Mbps
MbpsMaxBW float64 `json:"mbpsMaxBW"`
// Maximum Segment Size (MSS), in bytes
ByteMSS uint64 `json:"byteMSS"`
// The number of packets in the sender's buffer that are already scheduled
// for sending or even possibly sent, but not yet acknowledged
PacketsSendBuf uint64 `json:"packetsSendBuf"`
// Instantaneous (current) value of packetsSndBuf, but expressed in bytes,
// including payload and all headers (IP, TCP, SRT)
BytesSendBuf uint64 `json:"bytesSendBuf"`
// The timespan (msec) of packets in the sender's buffer (unacknowledged packets)
MsSendBuf uint64 `json:"msSendBuf"`
// Timestamp-based Packet Delivery Delay value of the peer
MsSendTsbPdDelay uint64 `json:"msSendTsbPdDelay"`
// The number of acknowledged packets in receiver's buffer
PacketsReceiveBuf uint64 `json:"packetsReceiveBuf"`
// Instantaneous (current) value of packetsRcvBuf, expressed in bytes, including payload and all headers (IP, TCP, SRT)
BytesReceiveBuf uint64 `json:"bytesReceiveBuf"`
// The timespan (msec) of acknowledged packets in the receiver's buffer
MsReceiveBuf uint64 `json:"msReceiveBuf"`
// Timestamp-based Packet Delivery Delay value set on the socket via SRTO_RCVLATENCY or SRTO_LATENCY
MsReceiveTsbPdDelay uint64 `json:"msReceiveTsbPdDelay"`
// Instant value of the packet reorder tolerance
PacketsReorderTolerance uint64 `json:"packetsReorderTolerance"`
// Accumulated difference between the current time and the time-to-play of a packet that is received late
PacketsReceivedAvgBelatedTime uint64 `json:"packetsReceivedAvgBelatedTime"`
// Percentage of resent data vs. sent data
PacketsSendLossRate float64 `json:"packetsSendLossRate"`
// Percentage of retransmitted data vs. received data
PacketsReceivedLossRate float64 `json:"packetsReceivedLossRate"`
OutboundFramesDiscarded uint64 `json:"outboundFramesDiscarded"`
}
// APISRTConnList is a list of SRT connections.
type APISRTConnList struct {
ItemCount int `json:"itemCount"`
PageCount int `json:"pageCount"`
Items []APISRTConn `json:"items"`
}
================================================
FILE: internal/defs/api_webrtc.go
================================================
package defs
import (
"time"
"github.com/google/uuid"
)
// APIWebRTCServer contains methods used by the API and Metrics server.
type APIWebRTCServer interface {
APISessionsList() (*APIWebRTCSessionList, error)
APISessionsGet(uuid.UUID) (*APIWebRTCSession, error)
APISessionsKick(uuid.UUID) error
}
// APIWebRTCSessionState is the state of a WebRTC connection.
type APIWebRTCSessionState string
// states.
const (
APIWebRTCSessionStateRead APIWebRTCSessionState = "read"
APIWebRTCSessionStatePublish APIWebRTCSessionState = "publish"
)
// APIWebRTCSession is a WebRTC session.
type APIWebRTCSession struct {
ID uuid.UUID `json:"id"`
Created time.Time `json:"created"`
RemoteAddr string `json:"remoteAddr"`
PeerConnectionEstablished bool `json:"peerConnectionEstablished"`
LocalCandidate string `json:"localCandidate"`
RemoteCandidate string `json:"remoteCandidate"`
State APIWebRTCSessionState `json:"state"`
Path string `json:"path"`
Query string `json:"query"`
User string `json:"user"`
InboundBytes uint64 `json:"inboundBytes"`
InboundRTPPackets uint64 `json:"inboundRTPPackets"`
InboundRTPPacketsLost uint64 `json:"inboundRTPPacketsLost"`
InboundRTPPacketsJitter float64 `json:"inboundRTPPacketsJitter"`
InboundRTCPPackets uint64 `json:"inboundRTCPPackets"`
OutboundBytes uint64 `json:"outboundBytes"`
OutboundRTPPackets uint64 `json:"outboundRTPPackets"`
OutboundRTCPPackets uint64 `json:"outboundRTCPPackets"`
OutboundFramesDiscarded uint64 `json:"outboundFramesDiscarded"`
// deprecated
BytesReceived uint64 `json:"bytesReceived" deprecated:"true"`
BytesSent uint64 `json:"bytesSent" deprecated:"true"`
RTPPacketsReceived uint64 `json:"rtpPacketsReceived" deprecated:"true"`
RTPPacketsSent uint64 `json:"rtpPacketsSent" deprecated:"true"`
RTPPacketsLost uint64 `json:"rtpPacketsLost" deprecated:"true"`
RTPPacketsJitter float64 `json:"rtpPacketsJitter" deprecated:"true"`
RTCPPacketsReceived uint64 `json:"rtcpPacketsReceived" deprecated:"true"`
RTCPPacketsSent uint64 `json:"rtcpPacketsSent" deprecated:"true"`
}
// APIWebRTCSessionList is a list of WebRTC sessions.
type APIWebRTCSessionList struct {
ItemCount int `json:"itemCount"`
PageCount int `json:"pageCount"`
Items []APIWebRTCSession `json:"items"`
}
================================================
FILE: internal/defs/defs.go
================================================
// Package defs contains shared definitions.
package defs
================================================
FILE: internal/defs/path.go
================================================
package defs
import (
"fmt"
"github.com/bluenviron/gortsplib/v5/pkg/description"
"github.com/bluenviron/mediamtx/internal/conf"
"github.com/bluenviron/mediamtx/internal/externalcmd"
"github.com/bluenviron/mediamtx/internal/stream"
)
// PathNoStreamAvailableError is returned when no one is publishing.
type PathNoStreamAvailableError struct {
PathName string
}
// Error implements the error interface.
func (e PathNoStreamAvailableError) Error() string {
return fmt.Sprintf("no stream is available on path '%s'", e.PathName)
}
// Path is a path.
type Path interface {
Name() string
SafeConf() *conf.Path
ExternalCmdEnv() externalcmd.Environment
RemovePublisher(req PathRemovePublisherReq)
RemoveReader(req PathRemoveReaderReq)
}
// PathFindPathConfRes contains the response of FindPathConf().
type PathFindPathConfRes struct {
Conf *conf.Path
User string
Err error
}
// PathFindPathConfReq contains arguments of FindPathConf().
type PathFindPathConfReq struct {
AccessRequest PathAccessRequest
Res chan PathFindPathConfRes
}
// PathDescribeRes contains the response of Describe().
type PathDescribeRes struct {
Path Path
Stream *stream.Stream
Redirect string
Err error
}
// PathDescribeReq contains arguments of Describe().
type PathDescribeReq struct {
AccessRequest PathAccessRequest
Res chan PathDescribeRes
}
// PathAddPublisherRes contains the response of AddPublisher().
type PathAddPublisherRes struct {
Path Path
User string
SubStream *stream.SubStream
Err error
}
// PathAddPublisherReq contains arguments of AddPublisher().
type PathAddPublisherReq struct {
Author Publisher
Desc *description.Session
UseRTPPackets bool
ReplaceNTP bool
ConfToCompare *conf.Path
AccessRequest PathAccessRequest
Res chan PathAddPublisherRes
}
// PathRemovePublisherReq contains arguments of RemovePublisher().
type PathRemovePublisherReq struct {
Author Publisher
Res chan struct{}
}
// PathAddReaderRes contains the response of AddReader().
type PathAddReaderRes struct {
Path Path
User string
Stream *stream.Stream
Err error
}
// PathAddReaderReq contains arguments of AddReader().
type PathAddReaderReq struct {
Author Reader
AccessRequest PathAccessRequest
Res chan PathAddReaderRes
}
// PathRemoveReaderReq contains arguments of RemoveReader().
type PathRemoveReaderReq struct {
Author Reader
Res chan struct{}
}
// PathSourceStaticSetReadyRes contains the response of SetReady().
type PathSourceStaticSetReadyRes struct {
SubStream *stream.SubStream
Err error
}
// PathSourceStaticSetReadyReq contains arguments of SetReady().
type PathSourceStaticSetReadyReq struct {
Desc *description.Session
UseRTPPackets bool
ReplaceNTP bool
Res chan PathSourceStaticSetReadyRes
}
// PathSourceStaticSetNotReadyReq contains arguments of SetNotReady().
type PathSourceStaticSetNotReadyReq struct {
Res chan struct{}
}
================================================
FILE: internal/defs/path_access_request.go
================================================
package defs
import (
"net"
"github.com/bluenviron/mediamtx/internal/auth"
"github.com/bluenviron/mediamtx/internal/conf"
"github.com/google/uuid"
)
// PathAccessRequest is a path access request.
type PathAccessRequest struct {
Name string
Query string
Publish bool
SkipAuth bool
// only if skipAuth = false
Proto auth.Protocol
ID *uuid.UUID
Credentials *auth.Credentials
IP net.IP
CustomVerifyFunc func(expectedUser string, expectedPass string) bool
}
// ToAuthRequest converts a path access request into an authentication request.
func (r *PathAccessRequest) ToAuthRequest() *auth.Request {
return &auth.Request{
Action: func() conf.AuthAction {
if r.Publish {
return conf.AuthActionPublish
}
return conf.AuthActionRead
}(),
Path: r.Name,
Query: r.Query,
Protocol: r.Proto,
ID: r.ID,
Credentials: r.Credentials,
IP: r.IP,
CustomVerifyFunc: r.CustomVerifyFunc,
}
}
================================================
FILE: internal/defs/publisher.go
================================================
package defs
// Publisher is an entity that can publish a stream.
type Publisher interface {
Source
Close()
}
================================================
FILE: internal/defs/reader.go
================================================
package defs
// Reader is an entity that can read a stream.
type Reader interface {
Close()
APIReaderDescribe() *APIPathReader
}
================================================
FILE: internal/defs/source.go
================================================
package defs
import (
"fmt"
"strings"
"github.com/bluenviron/gortsplib/v5/pkg/description"
"github.com/bluenviron/gortsplib/v5/pkg/format"
"github.com/bluenviron/mediamtx/internal/logger"
)
// Source is an entity that can provide a stream.
// it can be:
// - Publisher
// - staticsources.Handler
// - core.sourceRedirect
type Source interface {
logger.Writer
APISourceDescribe() *APIPathSource
}
// FormatsInfo returns a description of formats.
func FormatsInfo(formats []format.Format) string {
codecs := FormatsToCodecs(formats)
codecNames := make([]string, len(codecs))
for i, codec := range codecs {
codecNames[i] = string(codec)
}
return fmt.Sprintf("%d %s (%s)",
len(formats),
func() string {
if len(formats) == 1 {
return "track"
}
return "tracks"
}(),
strings.Join(codecNames, ", "))
}
// MediasInfo returns a description of medias.
func MediasInfo(medias []*description.Media) string {
return FormatsInfo(gatherFormats(medias))
}
================================================
FILE: internal/defs/static_source.go
================================================
package defs
import (
"context"
"github.com/bluenviron/mediamtx/internal/conf"
)
// StaticSourceRunParams is the set of params passed to Run().
type StaticSourceRunParams struct {
Context context.Context
ResolvedSource string
Conf *conf.Path
ReloadConf chan *conf.Path
}
================================================
FILE: internal/errordumper/dumper.go
================================================
// Package errordumper contains a counter that that periodically invokes a callback if the counter is not zero.
package errordumper
import (
"sync"
"time"
)
const (
callbackPeriod = 1 * time.Second
)
// Dumper is a counter that periodically invokes a callback if errors were added.
type Dumper struct {
OnReport func(v uint64, last error)
mutex sync.Mutex
counter uint64
absCounter uint64
last error
terminate chan struct{}
done chan struct{}
}
// Start starts the counter.
func (c *Dumper) Start() {
c.terminate = make(chan struct{})
c.done = make(chan struct{})
go c.run()
}
// Stop stops the counter.
func (c *Dumper) Stop() {
close(c.terminate)
<-c.done
}
// Add adds an error to the counter.
func (c *Dumper) Add(err error) {
c.mutex.Lock()
defer c.mutex.Unlock()
c.counter++
c.absCounter++
c.last = err
}
// Get returns the total number of errors.
func (c *Dumper) Get() uint64 {
c.mutex.Lock()
defer c.mutex.Unlock()
return c.absCounter
}
func (c *Dumper) run() {
defer close(c.done)
t := time.NewTicker(callbackPeriod)
defer t.Stop()
for {
select {
case <-c.terminate:
return
case <-t.C:
c.mutex.Lock()
var counter uint64
counter, c.counter = c.counter, 0
last := c.last
c.mutex.Unlock()
if counter != 0 {
c.OnReport(counter, last)
}
}
}
}
================================================
FILE: internal/errordumper/dumper_test.go
================================================
package errordumper
import (
"fmt"
"testing"
"time"
"github.com/stretchr/testify/require"
)
func TestDumperReport(t *testing.T) {
done := make(chan struct{})
c := &Dumper{
OnReport: func(v uint64, last error) {
require.Equal(t, uint64(1), v)
require.EqualError(t, last, "test error")
close(done)
},
}
c.Start()
defer c.Stop()
c.Add(fmt.Errorf("test error"))
select {
case <-done:
case <-time.After(2 * time.Second):
t.Errorf("should not happen")
}
}
func TestDumperDoNotReport(t *testing.T) {
c := &Dumper{
OnReport: func(_ uint64, _ error) {
t.Errorf("should not happen")
},
}
c.Start()
defer c.Stop()
<-time.After(2 * time.Second)
}
================================================
FILE: internal/externalcmd/cmd.go
================================================
// Package externalcmd allows to launch external commands.
package externalcmd
import (
"errors"
"fmt"
"os"
"time"
)
const (
restartPause = 5 * time.Second
)
var errTerminated = errors.New("terminated")
// OnExitFunc is the prototype of onExit.
type OnExitFunc func(error)
// Environment is a Cmd environment.
type Environment map[string]string
// Cmd is an external command.
type Cmd struct {
pool *Pool
cmdstr string
restart bool
env Environment
onExit func(error)
// in
terminate chan struct{}
}
// NewCmd allocates a Cmd.
func NewCmd(
pool *Pool,
cmdstr string,
restart bool,
env Environment,
onExit OnExitFunc,
) *Cmd {
// replace variables in both Linux and Windows, in order to allow using the
// same commands on both of them.
cmdstr = os.Expand(cmdstr, func(variable string) string {
if value, ok := env[variable]; ok {
return value
}
return os.Getenv(variable)
})
if onExit == nil {
onExit = func(_ error) {}
}
e := &Cmd{
pool: pool,
cmdstr: cmdstr,
restart: restart,
env: env,
onExit: onExit,
terminate: make(chan struct{}),
}
pool.wg.Add(1)
go e.run()
return e
}
// Close closes the command. It doesn't wait for the command to exit.
func (e *Cmd) Close() {
close(e.terminate)
}
func (e *Cmd) run() {
defer e.pool.wg.Done()
env := append([]string(nil), os.Environ()...)
for key, val := range e.env {
env = append(env, key+"="+val)
}
for {
err := e.runOSSpecific(env)
if errors.Is(err, errTerminated) {
return
}
if !e.restart {
if err != nil {
e.onExit(err)
}
return
}
if err != nil {
e.onExit(err)
} else {
e.onExit(fmt.Errorf("command exited with code 0"))
}
select {
case <-time.After(restartPause):
case <-e.terminate:
return
}
}
}
================================================
FILE: internal/externalcmd/cmd_unix.go
================================================
//go:build !windows
package externalcmd
import (
"errors"
"fmt"
"os"
"os/exec"
"syscall"
"github.com/kballard/go-shellquote"
)
func (e *Cmd) runOSSpecific(env []string) error {
cmdParts, err := shellquote.Split(e.cmdstr)
if err != nil {
return err
}
cmd := exec.Command(cmdParts[0], cmdParts[1:]...)
cmd.Env = env
cmd.Stdout = os.Stdout
cmd.Stderr = os.Stderr
// set process group in order to allow killing subprocesses
cmd.SysProcAttr = &syscall.SysProcAttr{Setpgid: true}
err = cmd.Start()
if err != nil {
return err
}
cmdDone := make(chan int)
go func() {
cmdDone <- func() int {
err2 := cmd.Wait()
if err2 == nil {
return 0
}
var ee *exec.ExitError
if errors.As(err2, &ee) {
ee.ExitCode()
}
return 0
}()
}()
select {
case <-e.terminate:
// the minus is needed to kill all subprocesses
syscall.Kill(-cmd.Process.Pid, syscall.SIGINT) //nolint:errcheck
<-cmdDone
return errTerminated
case c := <-cmdDone:
if c != 0 {
return fmt.Errorf("command exited with code %d", c)
}
return nil
}
}
================================================
FILE: internal/externalcmd/cmd_win.go
================================================
//go:build windows
package externalcmd
import (
"fmt"
"os"
"os/exec"
"strings"
"syscall"
"unsafe"
"github.com/kballard/go-shellquote"
"golang.org/x/sys/windows"
)
// taken from
// https://gist.github.com/hallazzang/76f3970bfc949831808bbebc8ca15209
func createProcessGroup() (windows.Handle, error) {
h, err := windows.CreateJobObject(nil, nil)
if err != nil {
return 0, err
}
info := windows.JOBOBJECT_EXTENDED_LIMIT_INFORMATION{
BasicLimitInformation: windows.JOBOBJECT_BASIC_LIMIT_INFORMATION{
LimitFlags: windows.JOB_OBJECT_LIMIT_KILL_ON_JOB_CLOSE,
},
}
_, err = windows.SetInformationJobObject(
h,
windows.JobObjectExtendedLimitInformation,
uintptr(unsafe.Pointer(&info)),
uint32(unsafe.Sizeof(info)))
if err != nil {
return 0, err
}
return h, nil
}
func closeProcessGroup(h windows.Handle) error {
return windows.CloseHandle(h)
}
func addProcessToGroup(h windows.Handle, p *os.Process) error {
// Combine the required access rights
access := uint32(windows.PROCESS_SET_QUOTA | windows.PROCESS_TERMINATE)
processHandle, err := windows.OpenProcess(access, false, uint32(p.Pid))
if err != nil {
return fmt.Errorf("failed to open process: %v", err)
}
defer windows.CloseHandle(processHandle)
err = windows.AssignProcessToJobObject(h, processHandle)
if err != nil {
return fmt.Errorf("failed to assign process to job object: %v", err)
}
return nil
}
func (e *Cmd) runOSSpecific(env []string) error {
var cmd *exec.Cmd
// from Golang documentation:
// On Windows, processes receive the whole command line as a single string and do their own parsing.
// Command combines and quotes Args into a command line string with an algorithm compatible with
// applications using CommandLineToArgvW (which is the most common way). Notable exceptions are
// msiexec.exe and cmd.exe (and thus, all batch files), which have a different unquoting algorithm.
// In these or other similar cases, you can do the quoting yourself and provide the full command
// line in SysProcAttr.CmdLine, leaving Args empty.
if strings.HasPrefix(e.cmdstr, "cmd ") || strings.HasPrefix(e.cmdstr, "cmd.exe ") {
args := strings.TrimPrefix(strings.TrimPrefix(e.cmdstr, "cmd "), "cmd.exe ")
cmd = exec.Command("cmd.exe")
cmd.SysProcAttr = &syscall.SysProcAttr{
CmdLine: args,
}
} else {
cmdParts, err := shellquote.Split(e.cmdstr)
if err != nil {
return err
}
cmd = exec.Command(cmdParts[0], cmdParts[1:]...)
}
cmd.Env = env
cmd.Stdout = os.Stdout
cmd.Stderr = os.Stderr
// create a process group to kill all subprocesses
g, err := createProcessGroup()
if err != nil {
return err
}
err = cmd.Start()
if err != nil {
return err
}
err = addProcessToGroup(g, cmd.Process)
if err != nil {
return err
}
cmdDone := make(chan int)
go func() {
cmdDone <- func() int {
err := cmd.Wait()
if err == nil {
return 0
}
ee, ok := err.(*exec.ExitError)
if !ok {
return 0
}
return ee.ExitCode()
}()
}()
select {
case <-e.terminate:
closeProcessGroup(g)
<-cmdDone
return errTerminated
case c := <-cmdDone:
closeProcessGroup(g)
if c != 0 {
return fmt.Errorf("command exited with code %d", c)
}
return nil
}
}
================================================
FILE: internal/externalcmd/pool.go
================================================
package externalcmd
import (
"sync"
)
// Pool is a pool of external commands.
type Pool struct {
wg sync.WaitGroup
}
// Initialize initializes a Pool.
func (p *Pool) Initialize() {
}
// Close waits for all external commands to exit.
func (p *Pool) Close() {
p.wg.Wait()
}
================================================
FILE: internal/hooks/hooks.go
================================================
// Package hooks contains hook implementations.
package hooks
================================================
FILE: internal/hooks/on_connect.go
================================================
package hooks
import (
"net"
"github.com/bluenviron/mediamtx/internal/defs"
"github.com/bluenviron/mediamtx/internal/externalcmd"
"github.com/bluenviron/mediamtx/internal/logger"
)
// OnConnectParams are the parameters of OnConnect.
type OnConnectParams struct {
Logger logger.Writer
ExternalCmdPool *externalcmd.Pool
RunOnConnect string
RunOnConnectRestart bool
RunOnDisconnect string
RTSPAddress string
Desc defs.APIPathReader
}
// OnConnect is the OnConnect hook.
func OnConnect(params OnConnectParams) func() {
var env externalcmd.Environment
var onConnectCmd *externalcmd.Cmd
if params.RunOnConnect != "" || params.RunOnDisconnect != "" {
_, port, _ := net.SplitHostPort(params.RTSPAddress)
env = externalcmd.Environment{
"RTSP_PORT": port,
"MTX_CONN_TYPE": string(params.Desc.Type),
"MTX_CONN_ID": params.Desc.ID,
}
}
if params.RunOnConnect != "" {
params.Logger.Log(logger.Info, "runOnConnect command started")
onConnectCmd = externalcmd.NewCmd(
params.ExternalCmdPool,
params.RunOnConnect,
params.RunOnConnectRestart,
env,
func(err error) {
params.Logger.Log(logger.Info, "runOnConnect command exited: %v", err)
})
}
return func() {
if onConnectCmd != nil {
onConnectCmd.Close()
params.Logger.Log(logger.Info, "runOnConnect command stopped")
}
if params.RunOnDisconnect != "" {
params.Logger.Log(logger.Info, "runOnDisconnect command launched")
externalcmd.NewCmd(
params.ExternalCmdPool,
params.RunOnDisconnect,
false,
env,
nil)
}
}
}
================================================
FILE: internal/hooks/on_demand.go
================================================
package hooks
import (
"github.com/bluenviron/mediamtx/internal/conf"
"github.com/bluenviron/mediamtx/internal/externalcmd"
"github.com/bluenviron/mediamtx/internal/logger"
)
// OnDemandParams are the parameters of OnDemand.
type OnDemandParams struct {
Logger logger.Writer
ExternalCmdPool *externalcmd.Pool
Conf *conf.Path
ExternalCmdEnv externalcmd.Environment
Query string
}
// OnDemand is the OnDemand hook.
func OnDemand(params OnDemandParams) func(string) {
var env externalcmd.Environment
var onDemandCmd *externalcmd.Cmd
if params.Conf.RunOnDemand != "" || params.Conf.RunOnUnDemand != "" {
env = params.ExternalCmdEnv
env["MTX_QUERY"] = params.Query
}
if params.Conf.RunOnDemand != "" {
params.Logger.Log(logger.Info, "runOnDemand command started")
onDemandCmd = externalcmd.NewCmd(
params.ExternalCmdPool,
params.Conf.RunOnDemand,
params.Conf.RunOnDemandRestart,
env,
func(err error) {
params.Logger.Log(logger.Info, "runOnDemand command exited: %v", err)
})
}
return func(reason string) {
if onDemandCmd != nil {
onDemandCmd.Close()
params.Logger.Log(logger.Info, "runOnDemand command stopped: %v", reason)
}
if params.Conf.RunOnUnDemand != "" {
params.Logger.Log(logger.Info, "runOnUnDemand command launched")
externalcmd.NewCmd(
params.ExternalCmdPool,
params.Conf.RunOnUnDemand,
false,
env,
nil)
}
}
}
================================================
FILE: internal/hooks/on_init.go
================================================
package hooks
import (
"github.com/bluenviron/mediamtx/internal/conf"
"github.com/bluenviron/mediamtx/internal/externalcmd"
"github.com/bluenviron/mediamtx/internal/logger"
)
// OnInitParams are the parameters of OnInit.
type OnInitParams struct {
Logger logger.Writer
ExternalCmdPool *externalcmd.Pool
Conf *conf.Path
ExternalCmdEnv externalcmd.Environment
}
// OnInit is the OnInit hook.
func OnInit(params OnInitParams) func() {
var onInitCmd *externalcmd.Cmd
if params.Conf.RunOnInit != "" {
params.Logger.Log(logger.Info, "runOnInit command started")
onInitCmd = externalcmd.NewCmd(
params.ExternalCmdPool,
params.Conf.RunOnInit,
params.Conf.RunOnInitRestart,
params.ExternalCmdEnv,
func(err error) {
params.Logger.Log(logger.Info, "runOnInit command exited: %v", err)
})
}
return func() {
if onInitCmd != nil {
onInitCmd.Close()
params.Logger.Log(logger.Info, "runOnInit command stopped")
}
}
}
================================================
FILE: internal/hooks/on_read.go
================================================
package hooks
import (
"github.com/bluenviron/mediamtx/internal/conf"
"github.com/bluenviron/mediamtx/internal/defs"
"github.com/bluenviron/mediamtx/internal/externalcmd"
"github.com/bluenviron/mediamtx/internal/logger"
)
// OnReadParams are the parameters of OnRead.
type OnReadParams struct {
Logger logger.Writer
ExternalCmdPool *externalcmd.Pool
Conf *conf.Path
ExternalCmdEnv externalcmd.Environment
Reader defs.APIPathReader
Query string
}
// OnRead is the OnRead hook.
func OnRead(params OnReadParams) func() {
var env externalcmd.Environment
var onReadCmd *externalcmd.Cmd
if params.Conf.RunOnRead != "" || params.Conf.RunOnUnread != "" {
env = params.ExternalCmdEnv
desc := params.Reader
env["MTX_QUERY"] = params.Query
env["MTX_READER_TYPE"] = string(desc.Type)
env["MTX_READER_ID"] = desc.ID
}
if params.Conf.RunOnRead != "" {
params.Logger.Log(logger.Info, "runOnRead command started")
onReadCmd = externalcmd.NewCmd(
params.ExternalCmdPool,
params.Conf.RunOnRead,
params.Conf.RunOnReadRestart,
env,
func(err error) {
params.Logger.Log(logger.Info, "runOnRead command exited: %v", err)
})
}
return func() {
if onReadCmd != nil {
onReadCmd.Close()
params.Logger.Log(logger.Info, "runOnRead command stopped")
}
if params.Conf.RunOnUnread != "" {
params.Logger.Log(logger.Info, "runOnUnread command launched")
externalcmd.NewCmd(
params.ExternalCmdPool,
params.Conf.RunOnUnread,
false,
env,
nil)
}
}
}
================================================
FILE: internal/hooks/on_ready.go
================================================
package hooks
import (
"github.com/bluenviron/mediamtx/internal/conf"
"github.com/bluenviron/mediamtx/internal/defs"
"github.com/bluenviron/mediamtx/internal/externalcmd"
"github.com/bluenviron/mediamtx/internal/logger"
)
// OnReadyParams are the parameters of OnReady.
type OnReadyParams struct {
Logger logger.Writer
ExternalCmdPool *externalcmd.Pool
Conf *conf.Path
ExternalCmdEnv externalcmd.Environment
Desc *defs.APIPathSource
Query string
}
// OnReady is the OnReady hook.
func OnReady(params OnReadyParams) func() {
var env externalcmd.Environment
var onReadyCmd *externalcmd.Cmd
if params.Conf.RunOnReady != "" || params.Conf.RunOnNotReady != "" {
env = params.ExternalCmdEnv
env["MTX_QUERY"] = params.Query
if params.Desc != nil {
env["MTX_SOURCE_TYPE"] = string(params.Desc.Type)
env["MTX_SOURCE_ID"] = params.Desc.ID
}
}
if params.Conf.RunOnReady != "" {
params.Logger.Log(logger.Info, "runOnReady command started")
onReadyCmd = externalcmd.NewCmd(
params.ExternalCmdPool,
params.Conf.RunOnReady,
params.Conf.RunOnReadyRestart,
env,
func(err error) {
params.Logger.Log(logger.Info, "runOnReady command exited: %v", err)
})
}
return func() {
if onReadyCmd != nil {
onReadyCmd.Close()
params.Logger.Log(logger.Info, "runOnReady command stopped")
}
if params.Conf.RunOnNotReady != "" {
params.Logger.Log(logger.Info, "runOnNotReady command launched")
externalcmd.NewCmd(
params.ExternalCmdPool,
params.Conf.RunOnNotReady,
false,
env,
nil)
}
}
}
================================================
FILE: internal/linters/conf/conf_test.go
================================================
//go:build enable_linters
package conf
import (
"os"
"strings"
"testing"
"github.com/goccy/go-yaml/ast"
"github.com/goccy/go-yaml/parser"
"github.com/goccy/go-yaml/token"
"github.com/stretchr/testify/require"
)
func checkBooleans(t *testing.T, keys []string, node ast.Node) {
switch n := node.(type) {
case *ast.StringNode:
if n.Token.Type == token.StringType {
val := strings.ToLower(n.Token.Value)
if val == "yes" || val == "no" || val == "on" || val == "off" || val == "y" || val == "n" {
t.Errorf("deprecated bool value '%v: %v'", strings.Join(keys, "."), val)
}
}
case *ast.MappingNode:
for _, value := range n.Values {
checkBooleans(t, append(keys, value.Key.(*ast.StringNode).Token.Value), value.Value)
}
}
}
func TestConf(t *testing.T) {
buf, err := os.ReadFile("../../../mediamtx.yml")
require.NoError(t, err)
file, err := parser.ParseBytes(buf, 0)
require.NoError(t, err)
checkBooleans(t, nil, file.Docs[0].Body)
}
================================================
FILE: internal/linters/go2api/go2api_test.go
================================================
//go:build enable_linters
package main
import (
"os"
"reflect"
"strings"
"testing"
"time"
"github.com/bluenviron/mediamtx/internal/conf"
"github.com/bluenviron/mediamtx/internal/defs"
"github.com/goccy/go-yaml"
"github.com/google/uuid"
"github.com/stretchr/testify/require"
)
type openAPIProperty struct {
Ref string `yaml:"$ref"`
Type string `yaml:"type"`
Format string `yaml:"format"`
AllOf []openAPIProperty `yaml:"allOf"`
Nullable bool `yaml:"nullable"`
Deprecated bool `yaml:"deprecated"`
Enum []string `yaml:"enum"`
Items *openAPIProperty `yaml:"items"`
}
func wrapRef(rt reflect.Type, p openAPIProperty) openAPIProperty {
if p.Ref == "" {
return p
}
if _, ok := goEnumToApi(rt); ok {
p.Type = "string"
} else if rt.Kind() == reflect.Struct {
p.Type = "object"
}
p.AllOf = []openAPIProperty{{Ref: p.Ref}}
p.Ref = ""
return p
}
type openAPISchema struct {
Type string `yaml:"type"`
Enum []string `yaml:"enum"`
Properties map[string]openAPIProperty `yaml:"properties"`
}
type openAPI struct {
Components struct {
Schemas map[string]openAPISchema `yaml:"schemas"`
} `yaml:"components"`
}
func schemaName(rt reflect.Type) string {
name := strings.TrimPrefix(rt.Name(), "API")
if rt.PkgPath() == "github.com/bluenviron/mediamtx/internal/conf" && name == "Path" {
return "PathConf"
}
return name
}
func goStructToApi(t *testing.T, rt reflect.Type) openAPIProperty {
if rt.Kind() == reflect.Pointer {
prop := goStructToApi(t, rt.Elem())
prop = wrapRef(rt.Elem(), prop)
prop.Nullable = true
return prop
}
if _, ok := goEnumToApi(rt); ok {
return openAPIProperty{Ref: "#/components/schemas/" + schemaName(rt)}
}
if rt == reflect.TypeOf((*defs.APIPathTrackCodecProps)(nil)).Elem() {
return openAPIProperty{
Type: "object",
AllOf: []openAPIProperty{{Ref: "#/components/schemas/" + schemaName(rt)}},
Nullable: true,
}
}
switch {
case rt == reflect.TypeOf(""):
return openAPIProperty{Type: "string"}
case rt == reflect.TypeOf(int(0)):
return openAPIProperty{Type: "integer", Format: "int64"}
case rt == reflect.TypeOf(uint(0)):
return openAPIProperty{Type: "integer", Format: "uint64"}
case rt == reflect.TypeOf(uint64(0)):
return openAPIProperty{Type: "integer", Format: "uint64"}
case rt == reflect.TypeOf(float64(0)):
return openAPIProperty{Type: "number", Format: "double"}
case rt == reflect.TypeOf(false):
return openAPIProperty{Type: "boolean"}
case rt == reflect.TypeOf(uuid.UUID{}):
return openAPIProperty{Type: "string", Format: "uuid"}
case rt == reflect.TypeOf(time.Time{}) ||
rt == reflect.TypeOf(conf.Duration(0)) ||
rt == reflect.TypeOf(conf.IPNetwork{}) ||
rt == reflect.TypeOf(conf.Credential("")) ||
rt == reflect.TypeOf(conf.StringSize(0)):
return openAPIProperty{Type: "string"}
case rt == reflect.TypeOf(conf.RTSPTransports{}):
return openAPIProperty{
Type: "array",
Items: &openAPIProperty{
Type: "string",
Enum: []string{"udp", "multicast", "tcp"},
},
}
case rt.Kind() == reflect.Struct:
return openAPIProperty{
Ref: "#/components/schemas/" + schemaName(rt),
}
case rt.Kind() == reflect.Slice:
items := goStructToApi(t, rt.Elem())
return openAPIProperty{
Type: "array",
Items: &items,
}
default:
t.Errorf("unhandled type: %v", rt)
return openAPIProperty{}
}
}
func goEnumToApi(rt reflect.Type) (openAPISchema, bool) {
switch rt {
case reflect.TypeOf(defs.APIOKStatus("")):
return openAPISchema{Type: "string", Enum: []string{"ok"}}, true
case reflect.TypeOf(defs.APIErrorStatus("")):
return openAPISchema{Type: "string", Enum: []string{"error"}}, true
case reflect.TypeOf(defs.APIPathSourceType("")):
return openAPISchema{Type: "string", Enum: []string{
"hlsSource",
"redirect",
"rpiCameraSource",
"rtmpConn",
"rtmpsConn",
"rtmpSource",
"rtspSession",
"rtspSource",
"rtspsSession",
"srtConn",
"srtSource",
"mpegtsSource",
"rtpSource",
"webRTCSession",
"webRTCSource",
}}, true
case reflect.TypeOf(defs.APIPathReaderType("")):
return openAPISchema{Type: "string", Enum: []string{
"hlsMuxer",
"rpiCameraSecondary",
"rtmpConn",
"rtmpsConn",
"rtspConn",
"rtspSession",
"rtspsConn",
"rtspsSession",
"srtConn",
"webRTCSession",
}}, true
case reflect.TypeOf(defs.APIPathTrackCodec("")):
return openAPISchema{Type: "string", Enum: []string{
"AV1",
"VP9",
"VP8",
"H265",
"H264",
"MPEG-4 Video",
"MPEG-1 Video",
"MJPEG",
"Opus",
"Vorbis",
"MPEG-4 Audio",
"MPEG-4 Audio LATM",
"MPEG-1 Audio",
"AC3",
"Speex",
"G726",
"G722",
"G711",
"LPCM",
"MPEG-TS",
"KLV",
"Generic",
}}, true
case reflect.TypeOf(conf.AlwaysAvailableTrackCodec("")):
return openAPISchema{Type: "string", Enum: []string{
"AV1",
"VP9",
"H265",
"H264",
"MPEG4Audio",
"Opus",
"G711",
"LPCM",
}}, true
case reflect.TypeOf(conf.AuthAction("")):
return openAPISchema{Type: "string", Enum: []string{
"publish",
"read",
"playback",
"api",
"metrics",
"pprof",
}}, true
case reflect.TypeOf(conf.AuthMethod("")):
return openAPISchema{Type: "string", Enum: []string{
"internal",
"http",
"jwt",
}}, true
case reflect.TypeOf(conf.Encryption("")):
return openAPISchema{Type: "string", Enum: []string{
"no",
"optional",
"strict",
}}, true
case reflect.TypeOf(conf.HLSVariant(0)):
return openAPISchema{Type: "string", Enum: []string{
"mpegts",
"fmp4",
"lowLatency",
}}, true
case reflect.TypeOf(conf.LogDestination(0)):
return openAPISchema{Type: "string", Enum: []string{
"stdout",
"file",
"syslog",
}}, true
case reflect.TypeOf(conf.LogLevel(0)):
return openAPISchema{Type: "string", Enum: []string{
"error",
"warn",
"info",
"debug",
}}, true
case reflect.TypeOf(conf.RecordFormat("")):
return openAPISchema{Type: "string", Enum: []string{
"fmp4",
"mpegts",
}}, true
case reflect.TypeOf(conf.RTSPAuthMethod(0)):
return openAPISchema{Type: "string", Enum: []string{
"basic",
"digest",
}}, true
case reflect.TypeOf(conf.RTSPRangeType("")):
return openAPISchema{Type: "string", Enum: []string{
"",
"clock",
"npt",
"smpte",
}}, true
case reflect.TypeOf(conf.RTSPTransport{}):
return openAPISchema{Type: "string", Enum: []string{
"udp",
"multicast",
"tcp",
"automatic",
}}, true
case reflect.TypeOf(defs.APIRTMPConnState("")):
return openAPISchema{Type: "string", Enum: []string{"idle", "read", "publish"}}, true
case reflect.TypeOf(defs.APIWebRTCSessionState("")):
return openAPISchema{Type: "string", Enum: []string{"read", "publish"}}, true
case reflect.TypeOf(defs.APISRTConnState("")):
return openAPISchema{Type: "string", Enum: []string{"idle", "read", "publish"}}, true
case reflect.TypeOf(defs.APIRTSPSessionState("")):
return openAPISchema{Type: "string", Enum: []string{"idle", "read", "publish"}}, true
}
return openAPISchema{}, false
}
func TestGo2API(t *testing.T) {
byts, err := os.ReadFile("../../../api/openapi.yaml")
require.NoError(t, err)
var doc openAPI
err = yaml.Unmarshal(byts, &doc)
require.NoError(t, err)
t.Run("structs", func(t *testing.T) {
for _, ca := range []struct {
openAPIKey string
goStruct any
}{
{
"AlwaysAvailableTrack",
conf.AlwaysAvailableTrack{},
},
{
"AuthInternalUser",
conf.AuthInternalUser{},
},
{
"AuthInternalUserPermission",
conf.AuthInternalUserPermission{},
},
{
"GlobalConf",
conf.Conf{},
},
{
"HLSMuxer",
defs.APIHLSMuxer{},
},
{
"HLSMuxerList",
defs.APIHLSMuxerList{},
},
{
"Info",
defs.APIInfo{},
},
{
"Path",
defs.APIPath{},
},
{
"PathConf",
conf.Path{},
},
{
"PathConfList",
defs.APIPathConfList{},
},
{
"PathList",
defs.APIPathList{},
},
{
"PathReader",
defs.APIPathReader{},
},
{
"PathSource",
defs.APIPathSource{},
},
{
"PathTrack",
defs.APIPathTrack{},
},
{
"Recording",
defs.APIRecording{},
},
{
"RecordingList",
defs.APIRecordingList{},
},
{
"RecordingSegment",
defs.APIRecordingSegment{},
},
{
"RTMPConn",
defs.APIRTMPConn{},
},
{
"RTMPConnList",
defs.APIRTMPConnList{},
},
{
"RTSPConn",
defs.APIRTSPConn{},
},
{
"RTSPConnList",
defs.APIRTSPConnsList{},
},
{
"RTSPSession",
defs.APIRTSPSession{},
},
{
"RTSPSessionList",
defs.APIRTSPSessionList{},
},
{
"SRTConn",
defs.APISRTConn{},
},
{
"SRTConnList",
defs.APISRTConnList{},
},
{
"WebRTCSession",
defs.APIWebRTCSession{},
},
{
"WebRTCSessionList",
defs.APIWebRTCSessionList{},
},
} {
t.Run(ca.openAPIKey, func(t *testing.T) {
content1 := doc.Components.Schemas[ca.openAPIKey]
content2 := openAPISchema{
Type: "object",
Properties: make(map[string]openAPIProperty),
}
ty := reflect.TypeOf(ca.goStruct)
for i := range ty.NumField() {
sf := ty.Field(i)
js := sf.Tag.Get("json")
name, _, _ := strings.Cut(js, ",")
deprecated := sf.Tag.Get("deprecated") == "true"
if name != "" && name != "-" && name != "paths" && name != "pathDefaults" &&
(!strings.Contains(js, ",omitempty") || deprecated) {
prop := goStructToApi(t, sf.Type)
prop.Deprecated = deprecated
if deprecated {
prop = wrapRef(sf.Type, prop)
}
content2.Properties[name] = prop
}
}
require.Equal(t, content2, content1)
})
}
})
t.Run("enums", func(t *testing.T) {
for _, rt := range []reflect.Type{
reflect.TypeOf(defs.APIOKStatus("")),
reflect.TypeOf(defs.APIErrorStatus("")),
reflect.TypeOf(defs.APIPathSourceType("")),
reflect.TypeOf(defs.APIPathReaderType("")),
reflect.TypeOf(defs.APIPathTrackCodec("")),
reflect.TypeOf(conf.AlwaysAvailableTrackCodec("")),
reflect.TypeOf(conf.AuthAction("")),
reflect.TypeOf(conf.AuthMethod("")),
reflect.TypeOf(conf.Encryption("")),
reflect.TypeOf(conf.HLSVariant(0)),
reflect.TypeOf(conf.LogDestination(0)),
reflect.TypeOf(conf.LogLevel(0)),
reflect.TypeOf(conf.RecordFormat("")),
reflect.TypeOf(conf.RTSPAuthMethod(0)),
reflect.TypeOf(conf.RTSPRangeType("")),
reflect.TypeOf(conf.RTSPTransport{}),
reflect.TypeOf(defs.APIRTMPConnState("")),
reflect.TypeOf(defs.APIRTSPSessionState("")),
reflect.TypeOf(defs.APISRTConnState("")),
reflect.TypeOf(defs.APIWebRTCSessionState("")),
} {
t.Run(rt.Name(), func(t *testing.T) {
content1 := doc.Components.Schemas[schemaName(rt)]
content2, ok := goEnumToApi(rt)
require.True(t, ok)
require.Equal(t, content2, content1)
})
}
})
}
================================================
FILE: internal/logger/destination.go
================================================
package logger
import (
"time"
)
// Destination is a log destination.
type Destination int
const (
// DestinationStdout writes logs to the standard output.
DestinationStdout Destination = iota
// DestinationFile writes logs to a file.
DestinationFile
// DestinationSyslog writes logs to the system logger.
DestinationSyslog
)
type destination interface {
log(time.Time, Level, string, ...any)
close()
}
================================================
FILE: internal/logger/destination_file.go
================================================
package logger
import (
"bytes"
"fmt"
"os"
"strconv"
"time"
)
type destinationFile struct {
structured bool
file *os.File
buf bytes.Buffer
}
func newDestinationFile(structured bool, filePath string) (destination, error) {
f, err := os.OpenFile(filePath, os.O_APPEND|os.O_CREATE|os.O_WRONLY, 0o644)
if err != nil {
return nil, err
}
return &destinationFile{
structured: structured,
file: f,
}, nil
}
func (d *destinationFile) log(t time.Time, level Level, format string, args ...any) {
d.buf.Reset()
if d.structured {
d.buf.WriteString(`{"timestamp":"`)
d.buf.WriteString(t.Format(time.RFC3339Nano))
d.buf.WriteString(`","level":"`)
writeLevel(&d.buf, level, false)
d.buf.WriteString(`","message":`)
d.buf.WriteString(strconv.Quote(fmt.Sprintf(format, args...)))
d.buf.WriteString(`}`)
d.buf.WriteByte('\n')
} else {
writePlainTime(&d.buf, t, false)
writeLevel(&d.buf, level, false)
d.buf.WriteByte(' ')
fmt.Fprintf(&d.buf, format, args...)
d.buf.WriteByte('\n')
}
d.file.Write(d.buf.Bytes()) //nolint:errcheck
}
func (d *destinationFile) close() {
d.file.Close()
}
================================================
FILE: internal/logger/destination_stdout.go
================================================
package logger
import (
"bytes"
"fmt"
"io"
"os"
"strconv"
"time"
"golang.org/x/term"
)
type destinationStdout struct {
structured bool
stdout io.Writer
useColor bool
buf bytes.Buffer
}
func newDestionationStdout(structured bool, stdout io.Writer) destination {
return &destinationStdout{
structured: structured,
stdout: stdout,
useColor: term.IsTerminal(int(os.Stdout.Fd())),
}
}
func (d *destinationStdout) log(t time.Time, level Level, format string, args ...any) {
d.buf.Reset()
if d.structured {
d.buf.WriteString(`{"timestamp":"`)
d.buf.WriteString(t.Format(time.RFC3339Nano))
d.buf.WriteString(`","level":"`)
writeLevel(&d.buf, level, false)
d.buf.WriteString(`","message":`)
d.buf.WriteString(strconv.Quote(fmt.Sprintf(format, args...)))
d.buf.WriteString(`}`)
d.buf.WriteByte('\n')
} else {
writePlainTime(&d.buf, t, d.useColor)
writeLevel(&d.buf, level, d.useColor)
d.buf.WriteByte(' ')
fmt.Fprintf(&d.buf, format, args...)
d.buf.WriteByte('\n')
}
d.stdout.Write(d.buf.Bytes()) //nolint:errcheck
}
func (d *destinationStdout) close() {
}
================================================
FILE: internal/logger/destination_syslog.go
================================================
//go:build !darwin && !windows
package logger
import (
"bytes"
"fmt"
"log/syslog"
"time"
)
type destinationSysLog struct {
syslog *syslog.Writer
buf bytes.Buffer
}
func newDestinationSyslog(prefix string) (destination, error) {
syslog, err := syslog.New(syslog.LOG_DAEMON, prefix)
if err != nil {
return nil, err
}
return &destinationSysLog{
syslog: syslog,
}, nil
}
func (d *destinationSysLog) log(_ time.Time, level Level, format string, args ...any) {
d.buf.Reset()
fmt.Fprintf(&d.buf, format, args...)
switch level {
case Debug:
d.syslog.Debug(d.buf.String()) //nolint:errcheck
case Info:
d.syslog.Info(d.buf.String()) //nolint:errcheck
case Warn:
d.syslog.Warning(d.buf.String()) //nolint:errcheck
case Error:
d.syslog.Err(d.buf.String()) //nolint:errcheck
}
}
func (d *destinationSysLog) close() {
d.syslog.Close() //nolint:errcheck
}
================================================
FILE: internal/logger/destination_syslog_disabled.go
================================================
//go:build darwin || windows
package logger
import "fmt"
func newDestinationSyslog(_ string) (destination, error) {
return nil, fmt.Errorf("syslog is not available on macOS and Windows")
}
================================================
FILE: internal/logger/level.go
================================================
package logger
// Level is a log level.
type Level int
// Log levels.
const (
Debug Level = iota + 1
Info
Warn
Error
)
================================================
FILE: internal/logger/logger.go
================================================
// Package logger contains a logger implementation.
package logger
import (
"bytes"
"io"
"os"
"sync"
"time"
"github.com/gookit/color"
)
// Logger is a log handler.
type Logger struct {
Level Level
Destinations []Destination
Structured bool
File string
SysLogPrefix string
timeNow func() time.Time
stdout io.Writer
destinations []destination
mutex sync.Mutex
}
// Initialize initializes Logger.
func (l *Logger) Initialize() error {
if l.timeNow == nil {
l.timeNow = time.Now
}
if l.stdout == nil {
l.stdout = os.Stdout
}
for _, destType := range l.Destinations {
switch destType {
case DestinationStdout:
l.destinations = append(l.destinations, newDestionationStdout(l.Structured, l.stdout))
case DestinationFile:
dest, err := newDestinationFile(l.Structured, l.File)
if err != nil {
l.Close()
return err
}
l.destinations = append(l.destinations, dest)
case DestinationSyslog:
dest, err := newDestinationSyslog(l.SysLogPrefix)
if err != nil {
l.Close()
return err
}
l.destinations = append(l.destinations, dest)
}
}
return nil
}
// Close closes a log handler.
func (l *Logger) Close() {
for _, dest := range l.destinations {
dest.close()
}
}
// https://golang.org/src/log/log.go#L78
func itoa(i int, wid int) []byte {
// Assemble decimal in reverse order.
var b [20]byte
bp := len(b) - 1
for i >= 10 || wid > 1 {
wid--
q := i / 10
b[bp] = byte('0' + i - q*10)
bp--
i = q
}
// i < 10
b[bp] = byte('0' + i)
return b[bp:]
}
func writePlainTime(buf *bytes.Buffer, t time.Time, useColor bool) {
var intbuf bytes.Buffer
// date
year, month, day := t.Date()
intbuf.Write(itoa(year, 4))
intbuf.WriteByte('/')
intbuf.Write(itoa(int(month), 2))
intbuf.WriteByte('/')
intbuf.Write(itoa(day, 2))
intbuf.WriteByte(' ')
// time
hour, minute, sec := t.Clock()
intbuf.Write(itoa(hour, 2))
intbuf.WriteByte(':')
intbuf.Write(itoa(minute, 2))
intbuf.WriteByte(':')
intbuf.Write(itoa(sec, 2))
intbuf.WriteByte(' ')
if useColor {
buf.WriteString(color.RenderString(color.Gray.Code(), intbuf.String()))
} else {
buf.WriteString(intbuf.String())
}
}
func writeLevel(buf *bytes.Buffer, level Level, useColor bool) {
switch level {
case Debug:
if useColor {
buf.WriteString(color.RenderString(color.Debug.Code(), "DEB"))
} else {
buf.WriteString("DEB")
}
case Info:
if useColor {
buf.WriteString(color.RenderString(color.Green.Code(), "INF"))
} else {
buf.WriteString("INF")
}
case Warn:
if useColor {
buf.WriteString(color.RenderString(color.Warn.Code(), "WAR"))
} else {
buf.WriteString("WAR")
}
case Error:
if useColor {
buf.WriteString(color.RenderString(color.Error.Code(), "ERR"))
} else {
buf.WriteString("ERR")
}
}
}
// Log writes a log entry.
func (l *Logger) Log(level Level, format string, args ...any) {
if level < l.Level {
return
}
l.mutex.Lock()
defer l.mutex.Unlock()
t := l.timeNow()
for _, dest := range l.destinations {
dest.log(t, level, format, args...)
}
}
================================================
FILE: internal/logger/logger_test.go
================================================
package logger
import (
"bytes"
"os"
"testing"
"time"
"github.com/stretchr/testify/require"
)
func TestLoggerToStdout(t *testing.T) {
for _, ca := range []string{
"plain",
"structured",
} {
t.Run(ca, func(t *testing.T) {
var buf bytes.Buffer
l := &Logger{
Destinations: []Destination{DestinationStdout},
Structured: (ca == "structured"),
timeNow: func() time.Time { return time.Date(2003, 11, 4, 23, 15, 8, 431232, time.UTC) },
stdout: &buf,
}
err := l.Initialize()
require.NoError(t, err)
defer l.Close()
l.Log(Info, "test format %d", 123)
if ca == "plain" {
require.Equal(t, "2003/11/04 23:15:08 INF test format 123\n", buf.String())
} else {
require.Equal(t, `{"timestamp":"2003-11-04T23:15:08.000431232Z",`+
`"level":"INF","message":"test format 123"}`+"\n", buf.String())
}
})
}
}
func TestLoggerToFile(t *testing.T) {
for _, ca := range []string{
"plain",
"structured",
} {
t.Run(ca, func(t *testing.T) {
tempFile, err := os.CreateTemp(os.TempDir(), "mtx-logger-")
require.NoError(t, err)
defer os.Remove(tempFile.Name())
defer tempFile.Close()
l := &Logger{
Level: Debug,
Destinations: []Destination{DestinationFile},
Structured: ca == "structured",
File: tempFile.Name(),
timeNow: func() time.Time { return time.Date(2003, 11, 4, 23, 15, 8, 0, time.UTC) },
}
err = l.Initialize()
require.NoError(t, err)
defer l.Close()
l.Log(Info, "test format %d", 123)
buf, err := os.ReadFile(tempFile.Name())
require.NoError(t, err)
if ca == "plain" {
require.Equal(t, "2003/11/04 23:15:08 INF test format 123\n", string(buf))
} else {
require.Equal(t, `{"timestamp":"2003-11-04T23:15:08Z",`+
`"level":"INF","message":"test format 123"}`+"\n", string(buf))
}
})
}
}
================================================
FILE: internal/logger/writer.go
================================================
package logger
// Writer is an object that provides a log method.
type Writer interface {
Log(Level, string, ...any)
}
================================================
FILE: internal/metrics/metrics.go
================================================
// Package metrics contains the metrics provider.
package metrics //nolint:revive
import (
"io"
"net"
"net/http"
"reflect"
"sort"
"strconv"
"sync"
"time"
"github.com/gin-gonic/gin"
"github.com/bluenviron/mediamtx/internal/auth"
"github.com/bluenviron/mediamtx/internal/conf"
"github.com/bluenviron/mediamtx/internal/defs"
"github.com/bluenviron/mediamtx/internal/logger"
"github.com/bluenviron/mediamtx/internal/protocols/httpp"
)
func interfaceIsEmpty(i any) bool {
return reflect.ValueOf(i).Kind() != reflect.Pointer || reflect.ValueOf(i).IsNil()
}
func sortedKeys(paths map[string]string) []string {
ret := make([]string, len(paths))
i := 0
for name := range paths {
ret[i] = name
i++
}
sort.Strings(ret)
return ret
}
func tags(m map[string]string) string {
o := "{"
first := true
for _, k := range sortedKeys(m) {
if first {
first = false
} else {
o += ","
}
o += k + "=\"" + m[k] + "\""
}
o += "}"
return o
}
func metric(key string, tags string, value int64) string {
return key + tags + " " + strconv.FormatInt(value, 10) + "\n"
}
func metricFloat(key string, tags string, value float64) string {
return key + tags + " " + strconv.FormatFloat(value, 'f', -1, 64) + "\n"
}
type metricsAuthManager interface {
Authenticate(req *auth.Request) (string, *auth.Error)
}
type metricsParent interface {
logger.Writer
}
// Metrics is a metrics provider.
type Metrics struct {
Address string
DumpPackets bool
Encryption bool
ServerKey string
ServerCert string
AllowOrigins []string
TrustedProxies conf.IPNetworks
ReadTimeout conf.Duration
WriteTimeout conf.Duration
AuthManager metricsAuthManager
Parent metricsParent
httpServer *httpp.Server
mutex sync.Mutex
pathManager defs.APIPathManager
hlsServer defs.APIHLSServer
rtspServer defs.APIRTSPServer
rtspsServer defs.APIRTSPServer
rtmpServer defs.APIRTMPServer
rtmpsServer defs.APIRTMPServer
srtServer defs.APISRTServer
webRTCServer defs.APIWebRTCServer
}
// Initialize initializes metrics.
func (m *Metrics) Initialize() error {
router := gin.New()
router.SetTrustedProxies(m.TrustedProxies.ToTrustedProxies()) //nolint:errcheck
router.Use(m.middlewarePreflightRequests)
router.Use(m.middlewareAuth)
router.GET("/metrics", m.onMetrics)
m.httpServer = &httpp.Server{
Address: m.Address,
AllowOrigins: m.AllowOrigins,
DumpPackets: m.DumpPackets,
DumpPacketsPrefix: "metrics_server_conn",
ReadTimeout: time.Duration(m.ReadTimeout),
WriteTimeout: time.Duration(m.WriteTimeout),
Encryption: m.Encryption,
ServerCert: m.ServerCert,
ServerKey: m.ServerKey,
Handler: router,
Parent: m,
}
err := m.httpServer.Initialize()
if err != nil {
return err
}
m.Log(logger.Info, "listener opened on "+m.Address)
return nil
}
// Close closes Metrics.
func (m *Metrics) Close() {
m.Log(logger.Info, "listener is closing")
m.httpServer.Close()
}
// Log implements logger.Writer.
func (m *Metrics) Log(level logger.Level, format string, args ...any) {
m.Parent.Log(level, "[metrics] "+format, args...)
}
func (m *Metrics) middlewarePreflightRequests(ctx *gin.Context) {
if ctx.Request.Method == http.MethodOptions &&
ctx.Request.Header.Get("Access-Control-Request-Method") != "" {
ctx.Header("Access-Control-Allow-Methods", "OPTIONS, GET")
ctx.Header("Access-Control-Allow-Headers", "Authorization")
ctx.AbortWithStatus(http.StatusNoContent)
return
}
}
func (m *Metrics) middlewareAuth(ctx *gin.Context) {
req := &auth.Request{
Action: conf.AuthActionMetrics,
Query: ctx.Request.URL.RawQuery,
Credentials: httpp.Credentials(ctx.Request),
IP: net.ParseIP(ctx.ClientIP()),
}
_, err := m.AuthManager.Authenticate(req)
if err != nil {
if err.AskCredentials {
ctx.Header("WWW-Authenticate", `Basic realm="mediamtx"`)
ctx.AbortWithStatusJSON(http.StatusUnauthorized, &defs.APIError{
Status: defs.APIErrorStatusError,
Error: "authentication error",
})
return
}
m.Log(logger.Info, "connection %v failed to authenticate: %v", httpp.RemoteAddr(ctx), err.Wrapped)
// wait some seconds to delay brute force attacks
<-time.After(auth.PauseAfterError)
ctx.AbortWithStatusJSON(http.StatusUnauthorized, &defs.APIError{
Status: defs.APIErrorStatusError,
Error: "authentication error",
})
return
}
}
func (m *Metrics) onMetrics(ctx *gin.Context) {
typ := ctx.Query("type")
pathFilter := ctx.Query("path")
hlsMuxerFilter := ctx.Query("hls_muxer")
rtspConnFilter := ctx.Query("rtsp_conn")
rtspSessionFilter := ctx.Query("rtsp_session")
rtspsConnFilter := ctx.Query("rtsps_conn")
rtspsSessionFilter := ctx.Query("rtsps_session")
rtmpConnFilter := ctx.Query("rtmp_conn")
rtmpsConnFilter := ctx.Query("rtmps_conn")
srtConnFilter := ctx.Query("srt_conn")
webrtcSessionFilter := ctx.Query("webrtc_session")
anyFilterActive := pathFilter != "" ||
hlsMuxerFilter != "" ||
rtspConnFilter != "" ||
rtspSessionFilter != "" ||
rtspsConnFilter != "" ||
rtspsSessionFilter != "" ||
rtmpConnFilter != "" ||
rtmpsConnFilter != "" ||
srtConnFilter != "" ||
webrtcSessionFilter != ""
out := ""
if (typ == "" || typ == "paths") && (!anyFilterActive || pathFilter != "") {
data, err := m.pathManager.APIPathsList()
if err == nil && len(data.Items) != 0 {
for _, i := range data.Items {
if pathFilter == "" || pathFilter == i.Name {
var state string
if i.Ready {
state = "ready"
} else {
state = "notReady"
}
ta := tags(map[string]string{
"name": i.Name,
"state": state,
})
out += metric("paths", ta, 1)
out += metric("paths_inbound_bytes", ta, int64(i.InboundBytes))
out += metric("paths_outbound_bytes", ta, int64(i.OutboundBytes))
out += metric("paths_inbound_frames_in_error", ta, int64(i.InboundFramesInError))
// deprecated
out += metric("paths_bytes_received", ta, int64(i.BytesReceived))
out += metric("paths_bytes_sent", ta, int64(i.BytesSent))
out += metric("paths_readers", ta, int64(len(i.Readers)))
}
}
} else if pathFilter == "" {
out += metric("paths", "", 0)
out += metric("paths_inbound_bytes", "", 0)
out += metric("paths_outbound_bytes", "", 0)
out += metric("paths_inbound_frames_in_error", "", 0)
// deprecated
out += metric("paths_bytes_received", "", 0)
out += metric("paths_bytes_sent", "", 0)
out += metric("paths_readers", "", 0)
}
}
if !interfaceIsEmpty(m.hlsServer) &&
(typ == "" || typ == "hls_muxers") &&
(!anyFilterActive || hlsMuxerFilter != "") {
var data *defs.APIHLSMuxerList
data, err := m.hlsServer.APIMuxersList()
if err == nil && len(data.Items) != 0 {
for _, i := range data.Items {
if hlsMuxerFilter == "" || hlsMuxerFilter == i.Path {
ta := tags(map[string]string{
"name": i.Path,
})
out += metric("hls_muxers", ta, 1)
out += metric("hls_muxers_outbound_bytes", ta, int64(i.OutboundBytes))
out += metric("hls_muxers_outbound_frames_discarded", ta, int64(i.OutboundFramesDiscarded))
// deprecated
out += metric("hls_muxers_bytes_sent", ta, int64(i.BytesSent))
}
}
} else if hlsMuxerFilter == "" {
out += metric("hls_muxers", "", 0)
out += metric("hls_muxers_outbound_bytes", "", 0)
out += metric("hls_muxers_outbound_frames_discarded", "", 0)
// deprecated
out += metric("hls_muxers_bytes_sent", "", 0)
}
}
if !interfaceIsEmpty(m.rtspServer) { //nolint:dupl
if (typ == "" || typ == "rtsp_conns") && (!anyFilterActive || rtspConnFilter != "") {
var data *defs.APIRTSPConnsList
data, err := m.rtspServer.APIConnsList()
if err == nil && len(data.Items) != 0 {
for _, i := range data.Items {
if rtspConnFilter == "" || rtspConnFilter == i.ID.String() {
ta := tags(map[string]string{
"id": i.ID.String(),
})
out += metric("rtsp_conns", ta, 1)
out += metric("rtsp_conns_inbound_bytes", ta, int64(i.InboundBytes))
out += metric("rtsp_conns_outbound_bytes", ta, int64(i.OutboundBytes))
// deprecated
out += metric("rtsp_conns_bytes_received", ta, int64(i.BytesReceived))
out += metric("rtsp_conns_bytes_sent", ta, int64(i.BytesSent))
}
}
} else if rtspConnFilter == "" {
out += metric("rtsp_conns", "", 0)
out += metric("rtsp_conns_inbound_bytes", "", 0)
out += metric("rtsp_conns_outbound_bytes", "", 0)
// deprecated
out += metric("rtsp_conns_bytes_received", "", 0)
out += metric("rtsp_conns_bytes_sent", "", 0)
}
}
if (typ == "" || typ == "rtsp_sessions") && (!anyFilterActive || rtspSessionFilter != "") {
var data *defs.APIRTSPSessionList
data, err := m.rtspServer.APISessionsList()
if err == nil && len(data.Items) != 0 {
for _, i := range data.Items {
if rtspSessionFilter == "" || rtspSessionFilter == i.ID.String() {
ta := tags(map[string]string{
"id": i.ID.String(),
"state": string(i.State),
"path": i.Path,
"remoteAddr": i.RemoteAddr,
})
out += metric("rtsp_sessions", ta, 1)
out += metric("rtsp_sessions_inbound_bytes", ta, int64(i.InboundBytes))
out += metric("rtsp_sessions_inbound_rtp_packets", ta, int64(i.InboundRTPPackets))
out += metric("rtsp_sessions_inbound_rtp_packets_lost", ta, int64(i.InboundRTPPacketsLost))
out += metric("rtsp_sessions_inbound_rtp_packets_in_error", ta, int64(i.InboundRTPPacketsInError))
out += metricFloat("rtsp_sessions_inbound_rtp_packets_jitter", ta, i.InboundRTPPacketsJitter)
out += metric("rtsp_sessions_inbound_rtcp_packets", ta, int64(i.InboundRTCPPackets))
out += metric("rtsp_sessions_inbound_rtcp_packets_in_error", ta, int64(i.InboundRTCPPacketsInError))
out += metric("rtsp_sessions_outbound_bytes", ta, int64(i.OutboundBytes))
out += metric("rtsp_sessions_outbound_rtp_packets", ta, int64(i.OutboundRTPPackets))
out += metric("rtsp_sessions_outbound_rtp_packets_reported_lost", ta, int64(i.OutboundRTPPacketsReportedLost))
out += metric("rtsp_sessions_outbound_rtp_packets_discarded", ta, int64(i.OutboundRTPPacketsDiscarded))
out += metric("rtsp_sessions_outbound_rtcp_packets", ta, int64(i.OutboundRTCPPackets))
// deprecated
out += metric("rtsp_sessions_bytes_received", ta, int64(i.BytesReceived))
out += metric("rtsp_sessions_bytes_sent", ta, int64(i.BytesSent))
out += metric("rtsp_sessions_rtp_packets_received", ta, int64(i.RTPPacketsReceived))
out += metric("rtsp_sessions_rtp_packets_sent", ta, int64(i.RTPPacketsSent))
out += metric("rtsp_sessions_rtp_packets_lost", ta, int64(i.RTPPacketsLost))
out += metric("rtsp_sessions_rtp_packets_in_error", ta, int64(i.RTPPacketsInError))
out += metricFloat("rtsp_sessions_rtp_packets_jitter", ta, i.RTPPacketsJitter)
out += metric("rtsp_sessions_rtcp_packets_received", ta, int64(i.RTCPPacketsReceived))
out += metric("rtsp_sessions_rtcp_packets_sent", ta, int64(i.RTCPPacketsSent))
out += metric("rtsp_sessions_rtcp_packets_in_error", ta, int64(i.RTCPPacketsInError))
}
}
} else if rtspSessionFilter == "" {
out += metric("rtsp_sessions", "", 0)
out += metric("rtsp_sessions_inbound_bytes", "", 0)
out += metric("rtsp_sessions_inbound_rtp_packets", "", 0)
out += metric("rtsp_sessions_inbound_rtp_packets_lost", "", 0)
out += metric("rtsp_sessions_inbound_rtp_packets_in_error", "", 0)
out += metricFloat("rtsp_sessions_inbound_rtp_packets_jitter", "", 0)
out += metric("rtsp_sessions_inbound_rtcp_packets", "", 0)
out += metric("rtsp_sessions_inbound_rtcp_packets_in_error", "", 0)
out += metric("rtsp_sessions_outbound_bytes", "", 0)
out += metric("rtsp_sessions_outbound_rtp_packets", "", 0)
out += metric("rtsp_sessions_outbound_rtp_packets_reported_lost", "", 0)
out += metric("rtsp_sessions_outbound_rtp_packets_discarded", "", 0)
out += metric("rtsp_sessions_outbound_rtcp_packets", "", 0)
// deprecated
out += metric("rtsp_sessions_bytes_received", "", 0)
out += metric("rtsp_sessions_bytes_sent", "", 0)
out += metric("rtsp_sessions_rtp_packets_received", "", 0)
out += metric("rtsp_sessions_rtp_packets_sent", "", 0)
out += metric("rtsp_sessions_rtp_packets_lost", "", 0)
out += metric("rtsp_sessions_rtp_packets_in_error", "", 0)
out += metricFloat("rtsp_sessions_rtp_packets_jitter", "", 0)
out += metric("rtsp_sessions_rtcp_packets_received", "", 0)
out += metric("rtsp_sessions_rtcp_packets_sent", "", 0)
out += metric("rtsp_sessions_rtcp_packets_in_error", "", 0)
}
}
}
if !interfaceIsEmpty(m.rtspsServer) { //nolint:dupl
if (typ == "" || typ == "rtsps_conns") && (!anyFilterActive || rtspsConnFilter != "") {
var data *defs.APIRTSPConnsList
data, err := m.rtspsServer.APIConnsList()
if err == nil && len(data.Items) != 0 {
for _, i := range data.Items {
if rtspsConnFilter == "" || rtspsConnFilter == i.ID.String() {
ta := tags(map[string]string{
"id": i.ID.String(),
})
out += metric("rtsps_conns", ta, 1)
out += metric("rtsps_conns_inbound_bytes", ta, int64(i.InboundBytes))
out += metric("rtsps_conns_outbound_bytes", ta, int64(i.OutboundBytes))
// deprecated
out += metric("rtsps_conns_bytes_received", ta, int64(i.BytesReceived))
out += metric("rtsps_conns_bytes_sent", ta, int64(i.BytesSent))
}
}
} else if rtspsConnFilter == "" {
out += metric("rtsps_conns", "", 0)
out += metric("rtsps_conns_inbound_bytes", "", 0)
out += metric("rtsps_conns_outbound_bytes", "", 0)
// deprecated
out += metric("rtsps_conns_bytes_received", "", 0)
out += metric("rtsps_conns_bytes_sent", "", 0)
}
}
if (typ == "" || typ == "rtsps_sessions") && (!anyFilterActive || rtspsSessionFilter != "") {
var data *defs.APIRTSPSessionList
data, err := m.rtspsServer.APISessionsList()
if err == nil && len(data.Items) != 0 {
for _, i := range data.Items {
if rtspsSessionFilter == "" || rtspsSessionFilter == i.ID.String() {
ta := tags(map[string]string{
"id": i.ID.String(),
"state": string(i.State),
"path": i.Path,
"remoteAddr": i.RemoteAddr,
})
out += metric("rtsps_sessions", ta, 1)
out += metric("rtsps_sessions_inbound_bytes", ta, int64(i.InboundBytes))
out += metric("rtsps_sessions_inbound_rtp_packets", ta, int64(i.InboundRTPPackets))
out += metric("rtsps_sessions_inbound_rtp_packets_lost", ta, int64(i.InboundRTPPacketsLost))
out += metric("rtsps_sessions_inbound_rtp_packets_in_error", ta, int64(i.InboundRTPPacketsInError))
out += metricFloat("rtsps_sessions_inbound_rtp_packets_jitter", ta, i.InboundRTPPacketsJitter)
out += metric("rtsps_sessions_inbound_rtcp_packets", ta, int64(i.InboundRTCPPackets))
out += metric("rtsps_sessions_inbound_rtcp_packets_in_error", ta, int64(i.InboundRTCPPacketsInError))
out += metric("rtsps_sessions_outbound_bytes", ta, int64(i.OutboundBytes))
out += metric("rtsps_sessions_outbound_rtp_packets", ta, int64(i.OutboundRTPPackets))
out += metric("rtsps_sessions_outbound_rtp_packets_reported_lost", ta, int64(i.OutboundRTPPacketsReportedLost))
out += metric("rtsps_sessions_outbound_rtp_packets_discarded", ta, int64(i.OutboundRTPPacketsDiscarded))
out += metric("rtsps_sessions_outbound_rtcp_packets", ta, int64(i.OutboundRTCPPackets))
// deprecated
out += metric("rtsps_sessions_bytes_received", ta, int64(i.BytesReceived))
out += metric("rtsps_sessions_bytes_sent", ta, int64(i.BytesSent))
out += metric("rtsps_sessions_rtp_packets_received", ta, int64(i.RTPPacketsReceived))
out += metric("rtsps_sessions_rtp_packets_sent", ta, int64(i.RTPPacketsSent))
out += metric("rtsps_sessions_rtp_packets_lost", ta, int64(i.RTPPacketsLost))
out += metric("rtsps_sessions_rtp_packets_in_error", ta, int64(i.RTPPacketsInError))
out += metricFloat("rtsps_sessions_rtp_packets_jitter", ta, i.RTPPacketsJitter)
out += metric("rtsps_sessions_rtcp_packets_received", ta, int64(i.RTCPPacketsReceived))
out += metric("rtsps_sessions_rtcp_packets_sent", ta, int64(i.RTCPPacketsSent))
out += metric("rtsps_sessions_rtcp_packets_in_error", ta, int64(i.RTCPPacketsInError))
}
}
} else if rtspsSessionFilter == "" {
out += metric("rtsps_sessions", "", 0)
out += metric("rtsps_sessions_inbound_bytes", "", 0)
out += metric("rtsps_sessions_inbound_rtp_packets", "", 0)
out += metric("rtsps_sessions_inbound_rtp_packets_lost", "", 0)
out += metric("rtsps_sessions_inbound_rtp_packets_in_error", "", 0)
out += metricFloat("rtsps_sessions_inbound_rtp_packets_jitter", "", 0)
out += metric("rtsps_sessions_inbound_rtcp_packets", "", 0)
out += metric("rtsps_sessions_inbound_rtcp_packets_in_error", "", 0)
out += metric("rtsps_sessions_outbound_bytes", "", 0)
out += metric("rtsps_sessions_outbound_rtp_packets", "", 0)
out += metric("rtsps_sessions_outbound_rtp_packets_reported_lost", "", 0)
out += metric("rtsps_sessions_outbound_rtp_packets_discarded", "", 0)
out += metric("rtsps_sessions_outbound_rtcp_packets", "", 0)
// deprecated
out += metric("rtsps_sessions_bytes_received", "", 0)
out += metric("rtsps_sessions_bytes_sent", "", 0)
out += metric("rtsps_sessions_rtp_packets_received", "", 0)
out += metric("rtsps_sessions_rtp_packets_sent", "", 0)
out += metric("rtsps_sessions_rtp_packets_lost", "", 0)
out += metric("rtsps_sessions_rtp_packets_in_error", "", 0)
out += metricFloat("rtsps_sessions_rtp_packets_jitter", "", 0)
out += metric("rtsps_sessions_rtcp_packets_received", "", 0)
out += metric("rtsps_sessions_rtcp_packets_sent", "", 0)
out += metric("rtsps_sessions_rtcp_packets_in_error", "", 0)
}
}
}
if !interfaceIsEmpty(m.rtmpServer) && //nolint:dupl
(typ == "" || typ == "rtmp_conns") &&
(!anyFilterActive || rtmpConnFilter != "") {
var data *defs.APIRTMPConnList
data, err := m.rtmpServer.APIConnsList()
if err == nil && len(data.Items) != 0 {
for _, i := range data.Items {
if rtmpConnFilter == "" || rtmpConnFilter == i.ID.String() {
ta := tags(map[string]string{
"id": i.ID.String(),
"state": string(i.State),
"path": i.Path,
"remoteAddr": i.RemoteAddr,
})
out += metric("rtmp_conns", ta, 1)
out += metric("rtmp_conns_inbound_bytes", ta, int64(i.InboundBytes))
out += metric("rtmp_conns_outbound_bytes", ta, int64(i.OutboundBytes))
out += metric("rtmp_conns_outbound_frames_discarded", ta, int64(i.OutboundFramesDiscarded))
// deprecated
out += metric("rtmp_conns_bytes_received", ta, int64(i.BytesReceived))
out += metric("rtmp_conns_bytes_sent", ta, int64(i.BytesSent))
}
}
} else if rtmpConnFilter == "" {
out += metric("rtmp_conns", "", 0)
out += metric("rtmp_conns_inbound_bytes", "", 0)
out += metric("rtmp_conns_outbound_bytes", "", 0)
out += metric("rtmp_conns_outbound_frames_discarded", "", 0)
// deprecated
out += metric("rtmp_conns_bytes_received", "", 0)
out += metric("rtmp_conns_bytes_sent", "", 0)
}
}
if !interfaceIsEmpty(m.rtmpsServer) && //nolint:dupl
(typ == "" || typ == "rtmp_conns") &&
(!anyFilterActive || rtmpsConnFilter != "") {
var data *defs.APIRTMPConnList
data, err := m.rtmpsServer.APIConnsList()
if err == nil && len(data.Items) != 0 {
for _, i := range data.Items {
if rtmpsConnFilter == "" || rtmpsConnFilter == i.ID.String() {
ta := tags(map[string]string{
"id": i.ID.String(),
"state": string(i.State),
"path": i.Path,
"remoteAddr": i.RemoteAddr,
})
out += metric("rtmps_conns", ta, 1)
out += metric("rtmps_conns_inbound_bytes", ta, int64(i.InboundBytes))
out += metric("rtmps_conns_outbound_bytes", ta, int64(i.OutboundBytes))
out += metric("rtmps_conns_outbound_frames_discarded", ta, int64(i.OutboundFramesDiscarded))
// deprecated
out += metric("rtmps_conns_bytes_received", ta, int64(i.BytesReceived))
out += metric("rtmps_conns_bytes_sent", ta, int64(i.BytesSent))
}
}
} else if rtmpsConnFilter == "" {
out += metric("rtmps_conns", "", 0)
out += metric("rtmps_conns_inbound_bytes", "", 0)
out += metric("rtmps_conns_outbound_bytes", "", 0)
out += metric("rtmps_conns_outbound_frames_discarded", "", 0)
// deprecated
out += metric("rtmps_conns_bytes_received", "", 0)
out += metric("rtmps_conns_bytes_sent", "", 0)
}
}
if !interfaceIsEmpty(m.srtServer) &&
(typ == "" || typ == "srt_conns") &&
(!anyFilterActive || srtConnFilter != "") {
var data *defs.APISRTConnList
data, err := m.srtServer.APIConnsList()
if err == nil && len(data.Items) != 0 {
for _, i := range data.Items {
if srtConnFilter == "" || srtConnFilter == i.ID.String() {
ta := tags(map[string]string{
"id": i.ID.String(),
"state": string(i.State),
"path": i.Path,
"remoteAddr": i.RemoteAddr,
})
out += metric("srt_conns", ta, 1)
out += metric("srt_conns_packets_sent", ta, int64(i.PacketsSent))
out += metric("srt_conns_packets_received", ta, int64(i.PacketsReceived))
out += metric("srt_conns_packets_sent_unique", ta, int64(i.PacketsSentUnique))
out += metric("srt_conns_packets_received_unique", ta, int64(i.PacketsReceivedUnique))
out += metric("srt_conns_packets_send_loss", ta, int64(i.PacketsSendLoss))
out += metric("srt_conns_packets_received_loss", ta, int64(i.PacketsReceivedLoss))
out += metric("srt_conns_packets_retrans", ta, int64(i.PacketsRetrans))
out += metric("srt_conns_packets_received_retrans", ta, int64(i.PacketsReceivedRetrans))
out += metric("srt_conns_packets_sent_ack", ta, int64(i.PacketsSentACK))
out += metric("srt_conns_packets_received_ack", ta, int64(i.PacketsReceivedACK))
out += metric("srt_conns_packets_sent_nak", ta, int64(i.PacketsSentNAK))
out += metric("srt_conns_packets_received_nak", ta, int64(i.PacketsReceivedNAK))
out += metric("srt_conns_packets_sent_km", ta, int64(i.PacketsSentKM))
out += metric("srt_conns_packets_received_km", ta, int64(i.PacketsReceivedKM))
out += metric("srt_conns_us_snd_duration", ta, int64(i.UsSndDuration))
out += metric("srt_conns_packets_received_belated", ta, int64(i.PacketsReceivedBelated))
out += metric("srt_conns_packets_send_drop", ta, int64(i.PacketsSendDrop))
out += metric("srt_conns_packets_received_drop", ta, int64(i.PacketsReceivedDrop))
out += metric("srt_conns_packets_received_undecrypt", ta, int64(i.PacketsReceivedUndecrypt))
out += metric("srt_conns_bytes_sent", ta, int64(i.BytesSent))
out += metric("srt_conns_bytes_received", ta, int64(i.BytesReceived))
out += metric("srt_conns_bytes_sent_unique", ta, int64(i.BytesSentUnique))
out += metric("srt_conns_bytes_received_unique", ta, int64(i.BytesReceivedUnique))
out += metric("srt_conns_bytes_received_loss", ta, int64(i.BytesReceivedLoss))
out += metric("srt_conns_bytes_retrans", ta, int64(i.BytesRetrans))
out += metric("srt_conns_bytes_received_retrans", ta, int64(i.BytesReceivedRetrans))
out += metric("srt_conns_bytes_received_belated", ta, int64(i.BytesReceivedBelated))
out += metric("srt_conns_bytes_send_drop", ta, int64(i.BytesSendDrop))
out += metric("srt_conns_bytes_received_drop", ta, int64(i.BytesReceivedDrop))
out += metric("srt_conns_bytes_received_undecrypt", ta, int64(i.BytesReceivedUndecrypt))
out += metricFloat("srt_conns_us_packets_send_period", ta, i.UsPacketsSendPeriod)
out += metric("srt_conns_packets_flow_window", ta, int64(i.PacketsFlowWindow))
out += metric("srt_conns_packets_flight_size", ta, int64(i.PacketsFlightSize))
out += metricFloat("srt_conns_ms_rtt", ta, i.MsRTT)
out += metricFloat("srt_conns_mbps_send_rate", ta, i.MbpsSendRate)
out += metricFloat("srt_conns_mbps_receive_rate", ta, i.MbpsReceiveRate)
out += metricFloat("srt_conns_mbps_link_capacity", ta, i.MbpsLinkCapacity)
out += metric("srt_conns_bytes_avail_send_buf", ta, int64(i.BytesAvailSendBuf))
out += metric("srt_conns_bytes_avail_receive_buf", ta, int64(i.BytesAvailReceiveBuf))
out += metricFloat("srt_conns_mbps_max_bw", ta, i.MbpsMaxBW)
out += metric("srt_conns_bytes_mss", ta, int64(i.ByteMSS))
out += metric("srt_conns_packets_send_buf", ta, int64(i.PacketsSendBuf))
out += metric("srt_conns_bytes_send_buf", ta, int64(i.BytesSendBuf))
out += metric("srt_conns_ms_send_buf", ta, int64(i.MsSendBuf))
out += metric("srt_conns_ms_send_tsb_pd_delay", ta, int64(i.MsSendTsbPdDelay))
out += metric("srt_conns_packets_receive_buf", ta, int64(i.PacketsReceiveBuf))
out += metric("srt_conns_bytes_receive_buf", ta, int64(i.BytesReceiveBuf))
out += metric("srt_conns_ms_receive_buf", ta, int64(i.MsReceiveBuf))
out += metric("srt_conns_ms_receive_tsb_pd_delay", ta, int64(i.MsReceiveTsbPdDelay))
out += metric("srt_conns_packets_reorder_tolerance", ta, int64(i.PacketsReorderTolerance))
out += metric("srt_conns_packets_received_avg_belated_time", ta, int64(i.PacketsReceivedAvgBelatedTime))
out += metricFloat("srt_conns_packets_send_loss_rate", ta, i.PacketsSendLossRate)
out += metricFloat("srt_conns_packets_received_loss_rate", ta, i.PacketsReceivedLossRate)
out += metric("srt_conns_outbound_frames_discarded", ta, int64(i.OutboundFramesDiscarded))
}
}
} else if srtConnFilter == "" {
out += metric("srt_conns", "", 0)
out += metric("srt_conns_packets_sent", "", 0)
out += metric("srt_conns_packets_received", "", 0)
out += metric("srt_conns_packets_sent_unique", "", 0)
out += metric("srt_conns_packets_received_unique", "", 0)
out += metric("srt_conns_packets_send_loss", "", 0)
out += metric("srt_conns_packets_received_loss", "", 0)
out += metric("srt_conns_packets_retrans", "", 0)
out += metric("srt_conns_packets_received_retrans", "", 0)
out += metric("srt_conns_packets_sent_ack", "", 0)
out += metric("srt_conns_packets_received_ack", "", 0)
out += metric("srt_conns_packets_sent_nak", "", 0)
out += metric("srt_conns_packets_received_nak", "", 0)
out += metric("srt_conns_packets_sent_km", "", 0)
out += metric("srt_conns_packets_received_km", "", 0)
out += metric("srt_conns_us_snd_duration", "", 0)
out += metric("srt_conns_packets_received_belated", "", 0)
out += metric("srt_conns_packets_send_drop", "", 0)
out += metric("srt_conns_packets_received_drop", "", 0)
out += metric("srt_conns_packets_received_undecrypt", "", 0)
out += metric("srt_conns_bytes_sent", "", 0)
out += metric("srt_conns_bytes_received", "", 0)
out += metric("srt_conns_bytes_sent_unique", "", 0)
out += metric("srt_conns_bytes_received_unique", "", 0)
out += metric("srt_conns_bytes_received_loss", "", 0)
out += metric("srt_conns_bytes_retrans", "", 0)
out += metric("srt_conns_bytes_received_retrans", "", 0)
out += metric("srt_conns_bytes_received_belated", "", 0)
out += metric("srt_conns_bytes_send_drop", "", 0)
out += metric("srt_conns_bytes_received_drop", "", 0)
out += metric("srt_conns_bytes_received_undecrypt", "", 0)
out += metricFloat("srt_conns_us_packets_send_period", "", 0)
out += metric("srt_conns_packets_flow_window", "", 0)
out += metric("srt_conns_packets_flight_size", "", 0)
out += metricFloat("srt_conns_ms_rtt", "", 0)
out += metricFloat("srt_conns_mbps_send_rate", "", 0)
out += metricFloat("srt_conns_mbps_receive_rate", "", 0)
out += metricFloat("srt_conns_mbps_link_capacity", "", 0)
out += metric("srt_conns_bytes_avail_send_buf", "", 0)
out += metric("srt_conns_bytes_avail_receive_buf", "", 0)
out += metricFloat("srt_conns_mbps_max_bw", "", 0)
out += metric("srt_conns_bytes_mss", "", 0)
out += metric("srt_conns_packets_send_buf", "", 0)
out += metric("srt_conns_bytes_send_buf", "", 0)
out += metric("srt_conns_ms_send_buf", "", 0)
out += metric("srt_conns_ms_send_tsb_pd_delay", "", 0)
out += metric("srt_conns_packets_receive_buf", "", 0)
out += metric("srt_conns_bytes_receive_buf", "", 0)
out += metric("srt_conns_ms_receive_buf", "", 0)
out += metric("srt_conns_ms_receive_tsb_pd_delay", "", 0)
out += metric("srt_conns_packets_reorder_tolerance", "", 0)
out += metric("srt_conns_packets_received_avg_belated_time", "", 0)
out += metricFloat("srt_conns_packets_send_loss_rate", "", 0)
out += metricFloat("srt_conns_packets_received_loss_rate", "", 0)
out += metric("srt_conns_outbound_frames_discarded", "", 0)
}
}
if !interfaceIsEmpty(m.webRTCServer) &&
(typ == "" || typ == "webrtc_sessions") &&
(!anyFilterActive || webrtcSessionFilter != "") {
var data *defs.APIWebRTCSessionList
data, err := m.webRTCServer.APISessionsList()
if err == nil && len(data.Items) != 0 {
for _, i := range data.Items {
if webrtcSessionFilter == "" || webrtcSessionFilter == i.ID.String() {
ta := tags(map[string]string{
"id": i.ID.String(),
"state": string(i.State),
"path": i.Path,
"remoteAddr": i.RemoteAddr,
})
out += metric("webrtc_sessions", ta, 1)
out += metric("webrtc_sessions_inbound_bytes", ta, int64(i.InboundBytes))
out += metric("webrtc_sessions_inbound_rtp_packets", ta, int64(i.InboundRTPPackets))
out += metric("webrtc_sessions_inbound_rtp_packets_lost", ta, int64(i.InboundRTPPacketsLost))
out += metricFloat("webrtc_sessions_inbound_rtp_packets_jitter", ta, i.InboundRTPPacketsJitter)
out += metric("webrtc_sessions_inbound_rtcp_packets", ta, int64(i.InboundRTCPPackets))
out += metric("webrtc_sessions_outbound_bytes", ta, int64(i.OutboundBytes))
out += metric("webrtc_sessions_outbound_rtp_packets", ta, int64(i.OutboundRTPPackets))
out += metric("webrtc_sessions_outbound_rtcp_packets", ta, int64(i.OutboundRTCPPackets))
out += metric("webrtc_sessions_outbound_frames_discarded", ta, int64(i.OutboundFramesDiscarded))
// deprecated
out += metric("webrtc_sessions_bytes_received", ta, int64(i.BytesReceived))
out += metric("webrtc_sessions_bytes_sent", ta, int64(i.BytesSent))
out += metric("webrtc_sessions_rtp_packets_received", ta, int64(i.RTPPacketsReceived))
out += metric("webrtc_sessions_rtp_packets_sent", ta, int64(i.RTPPacketsSent))
out += metric("webrtc_sessions_rtp_packets_lost", ta, int64(i.RTPPacketsLost))
out += metricFloat("webrtc_sessions_rtp_packets_jitter", ta, i.RTPPacketsJitter)
out += metric("webrtc_sessions_rtcp_packets_received", ta, int64(i.RTCPPacketsReceived))
out += metric("webrtc_sessions_rtcp_packets_sent", ta, int64(i.RTCPPacketsSent))
}
}
} else if webrtcSessionFilter == "" {
out += metric("webrtc_sessions", "", 0)
out += metric("webrtc_sessions_inbound_bytes", "", 0)
out += metric("webrtc_sessions_inbound_rtp_packets", "", 0)
out += metric("webrtc_sessions_inbound_rtp_packets_lost", "", 0)
out += metricFloat("webrtc_sessions_inbound_rtp_packets_jitter", "", 0)
out += metric("webrtc_sessions_inbound_rtcp_packets", "", 0)
out += metric("webrtc_sessions_outbound_bytes", "", 0)
out += metric("webrtc_sessions_outbound_rtp_packets", "", 0)
out += metric("webrtc_sessions_outbound_rtcp_packets", "", 0)
out += metric("webrtc_sessions_outbound_frames_discarded", "", 0)
// deprecated
out += metric("webrtc_sessions_bytes_received", "", 0)
out += metric("webrtc_sessions_bytes_sent", "", 0)
out += metric("webrtc_sessions_rtp_packets_received", "", 0)
out += metric("webrtc_sessions_rtp_packets_sent", "", 0)
out += metric("webrtc_sessions_rtp_packets_lost", "", 0)
out += metricFloat("webrtc_sessions_rtp_packets_jitter", "", 0)
out += metric("webrtc_sessions_rtcp_packets_received", "", 0)
out += metric("webrtc_sessions_rtcp_packets_sent", "", 0)
}
}
ctx.Writer.WriteHeader(http.StatusOK)
io.WriteString(ctx.Writer, out) //nolint:errcheck
}
// SetPathManager is called by core.
func (m *Metrics) SetPathManager(s defs.APIPathManager) {
m.mutex.Lock()
defer m.mutex.Unlock()
m.pathManager = s
}
// SetHLSServer is called by core.
func (m *Metrics) SetHLSServer(s defs.APIHLSServer) {
m.mutex.Lock()
defer m.mutex.Unlock()
m.hlsServer = s
}
// SetRTSPServer is called by core.
func (m *Metrics) SetRTSPServer(s defs.APIRTSPServer) {
m.mutex.Lock()
defer m.mutex.Unlock()
m.rtspServer = s
}
// SetRTSPSServer is called by core.
func (m *Metrics) SetRTSPSServer(s defs.APIRTSPServer) {
m.mutex.Lock()
defer m.mutex.Unlock()
m.rtspsServer = s
}
// SetRTMPServer is called by core.
func (m *Metrics) SetRTMPServer(s defs.APIRTMPServer) {
m.mutex.Lock()
defer m.mutex.Unlock()
m.rtmpServer = s
}
// SetRTMPSServer is called by core.
func (m *Metrics) SetRTMPSServer(s defs.APIRTMPServer) {
m.mutex.Lock()
defer m.mutex.Unlock()
m.rtmpsServer = s
}
// SetSRTServer is called by core.
func (m *Metrics) SetSRTServer(s defs.APISRTServer) {
m.mutex.Lock()
defer m.mutex.Unlock()
m.srtServer = s
}
// SetWebRTCServer is called by core.
func (m *Metrics) SetWebRTCServer(s defs.APIWebRTCServer) {
m.mutex.Lock()
defer m.mutex.Unlock()
m.webRTCServer = s
}
================================================
FILE: internal/metrics/metrics_test.go
================================================
package metrics //nolint:revive
import (
"fmt"
"io"
"net/http"
"strings"
"testing"
"time"
"github.com/bluenviron/mediamtx/internal/auth"
"github.com/bluenviron/mediamtx/internal/conf"
"github.com/bluenviron/mediamtx/internal/defs"
"github.com/bluenviron/mediamtx/internal/logger"
"github.com/bluenviron/mediamtx/internal/test"
"github.com/google/uuid"
"github.com/stretchr/testify/require"
)
func ptrOf[T any](v T) *T {
p := new(T)
*p = v
return p
}
func requireMetricsLines(t *testing.T, body []byte, lines []string) {
t.Helper()
got := string(body)
for _, line := range lines {
require.Contains(t, got, line+"\n")
}
nonEmptyLines := strings.Count(strings.TrimSpace(got), "\n") + 1
require.GreaterOrEqual(t, nonEmptyLines, len(lines))
}
type dummyPathManager struct{}
func (dummyPathManager) APIPathsList() (*defs.APIPathList, error) {
return &defs.APIPathList{
ItemCount: 1,
PageCount: 1,
Items: []defs.APIPath{{
Name: "mypath",
ConfName: "mypathconf",
Source: &defs.APIPathSource{
Type: defs.APIPathSourceTypeRTSPSession,
ID: "123324354",
},
Ready: true,
ReadyTime: ptrOf(time.Date(2003, 11, 4, 23, 15, 7, 0, time.UTC)),
Tracks: []defs.APIPathTrackCodec{defs.APIPathTrackCodecH264, defs.APIPathTrackCodecH265},
InboundBytes: 123,
OutboundBytes: 456,
InboundFramesInError: 7,
BytesReceived: 123,
BytesSent: 456,
Readers: []defs.APIPathReader{
{
Type: defs.APIPathReaderTypeRTSPSession,
ID: "345234423",
},
},
}},
}, nil
}
func (dummyPathManager) APIPathsGet(string) (*defs.APIPath, error) {
panic("unused")
}
type dummyHLSServer struct{}
func (dummyHLSServer) APIMuxersList() (*defs.APIHLSMuxerList, error) {
return &defs.APIHLSMuxerList{
ItemCount: 1,
PageCount: 1,
Items: []defs.APIHLSMuxer{{
Path: "mypath",
Created: time.Date(2003, 11, 4, 23, 15, 7, 0, time.UTC),
LastRequest: time.Date(2003, 11, 4, 23, 15, 7, 0, time.UTC),
OutboundBytes: 789,
OutboundFramesDiscarded: 12,
BytesSent: 789,
}},
}, nil
}
func (dummyHLSServer) APIMuxersGet(string) (*defs.APIHLSMuxer, error) {
panic("unused")
}
type dummyRTSPServer struct{}
func (dummyRTSPServer) APIConnsList() (*defs.APIRTSPConnsList, error) {
return &defs.APIRTSPConnsList{
ItemCount: 1,
PageCount: 1,
Items: []defs.APIRTSPConn{{
ID: uuid.MustParse("18294761-f9d1-4ea9-9a35-fe265b62eb41"),
Created: time.Date(2003, 11, 4, 23, 15, 7, 0, time.UTC),
RemoteAddr: "124.5.5.5:34542",
InboundBytes: 123,
OutboundBytes: 456,
BytesReceived: 123,
BytesSent: 456,
Session: nil,
}},
}, nil
}
func (dummyRTSPServer) APIConnsGet(uuid.UUID) (*defs.APIRTSPConn, error) {
panic("unused")
}
func (dummyRTSPServer) APISessionsList() (*defs.APIRTSPSessionList, error) {
return &defs.APIRTSPSessionList{
ItemCount: 1,
PageCount: 1,
Items: []defs.APIRTSPSession{{
ID: uuid.MustParse("124b22ce-9c34-4387-b045-44caf98049f7"),
Created: time.Date(2003, 11, 4, 23, 15, 7, 0, time.UTC),
RemoteAddr: "124.5.5.5:34542",
State: defs.APIRTSPSessionStatePublish,
Path: "mypath",
Query: "myquery",
Transport: nil,
InboundBytes: 123,
InboundRTPPackets: 789,
InboundRTPPacketsLost: 456,
InboundRTPPacketsInError: 789,
InboundRTPPacketsJitter: 123,
InboundRTCPPackets: 456,
InboundRTCPPacketsInError: 456,
OutboundBytes: 456,
OutboundRTPPackets: 123,
OutboundRTPPacketsReportedLost: 321,
OutboundRTPPacketsDiscarded: 111,
OutboundRTCPPackets: 789,
BytesReceived: 123,
BytesSent: 456,
RTPPacketsReceived: 789,
RTPPacketsSent: 123,
RTPPacketsLost: 456,
RTPPacketsInError: 789,
RTPPacketsJitter: 123,
RTCPPacketsReceived: 456,
RTCPPacketsSent: 789,
RTCPPacketsInError: 456,
}},
}, nil
}
func (dummyRTSPServer) APISessionsGet(uuid.UUID) (*defs.APIRTSPSession, error) {
panic("unused")
}
func (dummyRTSPServer) APISessionsKick(uuid.UUID) error {
panic("unused")
}
type dummyRTMPServer struct{}
func (dummyRTMPServer) APIConnsList() (*defs.APIRTMPConnList, error) {
return &defs.APIRTMPConnList{
ItemCount: 1,
PageCount: 1,
Items: []defs.APIRTMPConn{{
ID: uuid.MustParse("9a07afe4-fc07-4c9b-be6e-6255720c36d0"),
Created: time.Date(2003, 11, 4, 23, 15, 7, 0, time.UTC),
RemoteAddr: "3.3.3.3:5678",
State: defs.APIRTMPConnStateRead,
Path: "mypath",
Query: "myquery",
InboundBytes: 123,
OutboundBytes: 456,
OutboundFramesDiscarded: 12,
BytesReceived: 123,
BytesSent: 456,
}},
}, nil
}
func (dummyRTMPServer) APIConnsGet(uuid.UUID) (*defs.APIRTMPConn, error) {
panic("unused")
}
func (dummyRTMPServer) APIConnsKick(uuid.UUID) error {
panic("unused")
}
type dummyWebRTCServer struct{}
func (dummyWebRTCServer) APISessionsList() (*defs.APIWebRTCSessionList, error) {
return &defs.APIWebRTCSessionList{
ItemCount: 1,
PageCount: 1,
Items: []defs.APIWebRTCSession{{
ID: uuid.MustParse("f47ac10b-58cc-4372-a567-0e02b2c3d479"),
Created: time.Date(2003, 11, 4, 23, 15, 7, 0, time.UTC),
RemoteAddr: "127.0.0.1:3455",
PeerConnectionEstablished: true,
LocalCandidate: "local",
RemoteCandidate: "remote",
State: defs.APIWebRTCSessionStateRead,
Path: "mypath",
Query: "myquery",
InboundBytes: 123,
InboundRTPPackets: 789,
InboundRTPPacketsLost: 456,
InboundRTPPacketsJitter: 789,
InboundRTCPPackets: 123,
OutboundBytes: 456,
OutboundRTPPackets: 123,
OutboundRTCPPackets: 456,
OutboundFramesDiscarded: 12,
BytesReceived: 123,
BytesSent: 456,
RTPPacketsReceived: 789,
RTPPacketsSent: 123,
RTPPacketsLost: 456,
RTPPacketsJitter: 789,
RTCPPacketsReceived: 123,
RTCPPacketsSent: 456,
}},
}, nil
}
func (dummyWebRTCServer) APISessionsGet(uuid.UUID) (*defs.APIWebRTCSession, error) {
panic("unused")
}
func (dummyWebRTCServer) APISessionsKick(uuid.UUID) error {
panic("unused")
}
func TestPreflightRequest(t *testing.T) {
m := Metrics{
Address: "localhost:9998",
AllowOrigins: []string{"*"},
ReadTimeout: conf.Duration(10 * time.Second),
WriteTimeout: conf.Duration(10 * time.Second),
AuthManager: test.NilAuthManager,
Parent: test.NilLogger,
}
err := m.Initialize()
require.NoError(t, err)
defer m.Close()
tr := &http.Transport{}
defer tr.CloseIdleConnections()
hc := &http.Client{Transport: tr}
req, err := http.NewRequest(http.MethodOptions, "http://localhost:9998", nil)
require.NoError(t, err)
req.Header.Add("Access-Control-Request-Method", "GET")
res, err := hc.Do(req)
require.NoError(t, err)
defer res.Body.Close()
require.Equal(t, http.StatusNoContent, res.StatusCode)
byts, err := io.ReadAll(res.Body)
require.NoError(t, err)
require.Equal(t, "*", res.Header.Get("Access-Control-Allow-Origin"))
require.Equal(t, "true", res.Header.Get("Access-Control-Allow-Credentials"))
require.Equal(t, "OPTIONS, GET", res.Header.Get("Access-Control-Allow-Methods"))
require.Equal(t, "Authorization", res.Header.Get("Access-Control-Allow-Headers"))
require.Equal(t, byts, []byte{})
}
func TestMetrics(t *testing.T) {
checked := false
m := Metrics{
Address: "localhost:9998",
AllowOrigins: []string{"*"},
ReadTimeout: conf.Duration(10 * time.Second),
WriteTimeout: conf.Duration(10 * time.Second),
AuthManager: &test.AuthManager{
AuthenticateImpl: func(req *auth.Request) (string, *auth.Error) {
require.Equal(t, conf.AuthActionMetrics, req.Action)
require.Equal(t, "myuser", req.Credentials.User)
require.Equal(t, "mypass", req.Credentials.Pass)
checked = true
return req.Credentials.User, nil
},
},
Parent: test.NilLogger,
}
err := m.Initialize()
require.NoError(t, err)
defer m.Close()
m.SetPathManager(&dummyPathManager{})
m.SetHLSServer(&dummyHLSServer{})
m.SetRTSPServer(&dummyRTSPServer{})
m.SetRTSPSServer(&dummyRTSPServer{})
m.SetRTMPServer(&dummyRTMPServer{})
m.SetRTMPSServer(&dummyRTMPServer{})
m.SetWebRTCServer(&dummyWebRTCServer{})
tr := &http.Transport{}
defer tr.CloseIdleConnections()
hc := &http.Client{Transport: tr}
res, err := hc.Get("http://myuser:mypass@localhost:9998/metrics")
require.NoError(t, err)
defer res.Body.Close()
require.Equal(t, http.StatusOK, res.StatusCode)
byts, err := io.ReadAll(res.Body)
require.NoError(t, err)
requireMetricsLines(t, byts, []string{
`paths{name="mypath",state="ready"} 1`,
`paths_inbound_bytes{name="mypath",state="ready"} 123`,
`paths_outbound_bytes{name="mypath",state="ready"} 456`,
`paths_inbound_frames_in_error{name="mypath",state="ready"} 7`,
`paths_bytes_received{name="mypath",state="ready"} 123`,
`paths_bytes_sent{name="mypath",state="ready"} 456`,
`paths_readers{name="mypath",state="ready"} 1`,
`hls_muxers{name="mypath"} 1`,
`hls_muxers_outbound_bytes{name="mypath"} 789`,
`hls_muxers_outbound_frames_discarded{name="mypath"} 12`,
`rtsp_conns_inbound_bytes{id="18294761-f9d1-4ea9-9a35-fe265b62eb41"} 123`,
`rtsp_sessions_outbound_rtp_packets_discarded{id="124b22ce-9c34-4387-b045-44caf98049f7",` +
`path="mypath",remoteAddr="124.5.5.5:34542",state="publish"} 111`,
`rtsps_sessions_outbound_rtp_packets_discarded{id="124b22ce-9c34-4387-b045-44caf98049f7",` +
`path="mypath",remoteAddr="124.5.5.5:34542",state="publish"} 111`,
`rtmp_conns_inbound_bytes{id="9a07afe4-fc07-4c9b-be6e-6255720c36d0",` +
`path="mypath",remoteAddr="3.3.3.3:5678",state="read"} 123`,
`rtmp_conns_outbound_bytes{id="9a07afe4-fc07-4c9b-be6e-6255720c36d0",` +
`path="mypath",remoteAddr="3.3.3.3:5678",state="read"} 456`,
`rtmp_conns_outbound_frames_discarded{id="9a07afe4-fc07-4c9b-be6e-6255720c36d0",` +
`path="mypath",remoteAddr="3.3.3.3:5678",state="read"} 12`,
`rtmp_conns_bytes_received{id="9a07afe4-fc07-4c9b-be6e-6255720c36d0",` +
`path="mypath",remoteAddr="3.3.3.3:5678",state="read"} 123`,
`webrtc_sessions_outbound_bytes{id="f47ac10b-58cc-4372-a567-0e02b2c3d479",` +
`path="mypath",remoteAddr="127.0.0.1:3455",state="read"} 456`,
`webrtc_sessions_outbound_frames_discarded{id="f47ac10b-58cc-4372-a567-0e02b2c3d479",` +
`path="mypath",remoteAddr="127.0.0.1:3455",state="read"} 12`,
})
require.True(t, checked)
}
func TestAuthError(t *testing.T) {
n := 0
m := Metrics{
Address: "localhost:9998",
AllowOrigins: []string{"*"},
ReadTimeout: conf.Duration(10 * time.Second),
WriteTimeout: conf.Duration(10 * time.Second),
AuthManager: &test.AuthManager{
AuthenticateImpl: func(req *auth.Request) (string, *auth.Error) {
if req.Credentials.User == "" {
return "", &auth.Error{AskCredentials: true, Wrapped: fmt.Errorf("auth error")}
}
return "", &auth.Error{Wrapped: fmt.Errorf("auth error")}
},
},
Parent: test.Logger(func(l logger.Level, s string, i ...any) {
if l == logger.Info {
if n == 1 {
require.Regexp(t, "failed to authenticate: auth error$", fmt.Sprintf(s, i...))
}
n++
}
}),
}
err := m.Initialize()
require.NoError(t, err)
defer m.Close()
tr := &http.Transport{}
defer tr.CloseIdleConnections()
hc := &http.Client{Transport: tr}
res, err := hc.Get("http://localhost:9998/metrics")
require.NoError(t, err)
defer res.Body.Close()
require.Equal(t, http.StatusUnauthorized, res.StatusCode)
require.Equal(t, `Basic realm="mediamtx"`, res.Header.Get("WWW-Authenticate"))
res, err = hc.Get("http://myuser:mypass@localhost:9998/metrics")
require.NoError(t, err)
defer res.Body.Close()
require.Equal(t, http.StatusUnauthorized, res.StatusCode)
require.Equal(t, 2, n)
}
func TestFilter(t *testing.T) {
for _, ca := range []string{
"path",
"hls_muxer",
"rtsp_conn",
"rtsp_session",
// "rtsps_conn",
// "rtsps_session",
// "rtmp_conn",
// "rtmps_conn",
// "srt_conn",
// "webrtc_session",
} {
t.Run(ca, func(t *testing.T) {
m := Metrics{
Address: "localhost:9998",
AllowOrigins: []string{"*"},
ReadTimeout: conf.Duration(10 * time.Second),
WriteTimeout: conf.Duration(10 * time.Second),
AuthManager: test.NilAuthManager,
Parent: test.NilLogger,
}
err := m.Initialize()
require.NoError(t, err)
defer m.Close()
m.SetPathManager(&dummyPathManager{})
m.SetHLSServer(&dummyHLSServer{})
m.SetRTSPServer(&dummyRTSPServer{})
m.SetWebRTCServer(&dummyWebRTCServer{})
tr := &http.Transport{}
defer tr.CloseIdleConnections()
hc := &http.Client{Transport: tr}
u := "http://localhost:9998/metrics"
switch ca {
case "path":
u += "?path=mypath"
case "hls_muxer":
u += "?hls_muxer=mypath"
case "rtsp_conn":
u += "?rtsp_conn=18294761-f9d1-4ea9-9a35-fe265b62eb41"
case "rtsp_session":
u += "?rtsp_session=124b22ce-9c34-4387-b045-44caf98049f7"
}
res, err := hc.Get(u)
require.NoError(t, err)
defer res.Body.Close()
byts, err := io.ReadAll(res.Body)
require.NoError(t, err)
switch ca {
case "path":
require.Equal(t,
`paths{name="mypath",state="ready"} 1`+"\n"+
`paths_inbound_bytes{name="mypath",state="ready"} 123`+"\n"+
`paths_outbound_bytes{name="mypath",state="ready"} 456`+"\n"+
`paths_inbound_frames_in_error{name="mypath",state="ready"} 7`+"\n"+
`paths_bytes_received{name="mypath",state="ready"} 123`+"\n"+
`paths_bytes_sent{name="mypath",state="ready"} 456`+"\n"+
`paths_readers{name="mypath",state="ready"} 1`+"\n",
string(byts))
case "hls_muxer":
require.Equal(t,
`hls_muxers{name="mypath"} 1`+"\n"+
`hls_muxers_outbound_bytes{name="mypath"} 789`+"\n"+
`hls_muxers_outbound_frames_discarded{name="mypath"} 12`+"\n"+
`hls_muxers_bytes_sent{name="mypath"} 789`+"\n",
string(byts))
case "rtsp_conn":
require.Equal(t,
`rtsp_conns{id="18294761-f9d1-4ea9-9a35-fe265b62eb41"} 1`+"\n"+
`rtsp_conns_inbound_bytes{id="18294761-f9d1-4ea9-9a35-fe265b62eb41"} 123`+"\n"+
`rtsp_conns_outbound_bytes{id="18294761-f9d1-4ea9-9a35-fe265b62eb41"} 456`+"\n"+
`rtsp_conns_bytes_received{id="18294761-f9d1-4ea9-9a35-fe265b62eb41"} 123`+"\n"+
`rtsp_conns_bytes_sent{id="18294761-f9d1-4ea9-9a35-fe265b62eb41"} 456`+"\n",
string(byts))
case "rtsp_session":
require.Equal(t,
`rtsp_sessions{id="124b22ce-9c34-4387-b045-44caf98049f7",`+
`path="mypath",remoteAddr="124.5.5.5:34542",state="publish"} 1`+"\n"+
`rtsp_sessions_inbound_bytes{id="124b22ce-9c34-4387-b045-44caf98049f7",`+
`path="mypath",remoteAddr="124.5.5.5:34542",state="publish"} 123`+"\n"+
`rtsp_sessions_inbound_rtp_packets{id="124b22ce-9c34-4387-b045-44caf98049f7",`+
`path="mypath",remoteAddr="124.5.5.5:34542",state="publish"} 789`+"\n"+
`rtsp_sessions_inbound_rtp_packets_lost{id="124b22ce-9c34-4387-b045-44caf98049f7",`+
`path="mypath",remoteAddr="124.5.5.5:34542",state="publish"} 456`+"\n"+
`rtsp_sessions_inbound_rtp_packets_in_error{id="124b22ce-9c34-4387-b045-44caf98049f7",`+
`path="mypath",remoteAddr="124.5.5.5:34542",state="publish"} 789`+"\n"+
`rtsp_sessions_inbound_rtp_packets_jitter{id="124b22ce-9c34-4387-b045-44caf98049f7",`+
`path="mypath",remoteAddr="124.5.5.5:34542",state="publish"} 123`+"\n"+
`rtsp_sessions_inbound_rtcp_packets{id="124b22ce-9c34-4387-b045-44caf98049f7",`+
`path="mypath",remoteAddr="124.5.5.5:34542",state="publish"} 456`+"\n"+
`rtsp_sessions_inbound_rtcp_packets_in_error{id="124b22ce-9c34-4387-b045-44caf98049f7",`+
`path="mypath",remoteAddr="124.5.5.5:34542",state="publish"} 456`+"\n"+
`rtsp_sessions_outbound_bytes{id="124b22ce-9c34-4387-b045-44caf98049f7",`+
`path="mypath",remoteAddr="124.5.5.5:34542",state="publish"} 456`+"\n"+
`rtsp_sessions_outbound_rtp_packets{id="124b22ce-9c34-4387-b045-44caf98049f7",`+
`path="mypath",remoteAddr="124.5.5.5:34542",state="publish"} 123`+"\n"+
`rtsp_sessions_outbound_rtp_packets_reported_lost{id="124b22ce-9c34-4387-b045-44caf98049f7",`+
`path="mypath",remoteAddr="124.5.5.5:34542",state="publish"} 321`+"\n"+
`rtsp_sessions_outbound_rtp_packets_discarded{id="124b22ce-9c34-4387-b045-44caf98049f7",`+
`path="mypath",remoteAddr="124.5.5.5:34542",state="publish"} 111`+"\n"+
`rtsp_sessions_outbound_rtcp_packets{id="124b22ce-9c34-4387-b045-44caf98049f7",`+
`path="mypath",remoteAddr="124.5.5.5:34542",state="publish"} 789`+"\n"+
`rtsp_sessions_bytes_received{id="124b22ce-9c34-4387-b045-44caf98049f7",`+
`path="mypath",remoteAddr="124.5.5.5:34542",state="publish"} 123`+"\n"+
`rtsp_sessions_bytes_sent{id="124b22ce-9c34-4387-b045-44caf98049f7",`+
`path="mypath",remoteAddr="124.5.5.5:34542",state="publish"} 456`+"\n"+
`rtsp_sessions_rtp_packets_received{id="124b22ce-9c34-4387-b045-44caf98049f7",`+
`path="mypath",remoteAddr="124.5.5.5:34542",state="publish"} 789`+"\n"+
`rtsp_sessions_rtp_packets_sent{id="124b22ce-9c34-4387-b045-44caf98049f7",`+
`path="mypath",remoteAddr="124.5.5.5:34542",state="publish"} 123`+"\n"+
`rtsp_sessions_rtp_packets_lost{id="124b22ce-9c34-4387-b045-44caf98049f7",`+
`path="mypath",remoteAddr="124.5.5.5:34542",state="publish"} 456`+"\n"+
`rtsp_sessions_rtp_packets_in_error{id="124b22ce-9c34-4387-b045-44caf98049f7",`+
`path="mypath",remoteAddr="124.5.5.5:34542",state="publish"} 789`+"\n"+
`rtsp_sessions_rtp_packets_jitter{id="124b22ce-9c34-4387-b045-44caf98049f7",`+
`path="mypath",remoteAddr="124.5.5.5:34542",state="publish"} 123`+"\n"+
`rtsp_sessions_rtcp_packets_received{id="124b22ce-9c34-4387-b045-44caf98049f7",`+
`path="mypath",remoteAddr="124.5.5.5:34542",state="publish"} 456`+"\n"+
`rtsp_sessions_rtcp_packets_sent{id="124b22ce-9c34-4387-b045-44caf98049f7",`+
`path="mypath",remoteAddr="124.5.5.5:34542",state="publish"} 789`+"\n"+
`rtsp_sessions_rtcp_packets_in_error{id="124b22ce-9c34-4387-b045-44caf98049f7",`+
`path="mypath",remoteAddr="124.5.5.5:34542",state="publish"} 456`+"\n",
string(byts))
}
})
}
}
================================================
FILE: internal/ntpestimator/estimator.go
================================================
// Package ntpestimator contains a NTP estimator.
package ntpestimator
import (
"time"
)
const (
maxTimeDifference = 5 * time.Second
)
var timeNow = time.Now
func multiplyAndDivide(v, m, d time.Duration) time.Duration {
secs := v / d
dec := v % d
return (secs*m + dec*m/d)
}
// Estimator is a NTP estimator.
type Estimator struct {
ClockRate int
refNTP time.Time
refPTS int64
}
var zero = time.Time{}
// Estimate returns estimated NTP.
func (e *Estimator) Estimate(pts int64) time.Time {
now := timeNow()
// do not store monotonic clock, in order to include
// system clock changes into time differences
now = now.Round(0)
if e.refNTP.Equal(zero) {
e.refNTP = now
e.refPTS = pts
return now
}
computed := e.refNTP.Add((multiplyAndDivide(time.Duration(pts-e.refPTS), time.Second, time.Duration(e.ClockRate))))
if computed.After(now) || computed.Before(now.Add(-maxTimeDifference)) {
e.refNTP = now
e.refPTS = pts
return now
}
return computed
}
================================================
FILE: internal/ntpestimator/estimator_test.go
================================================
package ntpestimator
import (
"testing"
"time"
"github.com/stretchr/testify/require"
)
func TestEstimator(t *testing.T) {
e := &Estimator{ClockRate: 90000}
timeNow = func() time.Time { return time.Date(2003, 11, 4, 23, 15, 7, 0, time.UTC) }
ntp := e.Estimate(90000)
require.Equal(t, time.Date(2003, 11, 4, 23, 15, 7, 0, time.UTC), ntp)
timeNow = func() time.Time { return time.Date(2003, 11, 4, 23, 15, 8, 0, time.UTC) }
ntp = e.Estimate(2 * 90000)
require.Equal(t, time.Date(2003, 11, 4, 23, 15, 8, 0, time.UTC), ntp)
timeNow = func() time.Time { return time.Date(2003, 11, 4, 23, 15, 10, 0, time.UTC) }
ntp = e.Estimate(3 * 90000)
require.Equal(t, time.Date(2003, 11, 4, 23, 15, 9, 0, time.UTC), ntp)
timeNow = func() time.Time { return time.Date(2003, 11, 4, 23, 15, 9, 0, time.UTC) }
ntp = e.Estimate(4 * 90000)
require.Equal(t, time.Date(2003, 11, 4, 23, 15, 9, 0, time.UTC), ntp)
timeNow = func() time.Time { return time.Date(2003, 11, 4, 23, 15, 15, 0, time.UTC) }
ntp = e.Estimate(5 * 90000)
require.Equal(t, time.Date(2003, 11, 4, 23, 15, 10, 0, time.UTC), ntp)
timeNow = func() time.Time { return time.Date(2003, 11, 4, 23, 15, 20, 0, time.UTC) }
ntp = e.Estimate(6 * 90000)
require.Equal(t, time.Date(2003, 11, 4, 23, 15, 20, 0, time.UTC), ntp)
}
================================================
FILE: internal/packetdumper/conn.go
================================================
// Package packetdumper provides utilities to dump packets to disk.
package packetdumper
import (
"fmt"
"net"
"os"
"sync"
"time"
"github.com/google/gopacket"
"github.com/google/gopacket/layers"
"github.com/google/gopacket/pcapgo"
"github.com/google/uuid"
)
var _ net.Conn = (*Conn)(nil)
type direction int
const (
dirRead direction = iota
dirWrite
dirHandshake
)
type dumpEntry struct {
ntp time.Time
data []byte
direction direction
}
// Conn is a wrapper around net.Conn that dumps packets to disk.
type Conn struct {
Prefix string
Conn net.Conn
ServerSide bool
f *os.File
pw *pcapgo.NgWriter
once sync.Once
queue chan dumpEntry
terminated chan struct{}
done chan struct{}
}
// Initialize initializes Conn.
func (c *Conn) Initialize() error {
var err error
c.f, err = os.Create(fmt.Sprintf("%s_%d_%s.pcapng", c.Prefix, time.Now().UnixNano(), uuid.New().String()))
if err != nil {
return err
}
c.pw, err = pcapgo.NewNgWriter(c.f, layers.LinkTypeEthernet)
if err != nil {
c.f.Close()
return err
}
c.queue = make(chan dumpEntry, 64)
c.terminated = make(chan struct{})
c.done = make(chan struct{})
go c.run()
c.enqueue(dumpEntry{ntp: time.Now(), direction: dirHandshake})
return nil
}
// Close implements net.Conn.
func (c *Conn) Close() error {
c.once.Do(func() {
close(c.terminated)
})
<-c.done
return c.Conn.Close()
}
func (c *Conn) run() {
defer close(c.done)
defer c.f.Close()
local := c.Conn.LocalAddr().(*net.TCPAddr)
remote := c.Conn.RemoteAddr().(*net.TCPAddr)
nextLocalSequence := uint32(1000)
nextRemoteSequence := uint32(2000)
for {
select {
case e := <-c.queue:
c.processEntry(e, local, remote, &nextLocalSequence, &nextRemoteSequence)
case <-c.terminated:
// Drain anything already in the queue before exiting.
for {
select {
case e := <-c.queue:
c.processEntry(e, local, remote, &nextLocalSequence, &nextRemoteSequence)
default:
c.pw.Flush() //nolint:errcheck
return
}
}
}
}
}
func (c *Conn) processEntry(
e dumpEntry,
local, remote *net.TCPAddr,
nextLocalSequence, nextRemoteSequence *uint32,
) {
switch e.direction {
case dirHandshake:
clientAddr, serverAddr := local, remote // client side: local initiates
clientSeq, serverSeq := nextLocalSequence, nextRemoteSequence
if c.ServerSide {
clientAddr, serverAddr = remote, local // server side: remote initiated
clientSeq, serverSeq = nextRemoteSequence, nextLocalSequence
}
// SYN (client -> server)
c.writePacket(e.ntp, clientAddr, serverAddr,
layers.TCP{SYN: true, Window: 65535, Seq: *clientSeq, Ack: 0}, nil)
*clientSeq++
// SYN-ACK (server -> client)
c.writePacket(e.ntp, serverAddr, clientAddr,
layers.TCP{SYN: true, ACK: true, Window: 65535, Seq: *serverSeq, Ack: *clientSeq}, nil)
*serverSeq++
// ACK (client -> server)
c.writePacket(e.ntp, clientAddr, serverAddr,
layers.TCP{ACK: true, Window: 65535, Seq: *clientSeq, Ack: *serverSeq}, nil)
case dirRead:
tcpFlags := layers.TCP{
PSH: true,
ACK: true,
Window: 14600,
Seq: *nextRemoteSequence,
Ack: *nextLocalSequence,
}
c.writePacket(e.ntp, remote, local, tcpFlags, e.data)
*nextRemoteSequence += uint32(len(e.data))
case dirWrite:
tcpFlags := layers.TCP{
PSH: true,
ACK: true,
Window: 14600,
Seq: *nextLocalSequence,
Ack: *nextRemoteSequence,
}
c.writePacket(e.ntp, local, remote, tcpFlags, e.data)
*nextLocalSequence += uint32(len(e.data))
}
}
func (c *Conn) writePacket(
ntp time.Time,
src, dst *net.TCPAddr,
tcpFlags layers.TCP,
payload []byte,
) {
eth := &layers.Ethernet{
SrcMAC: net.HardwareAddr{0, 0, 0, 0, 0, 0},
DstMAC: net.HardwareAddr{0, 0, 0, 0, 0, 0},
EthernetType: layers.EthernetTypeIPv6,
}
ipv6 := &layers.IPv6{
Version: 6,
SrcIP: src.IP.To16(),
DstIP: dst.IP.To16(),
NextHeader: layers.IPProtocolTCP,
HopLimit: 64,
}
tcp := &layers.TCP{
SrcPort: layers.TCPPort(src.Port),
DstPort: layers.TCPPort(dst.Port),
Seq: tcpFlags.Seq,
Ack: tcpFlags.Ack,
Window: tcpFlags.Window,
SYN: tcpFlags.SYN,
ACK: tcpFlags.ACK,
PSH: tcpFlags.PSH,
FIN: tcpFlags.FIN,
}
tcp.SetNetworkLayerForChecksum(ipv6) //nolint:errcheck
buf := gopacket.NewSerializeBuffer()
opts := gopacket.SerializeOptions{FixLengths: true, ComputeChecksums: true}
gopacket.SerializeLayers(buf, opts, eth, ipv6, tcp, gopacket.Payload(payload)) //nolint:errcheck
raw := buf.Bytes()
c.pw.WritePacket(gopacket.CaptureInfo{ //nolint:errcheck
Timestamp: ntp,
CaptureLength: len(raw),
Length: len(raw),
}, raw)
}
func (c *Conn) enqueue(e dumpEntry) {
select {
case c.queue <- e:
case <-c.terminated:
}
}
func (c *Conn) Read(p []byte) (n int, err error) {
n, err = c.Conn.Read(p)
if n != 0 {
c.enqueue(dumpEntry{
ntp: time.Now(),
data: append([]byte(nil), p[:n]...),
direction: dirRead,
})
}
return n, err
}
func (c *Conn) Write(p []byte) (n int, err error) {
n, err = c.Conn.Write(p)
if err == nil {
c.enqueue(dumpEntry{
ntp: time.Now(),
data: append([]byte(nil), p...),
direction: dirWrite,
})
}
return n, err
}
// LocalAddr implements net.Conn.
func (c *Conn) LocalAddr() net.Addr { return c.Conn.LocalAddr() }
// RemoteAddr implements net.Conn.
func (c *Conn) RemoteAddr() net.Addr { return c.Conn.RemoteAddr() }
// SetDeadline implements net.Conn.
func (c *Conn) SetDeadline(t time.Time) error { return c.Conn.SetDeadline(t) }
// SetReadDeadline implements net.Conn.
func (c *Conn) SetReadDeadline(t time.Time) error { return c.Conn.SetReadDeadline(t) }
// SetWriteDeadline implements net.Conn.
func (c *Conn) SetWriteDeadline(t time.Time) error { return c.Conn.SetWriteDeadline(t) }
================================================
FILE: internal/packetdumper/conn_test.go
================================================
package packetdumper
import (
"io"
"net"
"os"
"path/filepath"
"testing"
"time"
"github.com/stretchr/testify/require"
)
// startTCPPair dials a local TCP listener and returns both ends of the connection.
func startTCPPair(t *testing.T) (client, server net.Conn) {
t.Helper()
ln, err := net.Listen("tcp", "127.0.0.1:0")
require.NoError(t, err)
serverCh := make(chan net.Conn, 1)
go func() {
conn, err2 := ln.Accept()
if err2 == nil {
serverCh <- conn
}
}()
client, err = net.Dial("tcp", ln.Addr().String())
require.NoError(t, err)
t.Cleanup(func() { ln.Close() })
select {
case server = <-serverCh:
case <-time.After(2 * time.Second):
t.Fatal("timed out waiting for server connection")
}
return client, server
}
func cleanupPcapng(t *testing.T, prefix string) {
t.Helper()
matches, err := filepath.Glob(prefix + "_*.pcapng")
require.NoError(t, err, "glob for pcapng files")
require.NotEmpty(t, matches, "expected at least one pcapng file to have been created")
for _, f := range matches {
require.NoError(t, os.Remove(f), "removing pcapng file %s", f)
}
}
func TestConnInitialize_CreatesFile(t *testing.T) {
client, server := startTCPPair(t)
defer server.Close()
prefix := filepath.Join(t.TempDir(), "capture")
c := &Conn{Prefix: prefix, Conn: client}
require.NoError(t, c.Initialize())
defer cleanupPcapng(t, prefix)
defer c.Close() //nolint:errcheck
}
func TestConnWrite(t *testing.T) {
client, server := startTCPPair(t)
defer server.Close()
prefix := filepath.Join(t.TempDir(), "capture")
c := &Conn{Prefix: prefix, Conn: client}
require.NoError(t, c.Initialize())
defer cleanupPcapng(t, prefix)
defer c.Close() //nolint:errcheck
n, err := c.Write([]byte("hello world"))
require.NoError(t, err)
require.Equal(t, 11, n)
buf := make([]byte, 11)
_, err = io.ReadFull(server, buf)
require.NoError(t, err)
require.Equal(t, []byte("hello world"), buf)
}
func TestConnRead(t *testing.T) {
client, server := startTCPPair(t)
defer server.Close()
prefix := filepath.Join(t.TempDir(), "capture")
c := &Conn{Prefix: prefix, Conn: client}
require.NoError(t, c.Initialize())
defer cleanupPcapng(t, prefix)
defer c.Close() //nolint:errcheck
_, err := server.Write([]byte("incoming data"))
require.NoError(t, err)
buf := make([]byte, 32)
n, err := c.Read(buf)
require.NoError(t, err)
require.Equal(t, []byte("incoming data"), buf[:n])
}
func TestConnServerSide(t *testing.T) {
client, server := startTCPPair(t)
defer client.Close()
prefix := filepath.Join(t.TempDir(), "capture")
c := &Conn{Prefix: prefix, Conn: server, ServerSide: true}
require.NoError(t, c.Initialize())
defer cleanupPcapng(t, prefix)
defer c.Close() //nolint:errcheck
n, err := c.Write([]byte("server response"))
require.NoError(t, err)
require.Equal(t, 15, n)
buf := make([]byte, 15)
_, err = io.ReadFull(client, buf)
require.NoError(t, err)
require.Equal(t, []byte("server response"), buf)
}
func TestConnMultipleWriteRead(t *testing.T) {
client, server := startTCPPair(t)
defer server.Close()
prefix := filepath.Join(t.TempDir(), "capture")
c := &Conn{Prefix: prefix, Conn: client}
require.NoError(t, c.Initialize())
defer cleanupPcapng(t, prefix)
defer c.Close() //nolint:errcheck
for _, msg := range []string{"foo", "bar", "baz"} {
n, err := c.Write([]byte(msg))
require.NoError(t, err)
require.Equal(t, len(msg), n)
}
buf := make([]byte, len("foobarbaz"))
_, err := io.ReadFull(server, buf)
require.NoError(t, err)
require.Equal(t, []byte("foobarbaz"), buf)
_, err = server.Write([]byte("abcde"))
require.NoError(t, err)
_, err = server.Write([]byte("fghij"))
require.NoError(t, err)
readBuf := make([]byte, 10)
_, err = io.ReadFull(c, readBuf)
require.NoError(t, err)
require.Equal(t, []byte("abcdefghij"), readBuf)
}
func TestConnCloseIdempotent(t *testing.T) {
client, server := startTCPPair(t)
defer server.Close()
prefix := filepath.Join(t.TempDir(), "capture")
c := &Conn{Prefix: prefix, Conn: client}
require.NoError(t, c.Initialize())
defer cleanupPcapng(t, prefix)
defer c.Close() //nolint:errcheck
defer c.Close() //nolint:errcheck
}
func TestConnDelegatesAddrMethods(t *testing.T) {
client, server := startTCPPair(t)
defer server.Close()
prefix := filepath.Join(t.TempDir(), "capture")
c := &Conn{Prefix: prefix, Conn: client}
require.NoError(t, c.Initialize())
defer cleanupPcapng(t, prefix)
defer c.Close() //nolint:errcheck
require.Equal(t, client.LocalAddr(), c.LocalAddr())
require.Equal(t, client.RemoteAddr(), c.RemoteAddr())
require.NoError(t, c.SetDeadline(time.Now().Add(time.Second)))
require.NoError(t, c.SetReadDeadline(time.Now().Add(time.Second)))
require.NoError(t, c.SetWriteDeadline(time.Now().Add(time.Second)))
}
================================================
FILE: internal/packetdumper/dial_context.go
================================================
package packetdumper
import (
"context"
"net"
)
// DialContext is a wrapper around net.Dialer.DialContext that dumps packets to disk.
type DialContext struct {
Prefix string
DialContext func(ctx context.Context, network, address string) (net.Conn, error)
}
// Do mimics net.Dialer.DialContext.
func (d *DialContext) Do(ctx context.Context, network, address string) (net.Conn, error) {
conn, err := d.DialContext(ctx, network, address)
if err != nil {
return nil, err
}
c := &Conn{
Prefix: d.Prefix,
Conn: conn,
}
err = c.Initialize()
if err != nil {
conn.Close()
return nil, err
}
return c, nil
}
================================================
FILE: internal/packetdumper/listen.go
================================================
package packetdumper
import (
"net"
)
// Listen is a wrapper around net.Listen that dumps packets to disk.
type Listen struct {
Prefix string
Listen func(network, address string) (net.Listener, error)
}
// Do mimics net.Listen.
func (l *Listen) Do(network, address string) (net.Listener, error) {
ln, err := l.Listen(network, address)
if err != nil {
return nil, err
}
return &Listener{
Prefix: l.Prefix,
Listener: ln,
}, nil
}
================================================
FILE: internal/packetdumper/listen_packet.go
================================================
package packetdumper
import (
"net"
)
// ListenPacket is a wrapper around net.ListenPacket that dumps packets to disk.
type ListenPacket struct {
Prefix string
ListenPacket func(network, address string) (net.PacketConn, error)
}
// Do mimics net.ListenPacket
func (l *ListenPacket) Do(network, address string) (net.PacketConn, error) {
pc, err := l.ListenPacket(network, address)
if err != nil {
return nil, err
}
d := &PacketConn{
Prefix: l.Prefix,
PacketConn: pc,
}
err = d.Initialize()
if err != nil {
return nil, err
}
return d, nil
}
================================================
FILE: internal/packetdumper/listener.go
================================================
package packetdumper
import "net"
var _ net.Listener = (*Listener)(nil)
// Listener is a wrapper around net.Listener that dumps packets to disk.
type Listener struct {
Prefix string
Listener net.Listener
}
// Accept implements net.Listener.
func (l *Listener) Accept() (net.Conn, error) {
conn, err := l.Listener.Accept()
if err != nil {
return nil, err
}
cd := &Conn{
Prefix: l.Prefix,
Conn: conn,
ServerSide: true,
}
err = cd.Initialize()
if err != nil {
conn.Close() //nolint:errcheck
return nil, err
}
return cd, nil
}
// Close implements net.Listener.
func (l *Listener) Close() error {
return l.Listener.Close()
}
// Addr implements net.Listener.
func (l *Listener) Addr() net.Addr {
return l.Listener.Addr()
}
================================================
FILE: internal/packetdumper/packet_conn.go
================================================
package packetdumper
import (
"fmt"
"net"
"os"
"sync"
"syscall"
"time"
"github.com/google/gopacket"
"github.com/google/gopacket/layers"
"github.com/google/gopacket/pcapgo"
"github.com/google/uuid"
)
var _ net.PacketConn = (*PacketConn)(nil)
type extendedPacketConn interface {
net.PacketConn
SetReadBuffer(bytes int) error
SyscallConn() (syscall.RawConn, error)
}
type packetDumpEntry struct {
ntp time.Time
data []byte
src, dst *net.UDPAddr
}
// PacketConn is a wrapper around net.PacketConn that dumps packets to disk.
type PacketConn struct {
Prefix string
PacketConn net.PacketConn
f *os.File
pw *pcapgo.NgWriter
once sync.Once
queue chan packetDumpEntry
terminated chan struct{}
done chan struct{}
}
// Initialize initializes PacketConn.
func (c *PacketConn) Initialize() error {
var err error
c.f, err = os.Create(fmt.Sprintf("%s_%d_%s.pcapng", c.Prefix, time.Now().UnixNano(), uuid.New().String()))
if err != nil {
return err
}
c.pw, err = pcapgo.NewNgWriter(c.f, layers.LinkTypeEthernet)
if err != nil {
c.f.Close()
return err
}
c.queue = make(chan packetDumpEntry, 64)
c.terminated = make(chan struct{})
c.done = make(chan struct{})
go c.run()
return nil
}
// Close implements net.PacketConn.
func (c *PacketConn) Close() error {
c.once.Do(func() {
close(c.terminated)
})
<-c.done
return c.PacketConn.Close()
}
func (c *PacketConn) run() {
defer close(c.done)
defer c.f.Close()
for {
select {
case e := <-c.queue:
c.writePacket(e.ntp, e.src, e.dst, e.data)
case <-c.terminated:
for {
select {
case e := <-c.queue:
c.writePacket(e.ntp, e.src, e.dst, e.data)
default:
c.pw.Flush() //nolint:errcheck
return
}
}
}
}
}
func (c *PacketConn) writePacket(ntp time.Time, src, dst *net.UDPAddr, payload []byte) {
eth := &layers.Ethernet{
SrcMAC: net.HardwareAddr{0, 0, 0, 0, 0, 0},
DstMAC: net.HardwareAddr{0, 0, 0, 0, 0, 0},
EthernetType: layers.EthernetTypeIPv6,
}
ipv6 := &layers.IPv6{
Version: 6,
SrcIP: src.IP.To16(),
DstIP: dst.IP.To16(),
NextHeader: layers.IPProtocolUDP,
HopLimit: 64,
}
udp := &layers.UDP{
SrcPort: layers.UDPPort(src.Port),
DstPort: layers.UDPPort(dst.Port),
}
udp.SetNetworkLayerForChecksum(ipv6) //nolint:errcheck
buf := gopacket.NewSerializeBuffer()
opts := gopacket.SerializeOptions{FixLengths: true, ComputeChecksums: true}
gopacket.SerializeLayers(buf, opts, eth, ipv6, udp, gopacket.Payload(payload)) //nolint:errcheck
raw := buf.Bytes()
c.pw.WritePacket(gopacket.CaptureInfo{ //nolint:errcheck
Timestamp: ntp,
CaptureLength: len(raw),
Length: len(raw),
}, raw)
}
func (c *PacketConn) enqueue(e packetDumpEntry) {
select {
case c.queue <- e:
case <-c.terminated:
}
}
// ReadFrom implements net.PacketConn.
func (c *PacketConn) ReadFrom(p []byte) (n int, addr net.Addr, err error) {
n, addr, err = c.PacketConn.ReadFrom(p)
if n != 0 {
local := c.PacketConn.LocalAddr().(*net.UDPAddr)
remote := addr.(*net.UDPAddr)
c.enqueue(packetDumpEntry{
ntp: time.Now(),
data: append([]byte(nil), p[:n]...),
src: remote,
dst: local,
})
}
return n, addr, err
}
// WriteTo implements net.PacketConn.
func (c *PacketConn) WriteTo(p []byte, addr net.Addr) (n int, err error) {
n, err = c.PacketConn.WriteTo(p, addr)
if err == nil {
local := c.PacketConn.LocalAddr().(*net.UDPAddr)
remote := addr.(*net.UDPAddr)
c.enqueue(packetDumpEntry{
ntp: time.Now(),
data: append([]byte(nil), p...),
src: local,
dst: remote,
})
}
return n, err
}
// LocalAddr implements net.PacketConn.
func (c *PacketConn) LocalAddr() net.Addr { return c.PacketConn.LocalAddr() }
// SetDeadline implements net.PacketConn.
func (c *PacketConn) SetDeadline(t time.Time) error { return c.PacketConn.SetDeadline(t) }
// SetReadDeadline implements net.PacketConn.
func (c *PacketConn) SetReadDeadline(t time.Time) error { return c.PacketConn.SetReadDeadline(t) }
// SetWriteDeadline implements net.PacketConn.
func (c *PacketConn) SetWriteDeadline(t time.Time) error { return c.PacketConn.SetWriteDeadline(t) }
// SetReadBuffer implements extendedPacketConn.
func (c *PacketConn) SetReadBuffer(bytes int) error {
return c.PacketConn.(extendedPacketConn).SetReadBuffer(bytes)
}
// SyscallConn implements extendedPacketConn.
func (c *PacketConn) SyscallConn() (syscall.RawConn, error) {
return c.PacketConn.(extendedPacketConn).SyscallConn()
}
================================================
FILE: internal/packetdumper/packet_conn_test.go
================================================
package packetdumper
import (
"net"
"os"
"path/filepath"
"testing"
"time"
"github.com/stretchr/testify/require"
)
// startUDPPair creates a pair of UDP connections and returns both ends.
func startUDPPair(t *testing.T) (client, server *net.UDPConn) {
t.Helper()
serverAddr, err := net.ResolveUDPAddr("udp", "127.0.0.1:0")
require.NoError(t, err)
server, err = net.ListenUDP("udp", serverAddr)
require.NoError(t, err)
clientAddr, err := net.ResolveUDPAddr("udp", "127.0.0.1:0")
require.NoError(t, err)
client, err = net.ListenUDP("udp", clientAddr)
require.NoError(t, err)
t.Cleanup(func() {
server.Close() //nolint:errcheck
client.Close() //nolint:errcheck
})
return client, server
}
func cleanupPcapngPacket(t *testing.T, prefix string) {
t.Helper()
matches, err := filepath.Glob(prefix + "_*.pcapng")
require.NoError(t, err, "glob for pcapng files")
require.NotEmpty(t, matches, "expected at least one pcapng file to have been created")
for _, f := range matches {
require.NoError(t, os.Remove(f), "removing pcapng file %s", f)
}
}
func TestPacketConnInitialize_CreatesFile(t *testing.T) {
client, server := startUDPPair(t)
defer server.Close() //nolint:errcheck
prefix := filepath.Join(t.TempDir(), "capture")
c := &PacketConn{Prefix: prefix, PacketConn: client}
require.NoError(t, c.Initialize())
defer cleanupPcapngPacket(t, prefix)
defer c.Close() //nolint:errcheck
}
func TestPacketConnWriteTo(t *testing.T) {
client, server := startUDPPair(t)
defer server.Close() //nolint:errcheck
prefix := filepath.Join(t.TempDir(), "capture")
c := &PacketConn{Prefix: prefix, PacketConn: client}
require.NoError(t, c.Initialize())
defer cleanupPcapngPacket(t, prefix)
defer c.Close() //nolint:errcheck
n, err := c.WriteTo([]byte("hello world"), server.LocalAddr())
require.NoError(t, err)
require.Equal(t, 11, n)
buf := make([]byte, 32)
server.SetReadDeadline(time.Now().Add(2 * time.Second)) //nolint:errcheck
rn, _, err := server.ReadFromUDP(buf)
require.NoError(t, err)
require.Equal(t, []byte("hello world"), buf[:rn])
}
func TestPacketConnReadFrom(t *testing.T) {
client, server := startUDPPair(t)
defer server.Close() //nolint:errcheck
prefix := filepath.Join(t.TempDir(), "capture")
c := &PacketConn{Prefix: prefix, PacketConn: client}
require.NoError(t, c.Initialize())
defer cleanupPcapngPacket(t, prefix)
defer c.Close() //nolint:errcheck
_, err := server.WriteTo([]byte("incoming data"), client.LocalAddr())
require.NoError(t, err)
buf := make([]byte, 32)
c.SetReadDeadline(time.Now().Add(2 * time.Second)) //nolint:errcheck
n, addr, err := c.ReadFrom(buf)
require.NoError(t, err)
require.Equal(t, []byte("incoming data"), buf[:n])
require.NotNil(t, addr)
}
func TestPacketConnMultipleWriteRead(t *testing.T) {
client, server := startUDPPair(t)
defer server.Close() //nolint:errcheck
prefix := filepath.Join(t.TempDir(), "capture")
c := &PacketConn{Prefix: prefix, PacketConn: client}
require.NoError(t, c.Initialize())
defer cleanupPcapngPacket(t, prefix)
defer c.Close() //nolint:errcheck
serverAddr := server.LocalAddr()
for _, msg := range []string{"foo", "bar", "baz"} {
n, err := c.WriteTo([]byte(msg), serverAddr)
require.NoError(t, err)
require.Equal(t, len(msg), n)
}
server.SetReadDeadline(time.Now().Add(2 * time.Second)) //nolint:errcheck
buf := make([]byte, 32)
received := make([]byte, 0, 9)
for range 3 {
n, _, err := server.ReadFromUDP(buf)
require.NoError(t, err)
received = append(received, buf[:n]...)
}
require.Equal(t, []byte("foobarbaz"), received)
for _, msg := range []string{"abcde", "fghij"} {
_, err := server.WriteTo([]byte(msg), client.LocalAddr())
require.NoError(t, err)
}
c.SetReadDeadline(time.Now().Add(2 * time.Second)) //nolint:errcheck
readReceived := make([]byte, 0, 10)
for range 2 {
n, _, err := c.ReadFrom(buf)
require.NoError(t, err)
readReceived = append(readReceived, buf[:n]...)
}
require.Equal(t, []byte("abcdefghij"), readReceived)
}
func TestPacketConnCloseIdempotent(t *testing.T) {
client, server := startUDPPair(t)
defer server.Close() //nolint:errcheck
prefix := filepath.Join(t.TempDir(), "capture")
c := &PacketConn{Prefix: prefix, PacketConn: client}
require.NoError(t, c.Initialize())
defer cleanupPcapngPacket(t, prefix)
defer c.Close() //nolint:errcheck
defer c.Close() //nolint:errcheck
}
func TestPacketConnDelegatesAddrMethods(t *testing.T) {
client, server := startUDPPair(t)
defer server.Close() //nolint:errcheck
prefix := filepath.Join(t.TempDir(), "capture")
c := &PacketConn{Prefix: prefix, PacketConn: client}
require.NoError(t, c.Initialize())
defer cleanupPcapngPacket(t, prefix)
defer c.Close() //nolint:errcheck
require.Equal(t, client.LocalAddr(), c.LocalAddr())
require.NoError(t, c.SetDeadline(time.Now().Add(time.Second)))
require.NoError(t, c.SetReadDeadline(time.Now().Add(time.Second)))
require.NoError(t, c.SetWriteDeadline(time.Now().Add(time.Second)))
}
func TestPacketConnReadFromRecordsSource(t *testing.T) {
client, server := startUDPPair(t)
defer server.Close() //nolint:errcheck
prefix := filepath.Join(t.TempDir(), "capture")
c := &PacketConn{Prefix: prefix, PacketConn: client}
require.NoError(t, c.Initialize())
defer cleanupPcapngPacket(t, prefix)
defer c.Close() //nolint:errcheck
_, err := server.WriteTo([]byte("ping"), client.LocalAddr())
require.NoError(t, err)
buf := make([]byte, 32)
c.SetReadDeadline(time.Now().Add(2 * time.Second)) //nolint:errcheck
n, addr, err := c.ReadFrom(buf)
require.NoError(t, err)
require.Equal(t, []byte("ping"), buf[:n])
// The reported source address should match the server's address.
require.Equal(t, server.LocalAddr().String(), addr.String())
}
================================================
FILE: internal/playback/muxer.go
================================================
package playback
import "github.com/bluenviron/mediacommon/v2/pkg/formats/fmp4"
type muxer interface {
writeInit(init *fmp4.Init)
setTrack(trackID int)
writeSample(
dts int64,
ptsOffset int32,
isNonSyncSample bool,
payloadSize uint32,
getPayload func() ([]byte, error),
) error
writeFinalDTS(dts int64)
flush() error
}
================================================
FILE: internal/playback/muxer_fmp4.go
================================================
package playback
import (
"io"
"time"
"github.com/bluenviron/mediacommon/v2/pkg/formats/fmp4"
"github.com/bluenviron/mediacommon/v2/pkg/formats/fmp4/seekablebuffer"
"github.com/bluenviron/mediamtx/internal/recordstore"
)
const (
partDuration = 1 * time.Second
)
type muxerFMP4Track struct {
id int
timeScale uint32
firstDTS int64
lastDTS int64
samples []*fmp4.Sample
}
func findTrack(tracks []*muxerFMP4Track, id int) *muxerFMP4Track {
for _, track := range tracks {
if track.id == id {
return track
}
}
return nil
}
type muxerFMP4 struct {
w io.Writer
init *fmp4.Init
nextSequenceNumber uint32
tracks []*muxerFMP4Track
curTrack *muxerFMP4Track
outBuf seekablebuffer.Buffer
}
func (w *muxerFMP4) writeInit(init *fmp4.Init) {
w.init = init
w.tracks = make([]*muxerFMP4Track, len(init.Tracks))
for i, track := range init.Tracks {
w.tracks[i] = &muxerFMP4Track{
id: track.ID,
timeScale: track.TimeScale,
firstDTS: -1,
}
}
}
func (w *muxerFMP4) setTrack(trackID int) {
w.curTrack = findTrack(w.tracks, trackID)
}
func (w *muxerFMP4) writeSample(
dts int64,
ptsOffset int32,
isNonSyncSample bool,
_ uint32,
getPayload func() ([]byte, error),
) error {
pl, err := getPayload()
if err != nil {
return err
}
if dts >= 0 {
// this is the first visible sample of this track
if w.curTrack.firstDTS < 0 {
w.curTrack.firstDTS = dts
// if sample is a IDR, remove previous GOP
if !isNonSyncSample {
w.curTrack.samples = w.curTrack.samples[:0]
}
} else {
duration := max(dts-w.curTrack.lastDTS, 0)
w.curTrack.samples[len(w.curTrack.samples)-1].Duration = uint32(duration)
}
w.curTrack.samples = append(w.curTrack.samples, &fmp4.Sample{
PTSOffset: ptsOffset,
IsNonSyncSample: isNonSyncSample,
Payload: pl,
})
w.curTrack.lastDTS = dts
partDurationMP4 := durationGoToMp4(partDuration, w.curTrack.timeScale)
if (w.curTrack.lastDTS - w.curTrack.firstDTS) >= partDurationMP4 {
err = w.innerFlush(false)
if err != nil {
return err
}
}
} else {
if !isNonSyncSample { // sample is IDR
// create a new GOP that starts from this sample.
// set sample duration to zero
w.curTrack.samples = w.curTrack.samples[:0]
w.curTrack.samples = append(w.curTrack.samples, &fmp4.Sample{
IsNonSyncSample: isNonSyncSample,
Payload: pl,
PTSOffset: ptsOffset,
})
} else { // sample is not IDR
// append sample to current GOP
// set sample duration to zero
w.curTrack.samples = append(w.curTrack.samples, &fmp4.Sample{
IsNonSyncSample: isNonSyncSample,
Payload: pl,
PTSOffset: ptsOffset,
})
}
}
return nil
}
func (w *muxerFMP4) writeFinalDTS(dts int64) {
if len(w.curTrack.samples) != 0 && w.curTrack.firstDTS >= 0 {
duration := max(dts-w.curTrack.lastDTS, 0)
w.curTrack.samples[len(w.curTrack.samples)-1].Duration = uint32(duration)
}
}
func (w *muxerFMP4) innerFlush(final bool) error {
var part fmp4.Part
for _, track := range w.tracks {
if track.firstDTS >= 0 && (len(track.samples) > 1 || (final && len(track.samples) != 0)) {
// do not write the final sample
// in order to allow changing its duration to compensate NTP-DTS differences
var samples []*fmp4.Sample
if !final {
samples = track.samples[:len(track.samples)-1]
} else {
samples = track.samples
}
part.Tracks = append(part.Tracks, &fmp4.PartTrack{
ID: track.id,
BaseTime: uint64(track.firstDTS),
Samples: samples,
})
if !final {
track.samples = track.samples[len(track.samples)-1:]
track.firstDTS = track.lastDTS
}
}
}
// no samples to write
if part.Tracks == nil {
// if no samples has been written before, return an error
if w.init != nil {
return recordstore.ErrNoSegmentsFound
}
return nil
}
part.SequenceNumber = w.nextSequenceNumber
w.nextSequenceNumber++
if w.init != nil {
err := w.init.Marshal(&w.outBuf)
if err != nil {
return err
}
_, err = w.w.Write(w.outBuf.Bytes())
if err != nil {
return err
}
w.init = nil
w.outBuf.Reset()
}
err := part.Marshal(&w.outBuf)
if err != nil {
return err
}
_, err = w.w.Write(w.outBuf.Bytes())
if err != nil {
return err
}
w.outBuf.Reset()
return nil
}
func (w *muxerFMP4) flush() error {
return w.innerFlush(true)
}
================================================
FILE: internal/playback/muxer_mp4.go
================================================
package playback
import (
"io"
"github.com/bluenviron/mediacommon/v2/pkg/formats/fmp4"
"github.com/bluenviron/mediacommon/v2/pkg/formats/pmp4"
"github.com/bluenviron/mediamtx/internal/recordstore"
)
type muxerMP4Track struct {
pmp4.Track
lastDTS int64
}
func findTrackMP4(tracks []*muxerMP4Track, id int) *muxerMP4Track {
for _, track := range tracks {
if track.ID == id {
return track
}
}
return nil
}
type muxerMP4 struct {
w io.Writer
tracks []*muxerMP4Track
curTrack *muxerMP4Track
}
func (w *muxerMP4) writeInit(init *fmp4.Init) {
w.tracks = make([]*muxerMP4Track, len(init.Tracks))
for i, track := range init.Tracks {
w.tracks[i] = &muxerMP4Track{
Track: pmp4.Track{
ID: track.ID,
TimeScale: track.TimeScale,
Codec: track.Codec,
},
}
}
}
func (w *muxerMP4) setTrack(trackID int) {
w.curTrack = findTrackMP4(w.tracks, trackID)
}
func (w *muxerMP4) writeSample(
dts int64,
ptsOffset int32,
isNonSyncSample bool,
payloadSize uint32,
getPayload func() ([]byte, error),
) error {
// remove GOPs before the GOP of the first sample
if (dts < 0 || (dts >= 0 && w.curTrack.lastDTS < 0)) && !isNonSyncSample {
w.curTrack.Samples = w.curTrack.Samples[:0]
}
if len(w.curTrack.Samples) == 0 {
w.curTrack.TimeOffset = int32(dts)
} else {
duration := max(dts-w.curTrack.lastDTS, 0)
w.curTrack.Samples[len(w.curTrack.Samples)-1].Duration = uint32(duration)
}
// prevent warning "edit list: 1 Missing key frame while searching for timestamp: 0"
if !isNonSyncSample {
ptsOffset = 0
}
w.curTrack.Samples = append(w.curTrack.Samples, &pmp4.Sample{
PTSOffset: ptsOffset,
IsNonSyncSample: isNonSyncSample,
PayloadSize: payloadSize,
GetPayload: getPayload,
})
w.curTrack.lastDTS = dts
return nil
}
func (w *muxerMP4) writeFinalDTS(dts int64) {
if len(w.curTrack.Samples) != 0 {
duration := max(dts-w.curTrack.lastDTS, 0)
w.curTrack.Samples[len(w.curTrack.Samples)-1].Duration = uint32(duration)
}
}
func (w *muxerMP4) flush() error {
if len(w.curTrack.Samples) == 0 || w.curTrack.lastDTS < 0 {
return recordstore.ErrNoSegmentsFound
}
var tracks []*pmp4.Track
for _, track := range w.tracks {
if len(track.Samples) != 0 {
tracks = append(tracks, &track.Track)
}
}
h := pmp4.Presentation{
Tracks: tracks,
}
return h.Marshal(w.w)
}
================================================
FILE: internal/playback/muxer_mp4_test.go
================================================
package playback
import (
"bytes"
"testing"
"github.com/bluenviron/mediacommon/v2/pkg/formats/fmp4"
mcodecs "github.com/bluenviron/mediacommon/v2/pkg/formats/mp4/codecs"
"github.com/bluenviron/mediamtx/internal/test"
"github.com/stretchr/testify/require"
)
// Test that tracks with no samples are not included in the output
func TestMuxerMP4EmptyTracks(t *testing.T) {
var buf bytes.Buffer
mux := &muxerMP4{
w: &buf,
}
init := &fmp4.Init{
Tracks: []*fmp4.InitTrack{
{
ID: 1,
TimeScale: 90000,
Codec: &mcodecs.H264{
SPS: test.FormatH264.SPS,
PPS: test.FormatH264.PPS,
},
},
{
ID: 2,
TimeScale: 48000,
Codec: &mcodecs.Opus{},
},
},
}
mux.writeInit(init)
// Only write samples to the first track
mux.setTrack(1)
err := mux.writeSample(0, 0, false, 5, func() ([]byte, error) {
return []byte{0x01, 0x02, 0x03, 0x04, 0x05}, nil
})
require.NoError(t, err)
err = mux.writeSample(90000, 0, true, 5, func() ([]byte, error) {
return []byte{0x06, 0x07, 0x08, 0x09, 0x0a}, nil
})
require.NoError(t, err)
mux.writeFinalDTS(180000)
err = mux.flush()
require.NoError(t, err)
require.Greater(t, buf.Len(), 0)
}
================================================
FILE: internal/playback/on_get.go
================================================
package playback
import (
"errors"
"fmt"
"net"
"net/http"
"os"
"strconv"
"time"
"github.com/bluenviron/mediacommon/v2/pkg/formats/fmp4"
"github.com/bluenviron/mediamtx/internal/conf"
"github.com/bluenviron/mediamtx/internal/logger"
"github.com/bluenviron/mediamtx/internal/recordstore"
"github.com/gin-gonic/gin"
)
type writerWrapper struct {
ctx *gin.Context
written bool
}
func (w *writerWrapper) Write(p []byte) (int, error) {
if !w.written {
w.written = true
w.ctx.Header("Accept-Ranges", "none")
w.ctx.Header("Content-Type", "video/mp4")
}
return w.ctx.Writer.Write(p)
}
func parseDuration(raw string) (time.Duration, error) {
// seconds
if secs, err := strconv.ParseFloat(raw, 64); err == nil {
return time.Duration(secs * float64(time.Second)), nil
}
// deprecated, golang format
return time.ParseDuration(raw)
}
func seekAndMux(
recordFormat conf.RecordFormat,
segments []*recordstore.Segment,
start time.Time,
duration time.Duration,
m muxer,
) error {
if recordFormat == conf.RecordFormatFMP4 {
f, err := os.Open(segments[0].Fpath)
if err != nil {
return err
}
defer f.Close()
firstInit, _, err := segmentFMP4ReadHeader(f)
if err != nil {
return err
}
m.writeInit(&fmp4.Init{
Tracks: firstInit.Tracks,
})
firstMtxi := findMtxi(firstInit.UserData)
startOffset := segments[0].Start.Sub(start) // this is negative
dts := startOffset
prevInit := firstInit
segmentDuration, err := segmentFMP4MuxParts(f, dts, duration, firstInit.Tracks, m)
if err != nil {
return err
}
segmentEnd := segments[0].Start.Add(segmentDuration)
for _, seg := range segments[1:] {
f, err = os.Open(seg.Fpath)
if err != nil {
return err
}
defer f.Close()
var init *fmp4.Init
init, _, err = segmentFMP4ReadHeader(f)
if err != nil {
return err
}
if !segmentFMP4CanBeConcatenated(prevInit, segmentEnd, init, seg.Start) {
break
}
if firstMtxi != nil {
mtxi := findMtxi(init.UserData)
dts = time.Duration(mtxi.DTS-firstMtxi.DTS) + startOffset
} else { // legacy method
dts = seg.Start.Sub(start) // this is positive
}
segmentDuration, err = segmentFMP4MuxParts(f, dts, duration, firstInit.Tracks, m)
if err != nil {
return err
}
segmentEnd = seg.Start.Add(segmentDuration)
prevInit = init
}
err = m.flush()
if err != nil {
return err
}
return nil
}
return fmt.Errorf("MPEG-TS format is not supported yet")
}
func (s *Server) onGet(ctx *gin.Context) {
pathName := ctx.Query("path")
if !s.doAuth(ctx, pathName) {
return
}
start, err := time.Parse(time.RFC3339, ctx.Query("start"))
if err != nil {
s.writeError(ctx, http.StatusBadRequest, fmt.Errorf("invalid start: %w", err))
return
}
duration, err := parseDuration(ctx.Query("duration"))
if err != nil {
s.writeError(ctx, http.StatusBadRequest, fmt.Errorf("invalid duration: %w", err))
return
}
ww := &writerWrapper{ctx: ctx}
var m muxer
format := ctx.Query("format")
switch format {
case "", "fmp4":
m = &muxerFMP4{w: ww}
case "mp4":
m = &muxerMP4{w: ww}
default:
s.writeError(ctx, http.StatusBadRequest, fmt.Errorf("invalid format: %s", format))
return
}
pathConf, err := s.safeFindPathConf(pathName)
if err != nil {
s.writeError(ctx, http.StatusBadRequest, err)
return
}
end := start.Add(duration)
segments, err := recordstore.FindSegments(pathConf, pathName, &start, &end)
if err != nil {
if errors.Is(err, recordstore.ErrNoSegmentsFound) {
s.writeError(ctx, http.StatusNotFound, err)
} else {
s.writeError(ctx, http.StatusBadRequest, err)
}
return
}
err = seekAndMux(pathConf.RecordFormat, segments, start, duration, m)
if err != nil {
// user aborted the download
var neterr *net.OpError
if errors.As(err, &neterr) {
return
}
// nothing has been written yet; send back JSON
if !ww.written {
if errors.Is(err, recordstore.ErrNoSegmentsFound) {
s.writeError(ctx, http.StatusNotFound, err)
} else {
s.writeError(ctx, http.StatusBadRequest, err)
}
return
}
// something has already been written: abort and write logs only
s.Log(logger.Error, err.Error())
return
}
}
================================================
FILE: internal/playback/on_get_test.go
================================================
package playback
import (
"bytes"
"io"
"net/http"
"net/url"
"os"
"path/filepath"
"testing"
"time"
amp4 "github.com/abema/go-mp4"
"github.com/bluenviron/mediacommon/v2/pkg/codecs/mpeg4audio"
"github.com/bluenviron/mediacommon/v2/pkg/formats/fmp4"
"github.com/bluenviron/mediacommon/v2/pkg/formats/fmp4/seekablebuffer"
mcodecs "github.com/bluenviron/mediacommon/v2/pkg/formats/mp4/codecs"
"github.com/bluenviron/mediacommon/v2/pkg/formats/pmp4"
"github.com/bluenviron/mediamtx/internal/conf"
"github.com/bluenviron/mediamtx/internal/recordstore"
"github.com/bluenviron/mediamtx/internal/test"
"github.com/google/uuid"
"github.com/stretchr/testify/require"
)
func writeSegment1(t *testing.T, fpath string) {
init := fmp4.Init{
Tracks: []*fmp4.InitTrack{
{
ID: 1,
TimeScale: 90000,
Codec: &mcodecs.H264{
SPS: test.FormatH264.SPS,
PPS: test.FormatH264.PPS,
},
},
{
ID: 2,
TimeScale: 48000,
Codec: &mcodecs.MPEG4Audio{
Config: mpeg4audio.AudioSpecificConfig{
Type: mpeg4audio.ObjectTypeAACLC,
SampleRate: 48000,
ChannelCount: 2,
},
},
},
},
}
var buf1 seekablebuffer.Buffer
err := init.Marshal(&buf1)
require.NoError(t, err)
var buf2 seekablebuffer.Buffer
parts := fmp4.Parts{
{
Tracks: []*fmp4.PartTrack{
{
ID: 1,
BaseTime: 30 * 90000,
Samples: []*fmp4.Sample{
{
Duration: 30 * 90000,
Payload: []byte{1, 2},
},
{
Duration: 1 * 90000,
PTSOffset: 90000,
Payload: []byte{3, 4},
},
{
Duration: 1 * 90000,
PTSOffset: -90000,
IsNonSyncSample: true,
Payload: []byte{5, 6},
}, // 62 secs
},
},
{
ID: 2,
BaseTime: 31 * 48000,
Samples: []*fmp4.Sample{
{
Duration: 29 * 48000,
Payload: []byte{1, 2},
},
{
Duration: 1 * 48000,
Payload: []byte{3, 4},
}, // 61 secs
},
},
},
},
}
err = parts.Marshal(&buf2)
require.NoError(t, err)
err = os.WriteFile(fpath, append(buf1.Bytes(), buf2.Bytes()...), 0o644)
require.NoError(t, err)
}
func writeSegment2(t *testing.T, fpath string) {
init := fmp4.Init{
Tracks: []*fmp4.InitTrack{
{
ID: 1,
TimeScale: 90000,
Codec: &mcodecs.H264{
SPS: test.FormatH264.SPS,
PPS: test.FormatH264.PPS,
},
},
{
ID: 2,
TimeScale: 48000,
Codec: &mcodecs.MPEG4Audio{
Config: mpeg4audio.AudioSpecificConfig{
Type: mpeg4audio.ObjectTypeAACLC,
SampleRate: 48000,
ChannelCount: 2,
},
},
},
},
}
var buf1 seekablebuffer.Buffer
err := init.Marshal(&buf1)
require.NoError(t, err)
var buf2 seekablebuffer.Buffer
parts := fmp4.Parts{ //nolint:dupl
{
Tracks: []*fmp4.PartTrack{{
ID: 1,
BaseTime: 0,
Samples: []*fmp4.Sample{
{
Duration: 1 * 90000,
Payload: []byte{7, 8},
}, // 1 sec
},
}},
},
{
Tracks: []*fmp4.PartTrack{{
ID: 2,
BaseTime: 0,
Samples: []*fmp4.Sample{
{
Duration: 1 * 48000,
Payload: []byte{5, 6},
},
{
Duration: 1 * 48000,
Payload: []byte{7, 8},
}, // 2 secs
},
}},
},
{
SequenceNumber: 5,
Tracks: []*fmp4.PartTrack{{
ID: 1,
BaseTime: 1 * 90000,
Samples: []*fmp4.Sample{
{
Duration: 1 * 90000,
Payload: []byte{9, 10},
},
{
Duration: 1 * 90000,
Payload: []byte{11, 12},
},
{
Duration: 1 * 90000,
Payload: []byte{13, 14},
}, // 4 secs
},
}},
},
}
err = parts.Marshal(&buf2)
require.NoError(t, err)
err = os.WriteFile(fpath, append(buf1.Bytes(), buf2.Bytes()...), 0o644)
require.NoError(t, err)
}
func writeSegment3(t *testing.T, fpath string) {
init := fmp4.Init{
Tracks: []*fmp4.InitTrack{
{
ID: 1,
TimeScale: 90000,
Codec: &mcodecs.H264{
SPS: test.FormatH264.SPS,
PPS: test.FormatH264.PPS,
},
},
},
}
var buf1 seekablebuffer.Buffer
err := init.Marshal(&buf1)
require.NoError(t, err)
var buf2 seekablebuffer.Buffer
parts := fmp4.Parts{
{
Tracks: []*fmp4.PartTrack{{
ID: 1,
BaseTime: 0,
Samples: []*fmp4.Sample{
{
Duration: 1 * 90000,
Payload: []byte{13, 14},
},
},
}},
},
}
err = parts.Marshal(&buf2)
require.NoError(t, err)
err = os.WriteFile(fpath, append(buf1.Bytes(), buf2.Bytes()...), 0o644)
require.NoError(t, err)
}
func TestOnGet(t *testing.T) {
for _, format := range []string{
"fmp4",
"mp4",
} {
for _, mode := range []string{
"no_mtxi",
"mtxi",
} {
t.Run(format+"_"+mode, func(t *testing.T) {
dir, err := os.MkdirTemp("", "mediamtx-playback")
require.NoError(t, err)
defer os.RemoveAll(dir)
err = os.Mkdir(filepath.Join(dir, "mypath"), 0o755)
require.NoError(t, err)
init := fmp4.Init{
Tracks: []*fmp4.InitTrack{
{
ID: 1,
TimeScale: 90000,
Codec: &mcodecs.H264{
SPS: test.FormatH264.SPS,
PPS: test.FormatH264.PPS,
},
},
{
ID: 2,
TimeScale: 48000,
Codec: &mcodecs.MPEG4Audio{
Config: mpeg4audio.AudioSpecificConfig{
Type: mpeg4audio.ObjectTypeAACLC,
SampleRate: 48000,
ChannelCount: 2,
},
},
},
},
}
// segment 1
func() {
if mode == "mtxi" {
init.UserData = []amp4.IBox{&recordstore.Mtxi{
StreamID: uuid.MustParse("31564107-9e7e-4923-bf2f-631371a35397"),
SegmentNumber: 4,
DTS: int64(11 * time.Second),
}}
}
var buf1 seekablebuffer.Buffer
err = init.Marshal(&buf1)
require.NoError(t, err)
var buf2 seekablebuffer.Buffer
parts := fmp4.Parts{
{
Tracks: []*fmp4.PartTrack{
{
ID: 1,
BaseTime: 30 * 90000,
Samples: []*fmp4.Sample{
{
Duration: 30 * 90000,
Payload: []byte{1, 2},
},
{
Duration: 1 * 90000,
PTSOffset: 90000,
Payload: []byte{3, 4},
},
{
Duration: 1 * 90000,
PTSOffset: -90000,
IsNonSyncSample: true,
Payload: []byte{5, 6},
}, // 62 secs
},
},
{
ID: 2,
BaseTime: 31 * 48000,
Samples: []*fmp4.Sample{
{
Duration: 29 * 48000,
Payload: []byte{1, 2},
},
{
Duration: 1 * 48000,
Payload: []byte{3, 4},
}, // 61 secs
},
},
},
},
}
err = parts.Marshal(&buf2)
require.NoError(t, err)
err = os.WriteFile(filepath.Join(dir, "mypath", "2008-11-07_11-22-00-500000.mp4"),
append(buf1.Bytes(), buf2.Bytes()...), 0o644)
require.NoError(t, err)
}()
// segment 2
func() { //nolint:dupl
if mode == "mtxi" {
init.UserData = []amp4.IBox{&recordstore.Mtxi{
StreamID: uuid.MustParse("31564107-9e7e-4923-bf2f-631371a35397"),
SegmentNumber: 5,
DTS: int64(73 * time.Second),
}}
}
var buf1 seekablebuffer.Buffer
err = init.Marshal(&buf1)
require.NoError(t, err)
var buf2 seekablebuffer.Buffer
parts := fmp4.Parts{ //nolint:dupl
{
Tracks: []*fmp4.PartTrack{{
ID: 1,
BaseTime: 0,
Samples: []*fmp4.Sample{
{
Duration: 1 * 90000,
Payload: []byte{7, 8},
}, // 1 sec
},
}},
},
{
Tracks: []*fmp4.PartTrack{{
ID: 2,
BaseTime: 0,
Samples: []*fmp4.Sample{
{
Duration: 1 * 48000,
Payload: []byte{5, 6},
},
{
Duration: 1 * 48000,
Payload: []byte{7, 8},
}, // 2 secs
},
}},
},
{
SequenceNumber: 5,
Tracks: []*fmp4.PartTrack{{
ID: 1,
BaseTime: 1 * 90000,
Samples: []*fmp4.Sample{
{
Duration: 1 * 90000,
Payload: []byte{9, 10},
},
{
Duration: 1 * 90000,
Payload: []byte{11, 12},
},
{
Duration: 1 * 90000,
Payload: []byte{13, 14},
}, // 4 secs
},
}},
},
}
err = parts.Marshal(&buf2)
require.NoError(t, err)
err = os.WriteFile(filepath.Join(dir, "mypath", "2008-11-07_11-23-02-500000.mp4"),
append(buf1.Bytes(), buf2.Bytes()...), 0o644)
require.NoError(t, err)
}()
// segment 3
func() { //nolint:dupl
if mode == "mtxi" {
init.UserData = []amp4.IBox{&recordstore.Mtxi{
StreamID: uuid.MustParse("31564107-9e7e-4923-bf2f-631371a35397"),
SegmentNumber: 6,
DTS: int64(75 * time.Second),
}}
}
var buf1 seekablebuffer.Buffer
err = init.Marshal(&buf1)
require.NoError(t, err)
var buf2 seekablebuffer.Buffer
parts := fmp4.Parts{ //nolint:dupl
{
Tracks: []*fmp4.PartTrack{{
ID: 1,
BaseTime: 0,
Samples: []*fmp4.Sample{
{
Duration: 1 * 90000,
Payload: []byte{7, 8},
}, // 1 sec
},
}},
},
{
Tracks: []*fmp4.PartTrack{{
ID: 2,
BaseTime: 0,
Samples: []*fmp4.Sample{
{
Duration: 1 * 48000,
Payload: []byte{5, 6},
},
{
Duration: 1 * 48000,
Payload: []byte{7, 8},
}, // 2 secs
},
}},
},
{
SequenceNumber: 5,
Tracks: []*fmp4.PartTrack{{
ID: 1,
BaseTime: 1 * 90000,
Samples: []*fmp4.Sample{
{
Duration: 1 * 90000,
Payload: []byte{9, 10},
},
{
Duration: 1 * 90000,
Payload: []byte{11, 12},
},
{
Duration: 1 * 90000,
Payload: []byte{13, 14},
}, // 4 secs
},
}},
},
}
err = parts.Marshal(&buf2)
require.NoError(t, err)
err = os.WriteFile(filepath.Join(dir, "mypath", "2008-11-07_11-23-04-500000.mp4"),
append(buf1.Bytes(), buf2.Bytes()...), 0o644)
require.NoError(t, err)
}()
s := &Server{
Address: "127.0.0.1:9996",
ReadTimeout: conf.Duration(10 * time.Second),
WriteTimeout: conf.Duration(10 * time.Second),
PathConfs: map[string]*conf.Path{
"mypath": {
Name: "mypath",
RecordPath: filepath.Join(dir, "%path/%Y-%m-%d_%H-%M-%S-%f"),
RecordFormat: conf.RecordFormatFMP4,
},
},
AuthManager: test.NilAuthManager,
Parent: test.NilLogger,
}
err = s.Initialize()
require.NoError(t, err)
defer s.Close()
u, err := url.Parse("http://myuser:mypass@localhost:9996/get")
require.NoError(t, err)
v := url.Values{}
v.Set("path", "mypath")
v.Set("start", time.Date(2008, 11, 7, 11, 23, 1, 500000000, time.Local).Format(time.RFC3339Nano))
v.Set("duration", "3")
v.Set("format", format)
u.RawQuery = v.Encode()
req, err := http.NewRequest(http.MethodGet, u.String(), nil)
require.NoError(t, err)
res, err := http.DefaultClient.Do(req)
require.NoError(t, err)
defer res.Body.Close()
require.Equal(t, http.StatusOK, res.StatusCode)
buf, err := io.ReadAll(res.Body)
require.NoError(t, err)
switch format {
case "fmp4":
var parts fmp4.Parts
err = parts.Unmarshal(buf)
require.NoError(t, err)
require.Equal(t, fmp4.Parts{
{
SequenceNumber: 0,
Tracks: []*fmp4.PartTrack{
{
ID: 1,
Samples: []*fmp4.Sample{
{
Duration: 0,
PTSOffset: 90000,
Payload: []byte{3, 4},
},
{
Duration: 90000,
PTSOffset: -90000,
IsNonSyncSample: true,
Payload: []byte{5, 6},
},
},
},
},
},
{
SequenceNumber: 1,
Tracks: []*fmp4.PartTrack{
{
ID: 2,
BaseTime: 48000,
Samples: []*fmp4.Sample{
{
Duration: 48000,
Payload: []byte{5, 6},
},
},
},
},
},
{
SequenceNumber: 2,
Tracks: []*fmp4.PartTrack{
{
ID: 1,
BaseTime: 90000,
Samples: []*fmp4.Sample{
{
Duration: 90000,
Payload: []byte{7, 8},
},
},
},
},
},
{
SequenceNumber: 3,
Tracks: []*fmp4.PartTrack{
{
ID: 1,
BaseTime: 2 * 90000,
Samples: []*fmp4.Sample{
{
Duration: 90000,
Payload: []byte{9, 10},
},
},
},
{
ID: 2,
BaseTime: 2 * 48000,
Samples: []*fmp4.Sample{
{
Duration: 48000,
Payload: []byte{7, 8},
},
},
},
},
},
}, parts)
case "mp4":
var p pmp4.Presentation
err = p.Unmarshal(bytes.NewReader(buf))
require.NoError(t, err)
sampleData := make(map[int][][]byte)
for _, track := range p.Tracks {
samples := make([][]byte, len(track.Samples))
for i, sample := range track.Samples {
buf, err = sample.GetPayload()
require.NoError(t, err)
samples[i] = buf
sample.GetPayload = nil
}
sampleData[track.ID] = samples
}
require.Equal(t, pmp4.Presentation{
Tracks: []*pmp4.Track{
{
ID: 1,
TimeScale: 90000,
TimeOffset: -90000,
Codec: &mcodecs.H264{
SPS: test.FormatH264.SPS,
PPS: test.FormatH264.PPS,
},
Samples: []*pmp4.Sample{
{
Duration: 90000,
PayloadSize: 2,
},
{
Duration: 90000,
PTSOffset: -90000,
IsNonSyncSample: true,
PayloadSize: 2,
},
{
Duration: 90000,
PayloadSize: 2,
},
{
Duration: 90000,
PayloadSize: 2,
},
},
},
{
ID: 2,
TimeScale: 48000,
TimeOffset: 48000,
Codec: &mcodecs.MPEG4Audio{
Config: mpeg4audio.AudioSpecificConfig{
Type: mpeg4audio.ObjectTypeAACLC,
SampleRate: 48000,
ChannelCount: 2,
ChannelConfig: 2,
},
},
Samples: []*pmp4.Sample{
{
Duration: 48000,
PayloadSize: 2,
},
{
Duration: 48000,
PayloadSize: 2,
},
},
},
},
}, p)
require.Equal(t, map[int][][]byte{
1: {
{3, 4},
{5, 6},
{7, 8},
{9, 10},
},
2: {
{5, 6},
{7, 8},
},
}, sampleData)
}
})
}
}
}
func TestOnGetDifferentInit(t *testing.T) {
dir, err := os.MkdirTemp("", "mediamtx-playback")
require.NoError(t, err)
defer os.RemoveAll(dir)
err = os.Mkdir(filepath.Join(dir, "mypath"), 0o755)
require.NoError(t, err)
writeSegment1(t, filepath.Join(dir, "mypath", "2008-11-07_11-22-00-500000.mp4"))
writeSegment3(t, filepath.Join(dir, "mypath", "2008-11-07_11-23-02-500000.mp4"))
s := &Server{
Address: "127.0.0.1:9996",
ReadTimeout: conf.Duration(10 * time.Second),
WriteTimeout: conf.Duration(10 * time.Second),
PathConfs: map[string]*conf.Path{
"mypath": {
Name: "mypath",
RecordPath: filepath.Join(dir, "%path/%Y-%m-%d_%H-%M-%S-%f"),
RecordFormat: conf.RecordFormatFMP4,
},
},
AuthManager: test.NilAuthManager,
Parent: test.NilLogger,
}
err = s.Initialize()
require.NoError(t, err)
defer s.Close()
u, err := url.Parse("http://myuser:mypass@localhost:9996/get")
require.NoError(t, err)
v := url.Values{}
v.Set("path", "mypath")
v.Set("start", time.Date(2008, 11, 7, 11, 23, 1, 500000000, time.Local).Format(time.RFC3339Nano))
v.Set("duration", "2")
v.Set("format", "fmp4")
u.RawQuery = v.Encode()
req, err := http.NewRequest(http.MethodGet, u.String(), nil)
require.NoError(t, err)
res, err := http.DefaultClient.Do(req)
require.NoError(t, err)
defer res.Body.Close()
require.Equal(t, http.StatusOK, res.StatusCode)
buf, err := io.ReadAll(res.Body)
require.NoError(t, err)
var parts fmp4.Parts
err = parts.Unmarshal(buf)
require.NoError(t, err)
require.Equal(t, fmp4.Parts{
{
SequenceNumber: 0,
Tracks: []*fmp4.PartTrack{
{
ID: 1,
Samples: []*fmp4.Sample{
{
Duration: 0,
PTSOffset: 90000,
Payload: []byte{3, 4},
},
{
Duration: 90000,
PTSOffset: -90000,
IsNonSyncSample: true,
Payload: []byte{5, 6},
},
},
},
},
},
}, parts)
}
func TestOnGetInMiddleOfLastSample(t *testing.T) {
for _, format := range []string{"fmp4", "mp4"} {
t.Run(format, func(t *testing.T) {
dir, err := os.MkdirTemp("", "mediamtx-playback")
require.NoError(t, err)
defer os.RemoveAll(dir)
err = os.Mkdir(filepath.Join(dir, "mypath"), 0o755)
require.NoError(t, err)
init := fmp4.Init{
Tracks: []*fmp4.InitTrack{
{
ID: 1,
TimeScale: 90000,
Codec: &mcodecs.H264{
SPS: test.FormatH264.SPS,
PPS: test.FormatH264.PPS,
},
},
},
}
func() {
fpath := filepath.Join(dir, "mypath", "2008-11-07_11-22-00-000000.mp4")
var buf1 seekablebuffer.Buffer
err = init.Marshal(&buf1)
require.NoError(t, err)
var buf2 seekablebuffer.Buffer
parts := fmp4.Parts{
{
Tracks: []*fmp4.PartTrack{
{
ID: 1,
Samples: []*fmp4.Sample{
{
Duration: 1 * 90000,
IsNonSyncSample: false,
Payload: []byte{1, 2},
},
},
},
},
},
}
err = parts.Marshal(&buf2)
require.NoError(t, err)
err = os.WriteFile(fpath, append(buf1.Bytes(), buf2.Bytes()...), 0o644)
require.NoError(t, err)
}()
s := &Server{
Address: "127.0.0.1:9996",
ReadTimeout: conf.Duration(10 * time.Second),
WriteTimeout: conf.Duration(10 * time.Second),
PathConfs: map[string]*conf.Path{
"mypath": {
Name: "mypath",
RecordPath: filepath.Join(dir, "%path/%Y-%m-%d_%H-%M-%S-%f"),
RecordFormat: conf.RecordFormatFMP4,
},
},
AuthManager: test.NilAuthManager,
Parent: test.NilLogger,
}
err = s.Initialize()
require.NoError(t, err)
defer s.Close()
u, err := url.Parse("http://myuser:mypass@localhost:9996/get")
require.NoError(t, err)
v := url.Values{}
v.Set("path", "mypath")
v.Set("start", time.Date(2008, 11, 7, 11, 22, 0, 500000000, time.Local).Format(time.RFC3339Nano))
v.Set("duration", "3")
v.Set("format", format)
u.RawQuery = v.Encode()
req, err := http.NewRequest(http.MethodGet, u.String(), nil)
require.NoError(t, err)
res, err := http.DefaultClient.Do(req)
require.NoError(t, err)
defer res.Body.Close()
require.Equal(t, http.StatusNotFound, res.StatusCode)
})
}
}
func TestOnGetBetweenSegments(t *testing.T) {
for _, ca := range []string{
"idr before",
"idr after",
} {
t.Run(ca, func(t *testing.T) {
dir, err := os.MkdirTemp("", "mediamtx-playback")
require.NoError(t, err)
defer os.RemoveAll(dir)
err = os.Mkdir(filepath.Join(dir, "mypath"), 0o755)
require.NoError(t, err)
init := fmp4.Init{
Tracks: []*fmp4.InitTrack{
{
ID: 1,
TimeScale: 90000,
Codec: &mcodecs.H264{
SPS: test.FormatH264.SPS,
PPS: test.FormatH264.PPS,
},
},
},
}
func() {
fpath := filepath.Join(dir, "mypath", "2008-11-07_11-22-00-000000.mp4")
var buf1 seekablebuffer.Buffer
err = init.Marshal(&buf1)
require.NoError(t, err)
var buf2 seekablebuffer.Buffer
parts := fmp4.Parts{
{
Tracks: []*fmp4.PartTrack{
{
ID: 1,
Samples: []*fmp4.Sample{
{
Duration: 1 * 90000,
IsNonSyncSample: false,
Payload: []byte{1, 2},
},
},
},
},
},
}
err = parts.Marshal(&buf2)
require.NoError(t, err)
err = os.WriteFile(fpath, append(buf1.Bytes(), buf2.Bytes()...), 0o644)
require.NoError(t, err)
}()
func() {
fpath := filepath.Join(dir, "mypath", "2008-11-07_11-22-01-000000.mp4")
var buf1 seekablebuffer.Buffer
err = init.Marshal(&buf1)
require.NoError(t, err)
var buf2 seekablebuffer.Buffer
parts := fmp4.Parts{
{
Tracks: []*fmp4.PartTrack{
{
ID: 1,
Samples: []*fmp4.Sample{
{
Duration: 1 * 90000,
IsNonSyncSample: (ca == "idr before"),
Payload: []byte{3, 4},
},
},
},
},
},
}
err = parts.Marshal(&buf2)
require.NoError(t, err)
err = os.WriteFile(fpath, append(buf1.Bytes(), buf2.Bytes()...), 0o644)
require.NoError(t, err)
}()
s := &Server{
Address: "127.0.0.1:9996",
ReadTimeout: conf.Duration(10 * time.Second),
WriteTimeout: conf.Duration(10 * time.Second),
PathConfs: map[string]*conf.Path{
"mypath": {
Name: "mypath",
RecordPath: filepath.Join(dir, "%path/%Y-%m-%d_%H-%M-%S-%f"),
RecordFormat: conf.RecordFormatFMP4,
},
},
AuthManager: test.NilAuthManager,
Parent: test.NilLogger,
}
err = s.Initialize()
require.NoError(t, err)
defer s.Close()
u, err := url.Parse("http://myuser:mypass@localhost:9996/get")
require.NoError(t, err)
v := url.Values{}
v.Set("path", "mypath")
v.Set("start", time.Date(2008, 11, 7, 11, 22, 0, 500000000, time.Local).Format(time.RFC3339Nano))
v.Set("duration", "3")
v.Set("format", "fmp4")
u.RawQuery = v.Encode()
req, err := http.NewRequest(http.MethodGet, u.String(), nil)
require.NoError(t, err)
res, err := http.DefaultClient.Do(req)
require.NoError(t, err)
defer res.Body.Close()
require.Equal(t, http.StatusOK, res.StatusCode)
buf, err := io.ReadAll(res.Body)
require.NoError(t, err)
var parts fmp4.Parts
err = parts.Unmarshal(buf)
require.NoError(t, err)
switch ca {
case "idr before":
require.Equal(t, fmp4.Parts{
{
SequenceNumber: 0,
Tracks: []*fmp4.PartTrack{
{
ID: 1,
BaseTime: 45000,
Samples: []*fmp4.Sample{
{
Duration: 0,
Payload: []byte{1, 2},
},
{
Duration: 90000,
Payload: []byte{3, 4},
IsNonSyncSample: true,
},
},
},
},
},
}, parts)
case "idr after":
require.Equal(t, fmp4.Parts{
{
SequenceNumber: 0,
Tracks: []*fmp4.PartTrack{
{
ID: 1,
BaseTime: 45000,
Samples: []*fmp4.Sample{
{
Duration: 90000,
Payload: []byte{3, 4},
},
},
},
},
},
}, parts)
}
})
}
}
================================================
FILE: internal/playback/on_list.go
================================================
package playback
import (
"encoding/json"
"errors"
"fmt"
"net"
"net/http"
"net/url"
"os"
"strconv"
"time"
"github.com/bluenviron/mediacommon/v2/pkg/formats/fmp4"
"github.com/bluenviron/mediamtx/internal/conf"
"github.com/bluenviron/mediamtx/internal/recordstore"
"github.com/gin-gonic/gin"
)
type listEntryDuration time.Duration
func (d listEntryDuration) MarshalJSON() ([]byte, error) {
return json.Marshal(time.Duration(d).Seconds())
}
type parsedSegment struct {
start time.Time
init *fmp4.Init
duration time.Duration
}
func parseSegment(seg *recordstore.Segment) (*parsedSegment, error) {
f, err := os.Open(seg.Fpath)
if err != nil {
return nil, err
}
defer f.Close()
init, duration, err := segmentFMP4ReadHeader(f)
if err != nil {
return nil, err
}
// if duration is not present in the header, compute it
// by parsing each part
if duration == 0 {
duration, err = segmentFMP4ReadDurationFromParts(f, init)
if err != nil {
return nil, err
}
}
return &parsedSegment{
start: seg.Start,
init: init,
duration: duration,
}, nil
}
func parseSegments(segments []*recordstore.Segment) ([]*parsedSegment, error) {
parsed := make([]*parsedSegment, len(segments))
ch := make(chan error)
// process segments in parallel.
// parallel random access should improve performance in most cases.
// ref: https://pkolaczk.github.io/disk-parallelism/
for i, seg := range segments {
go func(i int, seg *recordstore.Segment) {
var err error
parsed[i], err = parseSegment(seg)
ch <- err
}(i, seg)
}
var err error
for range segments {
err2 := <-ch
if err2 != nil {
err = err2
}
}
return parsed, err
}
func urlScheme(ctx *gin.Context, trustedProxies conf.IPNetworks, encryption bool) string {
if trustedProxies.Contains(net.ParseIP(ctx.RemoteIP())) {
xForwardedProto := ctx.Request.Header.Get("X-Forwarded-Proto")
if xForwardedProto != "" {
return xForwardedProto
}
}
if encryption {
return "https"
}
return "http"
}
type listEntry struct {
Start time.Time `json:"start"`
Duration listEntryDuration `json:"duration"`
URL string `json:"url"`
}
func concatenateSegments(parsed []*parsedSegment) []listEntry {
out := []listEntry{}
var prevInit *fmp4.Init
for _, parsed := range parsed {
if len(out) != 0 && segmentFMP4CanBeConcatenated(
prevInit,
out[len(out)-1].Start.Add(time.Duration(out[len(out)-1].Duration)),
parsed.init,
parsed.start) {
prevStart := out[len(out)-1].Start
curEnd := parsed.start.Add(parsed.duration)
out[len(out)-1].Duration = listEntryDuration(curEnd.Sub(prevStart))
} else {
out = append(out, listEntry{
Start: parsed.start,
Duration: listEntryDuration(parsed.duration),
})
}
prevInit = parsed.init
}
return out
}
func parseAndConcatenate(
recordFormat conf.RecordFormat,
segments []*recordstore.Segment,
) ([]listEntry, error) {
if recordFormat == conf.RecordFormatFMP4 {
parsed, err := parseSegments(segments)
if err != nil {
return nil, err
}
out := concatenateSegments(parsed)
return out, nil
}
return nil, fmt.Errorf("MPEG-TS format is not supported yet")
}
func (s *Server) onList(ctx *gin.Context) {
pathName := ctx.Query("path")
if !s.doAuth(ctx, pathName) {
return
}
pathConf, err := s.safeFindPathConf(pathName)
if err != nil {
s.writeError(ctx, http.StatusBadRequest, err)
return
}
var start *time.Time
rawStart := ctx.Query("start")
if rawStart != "" {
var tmp time.Time
tmp, err = time.Parse(time.RFC3339, rawStart)
if err != nil {
s.writeError(ctx, http.StatusBadRequest, fmt.Errorf("invalid start: %w", err))
return
}
start = &tmp
}
var end *time.Time
rawEnd := ctx.Query("end")
if rawEnd != "" {
var tmp time.Time
tmp, err = time.Parse(time.RFC3339, rawEnd)
if err != nil {
s.writeError(ctx, http.StatusBadRequest, fmt.Errorf("invalid end: %w", err))
return
}
end = &tmp
}
segments, err := recordstore.FindSegments(pathConf, pathName, start, end)
if err != nil {
if errors.Is(err, recordstore.ErrNoSegmentsFound) {
s.writeError(ctx, http.StatusNotFound, err)
} else {
s.writeError(ctx, http.StatusBadRequest, err)
}
return
}
entries, err := parseAndConcatenate(pathConf.RecordFormat, segments)
if err != nil {
s.writeError(ctx, http.StatusInternalServerError, err)
return
}
if start != nil {
firstEntry := entries[0]
// when start is placed in a gap between the first and second segment,
// or when there's no second segment,
// the first segment is erroneously included with a negative duration.
// remove it.
if firstEntry.Start.Add(time.Duration(firstEntry.Duration)).Before(*start) {
entries = entries[1:]
if len(entries) == 0 {
s.writeError(ctx, http.StatusNotFound, recordstore.ErrNoSegmentsFound)
return
}
} else if firstEntry.Start.Before(*start) {
entries[0].Duration -= listEntryDuration(start.Sub(firstEntry.Start))
entries[0].Start = *start
}
}
if end != nil {
lastEntry := entries[len(entries)-1]
if lastEntry.Start.Add(time.Duration(lastEntry.Duration)).After(*end) {
entries[len(entries)-1].Duration = listEntryDuration(end.Sub(lastEntry.Start))
}
}
scheme := urlScheme(ctx, s.TrustedProxies, s.Encryption)
for i := range entries {
v := url.Values{}
v.Add("path", pathName)
v.Add("start", entries[i].Start.Format(time.RFC3339Nano))
v.Add("duration", strconv.FormatFloat(time.Duration(entries[i].Duration).Seconds(), 'f', -1, 64))
u := &url.URL{
Scheme: scheme,
Host: ctx.Request.Host,
Path: "/get",
RawQuery: v.Encode(),
}
entries[i].URL = u.String()
}
ctx.JSON(http.StatusOK, entries)
}
================================================
FILE: internal/playback/on_list_test.go
================================================
package playback
import (
"bytes"
"encoding/json"
"fmt"
"io"
"net/http"
"net/url"
"os"
"path/filepath"
"testing"
"time"
amp4 "github.com/abema/go-mp4"
"github.com/bluenviron/mediacommon/v2/pkg/formats/fmp4"
mcodecs "github.com/bluenviron/mediacommon/v2/pkg/formats/mp4/codecs"
"github.com/bluenviron/mediamtx/internal/auth"
"github.com/bluenviron/mediamtx/internal/conf"
"github.com/bluenviron/mediamtx/internal/test"
"github.com/stretchr/testify/require"
)
func TestOnList(t *testing.T) {
for _, ca := range []string{
"unfiltered",
"filtered",
"filtered and gap",
"different init",
"start after duration",
"start before first",
} {
t.Run(ca, func(t *testing.T) {
dir, err := os.MkdirTemp("", "mediamtx-playback")
require.NoError(t, err)
defer os.RemoveAll(dir)
err = os.Mkdir(filepath.Join(dir, "mypath"), 0o755)
require.NoError(t, err)
switch ca {
case "unfiltered", "filtered", "start before first":
writeSegment1(t, filepath.Join(dir, "mypath", "2008-11-07_11-22-00-500000.mp4"))
writeSegment2(t, filepath.Join(dir, "mypath", "2008-11-07_11-23-02-500000.mp4"))
writeSegment2(t, filepath.Join(dir, "mypath", "2009-11-07_11-23-02-500000.mp4"))
case "filtered and gap":
writeSegment1(t, filepath.Join(dir, "mypath", "2008-11-07_11-22-00-500000.mp4"))
writeSegment2(t, filepath.Join(dir, "mypath", "2008-11-07_11-24-02-500000.mp4"))
case "different init":
writeSegment1(t, filepath.Join(dir, "mypath", "2008-11-07_11-22-00-500000.mp4"))
writeSegment3(t, filepath.Join(dir, "mypath", "2008-11-07_11-23-02-500000.mp4"))
case "start after duration":
writeSegment1(t, filepath.Join(dir, "mypath", "2008-11-07_11-22-00-500000.mp4"))
}
checked := false
s := &Server{
Address: "127.0.0.1:9996",
ReadTimeout: conf.Duration(10 * time.Second),
WriteTimeout: conf.Duration(10 * time.Second),
PathConfs: map[string]*conf.Path{
"mypath": {
Name: "mypath",
RecordPath: filepath.Join(dir, "%path/%Y-%m-%d_%H-%M-%S-%f"),
RecordFormat: conf.RecordFormatFMP4,
},
},
AuthManager: &test.AuthManager{
AuthenticateImpl: func(req *auth.Request) (string, *auth.Error) {
require.Equal(t, conf.AuthActionPlayback, req.Action)
require.Equal(t, "myuser", req.Credentials.User)
require.Equal(t, "mypass", req.Credentials.Pass)
checked = true
return req.Credentials.User, nil
},
},
Parent: test.NilLogger,
}
err = s.Initialize()
require.NoError(t, err)
defer s.Close()
u, err := url.Parse("http://myuser:mypass@localhost:9996/list?start=")
require.NoError(t, err)
v := url.Values{}
v.Set("path", "mypath")
switch ca {
case "filtered":
v.Set("start", time.Date(2008, 11, 7, 11, 22, 1, 500000000, time.Local).Format(time.RFC3339Nano))
v.Set("end", time.Date(2009, 11, 7, 11, 23, 4, 500000000, time.Local).Format(time.RFC3339Nano))
case "filtered and gap":
v.Set("start", time.Date(2008, 11, 7, 11, 23, 20, 500000000, time.Local).Format(time.RFC3339Nano))
v.Set("end", time.Date(2009, 11, 7, 11, 23, 4, 500000000, time.Local).Format(time.RFC3339Nano))
case "start after duration":
v.Set("start", time.Date(2010, 11, 7, 11, 23, 20, 500000000, time.Local).Format(time.RFC3339Nano))
case "start before first":
v.Set("start", time.Date(2007, 11, 7, 11, 23, 20, 500000000, time.Local).Format(time.RFC3339Nano))
}
u.RawQuery = v.Encode()
req, err := http.NewRequest(http.MethodGet, u.String(), nil)
require.NoError(t, err)
res, err := http.DefaultClient.Do(req)
require.NoError(t, err)
defer res.Body.Close()
if ca == "start after duration" {
require.Equal(t, http.StatusNotFound, res.StatusCode)
return
}
require.Equal(t, http.StatusOK, res.StatusCode)
var out any
err = json.NewDecoder(res.Body).Decode(&out)
require.NoError(t, err)
switch ca {
case "unfiltered", "start before first":
require.Equal(t, []any{
map[string]any{
"duration": float64(66),
"start": time.Date(2008, 11, 7, 11, 22, 0, 500000000, time.Local).Format(time.RFC3339Nano),
"url": "http://localhost:9996/get?duration=66&path=mypath&start=" +
url.QueryEscape(time.Date(2008, 11, 7, 11, 22, 0, 500000000, time.Local).Format(time.RFC3339Nano)),
},
map[string]any{
"duration": float64(4),
"start": time.Date(2009, 11, 7, 11, 23, 2, 500000000, time.Local).Format(time.RFC3339Nano),
"url": "http://localhost:9996/get?duration=4&path=mypath&start=" +
url.QueryEscape(time.Date(2009, 11, 7, 11, 23, 2, 500000000, time.Local).Format(time.RFC3339Nano)),
},
}, out)
case "filtered":
require.Equal(t, []any{
map[string]any{
"duration": float64(65),
"start": time.Date(2008, 11, 7, 11, 22, 1, 500000000, time.Local).Format(time.RFC3339Nano),
"url": "http://localhost:9996/get?duration=65&path=mypath&start=" +
url.QueryEscape(time.Date(2008, 11, 7, 11, 22, 1, 500000000, time.Local).Format(time.RFC3339Nano)),
},
map[string]any{
"duration": float64(2),
"start": time.Date(2009, 11, 7, 11, 23, 2, 500000000, time.Local).Format(time.RFC3339Nano),
"url": "http://localhost:9996/get?duration=2&path=mypath&start=" +
url.QueryEscape(time.Date(2009, 11, 7, 11, 23, 2, 500000000, time.Local).Format(time.RFC3339Nano)),
},
}, out)
case "filtered and gap":
require.Equal(t, []any{
map[string]any{
"duration": float64(4),
"start": time.Date(2008, 11, 7, 11, 24, 2, 500000000, time.Local).Format(time.RFC3339Nano),
"url": "http://localhost:9996/get?duration=4&path=mypath&start=" +
url.QueryEscape(time.Date(2008, 11, 7, 11, 24, 2, 500000000, time.Local).Format(time.RFC3339Nano)),
},
}, out)
case "different init":
require.Equal(t, []any{
map[string]any{
"duration": float64(62),
"start": time.Date(2008, 11, 7, 11, 22, 0, 500000000, time.Local).Format(time.RFC3339Nano),
"url": "http://localhost:9996/get?duration=62&path=mypath&start=" +
url.QueryEscape(time.Date(2008, 11, 7, 11, 22, 0, 500000000, time.Local).Format(time.RFC3339Nano)),
},
map[string]any{
"duration": float64(1),
"start": time.Date(2008, 11, 7, 11, 23, 2, 500000000, time.Local).Format(time.RFC3339Nano),
"url": "http://localhost:9996/get?duration=1&path=mypath&start=" +
url.QueryEscape(time.Date(2008, 11, 7, 11, 23, 2, 500000000, time.Local).Format(time.RFC3339Nano)),
},
}, out)
}
require.True(t, checked)
})
}
}
func writeDuration(f io.ReadWriteSeeker, d time.Duration) error {
_, err := f.Seek(0, io.SeekStart)
if err != nil {
return err
}
// check and skip ftyp header and content
buf := make([]byte, 8)
_, err = io.ReadFull(f, buf)
if err != nil {
return err
}
if !bytes.Equal(buf[4:], []byte{'f', 't', 'y', 'p'}) {
return fmt.Errorf("ftyp box not found")
}
ftypSize := uint32(buf[0])<<24 | uint32(buf[1])<<16 | uint32(buf[2])<<8 | uint32(buf[3])
_, err = f.Seek(int64(ftypSize), io.SeekStart)
if err != nil {
return err
}
// check and skip moov header
_, err = io.ReadFull(f, buf)
if err != nil {
return err
}
if !bytes.Equal(buf[4:], []byte{'m', 'o', 'o', 'v'}) {
return fmt.Errorf("moov box not found")
}
moovSize := uint32(buf[0])<<24 | uint32(buf[1])<<16 | uint32(buf[2])<<8 | uint32(buf[3])
moovPos, err := f.Seek(8, io.SeekCurrent)
if err != nil {
return err
}
var mvhd amp4.Mvhd
_, err = amp4.Unmarshal(f, uint64(moovSize-8), &mvhd, amp4.Context{})
if err != nil {
return err
}
mvhd.DurationV0 = uint32(d / time.Millisecond)
_, err = f.Seek(moovPos, io.SeekStart)
if err != nil {
return err
}
_, err = amp4.Marshal(f, &mvhd, amp4.Context{})
if err != nil {
return err
}
return nil
}
func TestOnListCachedDuration(t *testing.T) {
dir, err := os.MkdirTemp("", "mediamtx-playback")
require.NoError(t, err)
defer os.RemoveAll(dir)
err = os.Mkdir(filepath.Join(dir, "mypath"), 0o755)
require.NoError(t, err)
func() {
var f *os.File
f, err = os.Create(filepath.Join(dir, "mypath", "2008-11-07_11-22-00-500000.mp4"))
require.NoError(t, err)
defer f.Close()
init := fmp4.Init{
Tracks: []*fmp4.InitTrack{
{
ID: 1,
TimeScale: 90000,
Codec: &mcodecs.H264{
SPS: test.FormatH264.SPS,
PPS: test.FormatH264.PPS,
},
},
},
}
err = init.Marshal(f)
require.NoError(t, err)
err = writeDuration(f, 50*time.Second)
require.NoError(t, err)
}()
s := &Server{
Address: "127.0.0.1:9996",
ReadTimeout: conf.Duration(10 * time.Second),
WriteTimeout: conf.Duration(10 * time.Second),
PathConfs: map[string]*conf.Path{
"mypath": {
Name: "mypath",
RecordPath: filepath.Join(dir, "%path/%Y-%m-%d_%H-%M-%S-%f"),
RecordFormat: conf.RecordFormatFMP4,
},
},
AuthManager: test.NilAuthManager,
Parent: test.NilLogger,
}
err = s.Initialize()
require.NoError(t, err)
defer s.Close()
u, err := url.Parse("http://myuser:mypass@localhost:9996/list")
require.NoError(t, err)
v := url.Values{}
v.Set("path", "mypath")
u.RawQuery = v.Encode()
req, err := http.NewRequest(http.MethodGet, u.String(), nil)
require.NoError(t, err)
res, err := http.DefaultClient.Do(req)
require.NoError(t, err)
defer res.Body.Close()
require.Equal(t, http.StatusOK, res.StatusCode)
var out any
err = json.NewDecoder(res.Body).Decode(&out)
require.NoError(t, err)
require.Equal(t, []any{
map[string]any{
"duration": float64(50),
"start": time.Date(2008, 11, 7, 11, 22, 0, 500000000, time.Local).Format(time.RFC3339Nano),
"url": "http://localhost:9996/get?duration=50&path=mypath&start=" +
url.QueryEscape(time.Date(2008, 11, 7, 11, 22, 0, 500000000, time.Local).Format(time.RFC3339Nano)),
},
}, out)
}
func TestOnListXForwardedProto(t *testing.T) {
dir, err := os.MkdirTemp("", "mediamtx-playback")
require.NoError(t, err)
defer os.RemoveAll(dir)
err = os.Mkdir(filepath.Join(dir, "mypath"), 0o755)
require.NoError(t, err)
writeSegment1(t, filepath.Join(dir, "mypath", "2008-11-07_11-22-00-500000.mp4"))
var trustedProxies conf.IPNetworks
err = json.Unmarshal([]byte(`["127.0.0.0/8"]`), &trustedProxies)
require.NoError(t, err)
s := &Server{
Address: "127.0.0.1:9996",
ReadTimeout: conf.Duration(10 * time.Second),
WriteTimeout: conf.Duration(10 * time.Second),
TrustedProxies: trustedProxies,
PathConfs: map[string]*conf.Path{
"mypath": {
Name: "mypath",
RecordPath: filepath.Join(dir, "%path/%Y-%m-%d_%H-%M-%S-%f"),
RecordFormat: conf.RecordFormatFMP4,
},
},
AuthManager: test.NilAuthManager,
Parent: test.NilLogger,
}
err = s.Initialize()
require.NoError(t, err)
defer s.Close()
u, err := url.Parse("http://localhost:9996/list")
require.NoError(t, err)
v := url.Values{}
v.Set("path", "mypath")
u.RawQuery = v.Encode()
req, err := http.NewRequest(http.MethodGet, u.String(), nil)
require.NoError(t, err)
req.Header.Set("X-Forwarded-Proto", "https")
res, err := http.DefaultClient.Do(req)
require.NoError(t, err)
defer res.Body.Close()
require.Equal(t, http.StatusOK, res.StatusCode)
var out any
err = json.NewDecoder(res.Body).Decode(&out)
require.NoError(t, err)
require.Equal(t, []any{
map[string]any{
"duration": float64(62),
"start": time.Date(2008, 11, 7, 11, 22, 0, 500000000, time.Local).Format(time.RFC3339Nano),
"url": "https://localhost:9996/get?duration=62&path=mypath&start=" +
url.QueryEscape(time.Date(2008, 11, 7, 11, 22, 0, 500000000, time.Local).Format(time.RFC3339Nano)),
},
}, out)
}
================================================
FILE: internal/playback/segment_fmp4.go
================================================
package playback
import (
"bytes"
"errors"
"fmt"
"io"
"reflect"
"time"
amp4 "github.com/abema/go-mp4"
"github.com/bluenviron/mediacommon/v2/pkg/formats/fmp4"
"github.com/bluenviron/mediamtx/internal/recordstore"
)
const (
sampleFlagIsNonSyncSample = 1 << 16
concatenationTolerance = 1 * time.Second
)
var errTerminated = errors.New("terminated")
type readSeekerAt interface {
io.Reader
io.Seeker
io.ReaderAt
}
func durationGoToMp4(v time.Duration, timeScale uint32) int64 {
timeScale64 := int64(timeScale)
secs := v / time.Second
dec := v % time.Second
return int64(secs)*timeScale64 + int64(dec)*timeScale64/int64(time.Second)
}
func durationMp4ToGo(v int64, timeScale uint32) time.Duration {
timeScale64 := int64(timeScale)
secs := v / timeScale64
dec := v % timeScale64
return time.Duration(secs)*time.Second + time.Duration(dec)*time.Second/time.Duration(timeScale64)
}
func findInitTrack(tracks []*fmp4.InitTrack, id int) *fmp4.InitTrack {
for _, track := range tracks {
if track.ID == id {
return track
}
}
return nil
}
func findMtxi(userData []amp4.IBox) *recordstore.Mtxi {
for _, box := range userData {
if i, ok := box.(*recordstore.Mtxi); ok {
return i
}
}
return nil
}
func segmentFMP4TracksAreEqual(tracks1 []*fmp4.InitTrack, tracks2 []*fmp4.InitTrack) bool {
if len(tracks1) != len(tracks2) {
return false
}
for i, track1 := range tracks1 {
track2 := tracks2[i]
if track1.ID != track2.ID ||
track1.TimeScale != track2.TimeScale ||
reflect.TypeOf(track1.Codec) != reflect.TypeOf(track2.Codec) {
return false
}
}
return true
}
func segmentFMP4CanBeConcatenated(
prevInit *fmp4.Init,
prevEnd time.Time,
curInit *fmp4.Init,
curStart time.Time,
) bool {
mtxi1 := findMtxi(prevInit.UserData)
mtxi2 := findMtxi(curInit.UserData)
switch {
case mtxi1 == nil && mtxi2 != nil:
return false
case mtxi1 != nil && mtxi2 == nil:
return false
case mtxi1 == nil && mtxi2 == nil: // legacy method
return segmentFMP4TracksAreEqual(prevInit.Tracks, curInit.Tracks) &&
!curStart.Before(prevEnd.Add(-concatenationTolerance)) &&
!curStart.After(prevEnd.Add(concatenationTolerance))
default:
return bytes.Equal(mtxi1.StreamID[:], mtxi2.StreamID[:]) &&
(mtxi1.SegmentNumber+1) == mtxi2.SegmentNumber
}
}
func segmentFMP4ReadHeader(r io.ReadSeeker) (*fmp4.Init, time.Duration, error) {
// check and skip ftyp
buf := make([]byte, 8)
_, err := io.ReadFull(r, buf)
if err != nil {
return nil, 0, err
}
if !bytes.Equal(buf[4:], []byte{'f', 't', 'y', 'p'}) {
return nil, 0, fmt.Errorf("ftyp box not found")
}
ftypSize := uint32(buf[0])<<24 | uint32(buf[1])<<16 | uint32(buf[2])<<8 | uint32(buf[3])
_, err = r.Seek(int64(ftypSize), io.SeekStart)
if err != nil {
return nil, 0, err
}
// check moov
_, err = io.ReadFull(r, buf)
if err != nil {
return nil, 0, err
}
if !bytes.Equal(buf[4:], []byte{'m', 'o', 'o', 'v'}) {
return nil, 0, fmt.Errorf("moov box not found")
}
moovSize := uint32(buf[0])<<24 | uint32(buf[1])<<16 | uint32(buf[2])<<8 | uint32(buf[3])
// skip moov header
_, err = r.Seek(8, io.SeekCurrent)
if err != nil {
return nil, 0, err
}
// read mvhd
var mvhd amp4.Mvhd
_, err = amp4.Unmarshal(r, uint64(moovSize-8), &mvhd, amp4.Context{})
if err != nil {
return nil, 0, err
}
d := time.Duration(mvhd.DurationV0) * time.Second / time.Duration(mvhd.Timescale)
// read ftyp and moov
_, err = r.Seek(0, io.SeekStart)
if err != nil {
return nil, 0, err
}
buf = make([]byte, uint64(ftypSize+moovSize))
_, err = io.ReadFull(r, buf)
if err != nil {
return nil, 0, err
}
// pass ftyp and moov to fmp4.Init
var init fmp4.Init
err = init.Unmarshal(bytes.NewReader(buf))
if err != nil {
return nil, 0, err
}
return &init, d, nil
}
func segmentFMP4ReadDurationFromParts(
r io.ReadSeeker,
init *fmp4.Init,
) (time.Duration, error) {
_, err := r.Seek(0, io.SeekStart)
if err != nil {
return 0, err
}
// check and skip ftyp
buf := make([]byte, 8)
_, err = io.ReadFull(r, buf)
if err != nil {
return 0, err
}
if !bytes.Equal(buf[4:], []byte{'f', 't', 'y', 'p'}) {
return 0, fmt.Errorf("ftyp box not found")
}
ftypSize := uint32(buf[0])<<24 | uint32(buf[1])<<16 | uint32(buf[2])<<8 | uint32(buf[3])
_, err = r.Seek(int64(ftypSize), io.SeekStart)
if err != nil {
return 0, err
}
// check and skip moov
_, err = io.ReadFull(r, buf)
if err != nil {
return 0, err
}
if !bytes.Equal(buf[4:], []byte{'m', 'o', 'o', 'v'}) {
return 0, fmt.Errorf("moov box not found")
}
moovSize := uint32(buf[0])<<24 | uint32(buf[1])<<16 | uint32(buf[2])<<8 | uint32(buf[3])
_, err = r.Seek(int64(moovSize)-8, io.SeekCurrent)
if err != nil {
return 0, err
}
// find last valid moof and mdat
lastMoofPos := int64(-1)
for {
var moofPos int64
moofPos, err = r.Seek(0, io.SeekCurrent)
if err != nil {
return 0, err
}
_, err = io.ReadFull(r, buf)
if err != nil {
break
}
if !bytes.Equal(buf[4:], []byte{'m', 'o', 'o', 'f'}) {
break
}
moofSize := uint32(buf[0])<<24 | uint32(buf[1])<<16 | uint32(buf[2])<<8 | uint32(buf[3])
_, err = r.Seek(int64(moofSize)-8, io.SeekCurrent)
if err != nil {
break
}
_, err = io.ReadFull(r, buf)
if err != nil {
break
}
if !bytes.Equal(buf[4:], []byte{'m', 'd', 'a', 't'}) {
break
}
mdatSize := uint32(buf[0])<<24 | uint32(buf[1])<<16 | uint32(buf[2])<<8 | uint32(buf[3])
_, err = r.Seek(int64(mdatSize)-8, io.SeekCurrent)
if err != nil {
break
}
lastMoofPos = moofPos
}
if lastMoofPos < 0 {
return 0, fmt.Errorf("no moof boxes found")
}
// open last moof
_, err = r.Seek(lastMoofPos+8, io.SeekStart)
if err != nil {
return 0, err
}
_, err = io.ReadFull(r, buf)
if err != nil {
return 0, err
}
// skip mfhd
if !bytes.Equal(buf[4:], []byte{'m', 'f', 'h', 'd'}) {
return 0, fmt.Errorf("mfhd box not found")
}
_, err = r.Seek(8, io.SeekCurrent)
if err != nil {
return 0, err
}
var maxElapsed time.Duration
// foreach traf
outer:
for {
_, err = io.ReadFull(r, buf)
if err != nil {
return 0, err
}
switch {
case bytes.Equal(buf[4:], []byte{'t', 'r', 'a', 'f'}):
case bytes.Equal(buf[4:], []byte{'m', 'd', 'a', 't'}):
break outer
default:
return 0, fmt.Errorf("unexpected box %x", buf[4:8])
}
// parse tfhd
_, err = io.ReadFull(r, buf)
if err != nil {
return 0, err
}
if !bytes.Equal(buf[4:], []byte{'t', 'f', 'h', 'd'}) {
return 0, fmt.Errorf("tfhd box not found")
}
tfhdSize := uint32(buf[0])<<24 | uint32(buf[1])<<16 | uint32(buf[2])<<8 | uint32(buf[3])
buf2 := make([]byte, tfhdSize-8)
_, err = io.ReadFull(r, buf2)
if err != nil {
return 0, err
}
var tfhd amp4.Tfhd
_, err = amp4.Unmarshal(bytes.NewReader(buf2), uint64(len(buf2)), &tfhd, amp4.Context{})
if err != nil {
return 0, fmt.Errorf("invalid tfhd box: %w", err)
}
track := findInitTrack(init.Tracks, int(tfhd.TrackID))
if track == nil {
return 0, fmt.Errorf("invalid track ID: %v", tfhd.TrackID)
}
// parse tfdt
_, err = io.ReadFull(r, buf)
if err != nil {
return 0, err
}
if !bytes.Equal(buf[4:], []byte{'t', 'f', 'd', 't'}) {
return 0, fmt.Errorf("tfdt box not found")
}
tfdtSize := uint32(buf[0])<<24 | uint32(buf[1])<<16 | uint32(buf[2])<<8 | uint32(buf[3])
buf2 = make([]byte, tfdtSize-8)
_, err = io.ReadFull(r, buf2)
if err != nil {
return 0, err
}
var tfdt amp4.Tfdt
_, err = amp4.Unmarshal(bytes.NewReader(buf2), uint64(len(buf2)), &tfdt, amp4.Context{})
if err != nil {
return 0, fmt.Errorf("invalid tfdt box: %w", err)
}
// parse trun
_, err = io.ReadFull(r, buf)
if err != nil {
return 0, err
}
if !bytes.Equal(buf[4:], []byte{'t', 'r', 'u', 'n'}) {
return 0, fmt.Errorf("trun box not found")
}
trunSize := uint32(buf[0])<<24 | uint32(buf[1])<<16 | uint32(buf[2])<<8 | uint32(buf[3])
buf2 = make([]byte, trunSize-8)
_, err = io.ReadFull(r, buf2)
if err != nil {
return 0, err
}
var trun amp4.Trun
_, err = amp4.Unmarshal(bytes.NewReader(buf2), uint64(len(buf2)), &trun, amp4.Context{})
if err != nil {
return 0, fmt.Errorf("invalid trun box: %w", err)
}
elapsed := int64(tfdt.BaseMediaDecodeTimeV1)
for _, entry := range trun.Entries {
elapsed += int64(entry.SampleDuration)
}
elapsedGo := durationMp4ToGo(elapsed, track.TimeScale)
if elapsedGo > maxElapsed {
maxElapsed = elapsedGo
}
}
return maxElapsed, nil
}
func segmentFMP4MuxParts(
r readSeekerAt,
startDTS time.Duration,
duration time.Duration,
tracks []*fmp4.InitTrack,
m muxer,
) (time.Duration, error) {
var startDTSMP4 int64
var durationMP4 int64
moofOffset := uint64(0)
var tfhd *amp4.Tfhd
var tfdt *amp4.Tfdt
var timeScale uint32
var segmentDuration time.Duration
breakAtNextMdat := false
_, err := amp4.ReadBoxStructure(r, func(h *amp4.ReadHandle) (any, error) {
switch h.BoxInfo.Type.String() {
case "moof":
moofOffset = h.BoxInfo.Offset
return h.Expand()
case "traf":
return h.Expand()
case "tfhd":
box, _, err := h.ReadPayload()
if err != nil {
return nil, err
}
tfhd = box.(*amp4.Tfhd)
case "tfdt":
box, _, err := h.ReadPayload()
if err != nil {
return nil, err
}
tfdt = box.(*amp4.Tfdt)
track := findInitTrack(tracks, int(tfhd.TrackID))
if track == nil {
return nil, fmt.Errorf("invalid track ID: %v", tfhd.TrackID)
}
m.setTrack(int(tfhd.TrackID))
timeScale = track.TimeScale
startDTSMP4 = durationGoToMp4(startDTS, track.TimeScale)
durationMP4 = durationGoToMp4(duration, track.TimeScale)
case "trun":
box, _, err := h.ReadPayload()
if err != nil {
return nil, err
}
trun := box.(*amp4.Trun)
dataOffset := moofOffset + uint64(trun.DataOffset)
dts := int64(tfdt.BaseMediaDecodeTimeV1) + startDTSMP4
for _, e := range trun.Entries {
if dts >= durationMP4 {
breakAtNextMdat = true
break
}
sampleOffset := dataOffset
sampleSize := e.SampleSize
err = m.writeSample(
dts,
e.SampleCompositionTimeOffsetV1,
(e.SampleFlags&sampleFlagIsNonSyncSample) != 0,
e.SampleSize,
func() ([]byte, error) {
payload := make([]byte, sampleSize)
n, err2 := r.ReadAt(payload, int64(sampleOffset))
if err2 != nil {
return nil, err2
}
if n != int(sampleSize) {
return nil, fmt.Errorf("partial read")
}
return payload, nil
},
)
if err != nil {
return nil, err
}
dataOffset += uint64(e.SampleSize)
dts += int64(e.SampleDuration)
}
m.writeFinalDTS(dts)
segmentElapsed := durationMp4ToGo(dts-startDTSMP4, timeScale)
if segmentElapsed > segmentDuration {
segmentDuration = segmentElapsed
}
case "mdat":
if breakAtNextMdat {
return nil, errTerminated
}
}
return nil, nil
})
if err != nil && !errors.Is(err, errTerminated) {
return 0, err
}
return segmentDuration, nil
}
================================================
FILE: internal/playback/segment_fmp4_test.go
================================================
package playback
import (
"io"
"os"
"testing"
"time"
amp4 "github.com/abema/go-mp4"
"github.com/bluenviron/mediacommon/v2/pkg/codecs/mpeg4audio"
"github.com/bluenviron/mediacommon/v2/pkg/formats/fmp4"
mcodecs "github.com/bluenviron/mediacommon/v2/pkg/formats/mp4/codecs"
"github.com/bluenviron/mediamtx/internal/recordstore"
"github.com/bluenviron/mediamtx/internal/test"
"github.com/stretchr/testify/require"
)
func writeBenchInit(f io.WriteSeeker) {
init := fmp4.Init{
Tracks: []*fmp4.InitTrack{
{
ID: 1,
TimeScale: 90000,
Codec: &mcodecs.H264{
SPS: test.FormatH264.SPS,
PPS: test.FormatH264.PPS,
},
},
{
ID: 2,
TimeScale: 90000,
Codec: &mcodecs.MPEG4Audio{
Config: mpeg4audio.AudioSpecificConfig{
Type: mpeg4audio.ObjectTypeAACLC,
SampleRate: 48000,
ChannelCount: 2,
},
},
},
},
}
err := init.Marshal(f)
if err != nil {
panic(err)
}
_, err = f.Write([]byte{
0x00, 0x00, 0x00, 0x10, 'm', 'o', 'o', 'f',
})
if err != nil {
panic(err)
}
}
func BenchmarkFMP4ReadHeader(b *testing.B) {
f, err := os.CreateTemp(os.TempDir(), "mediamtx-playback-fmp4-")
if err != nil {
panic(err)
}
defer os.Remove(f.Name())
writeBenchInit(f)
f.Close()
for b.Loop() {
func() {
f, err = os.Open(f.Name())
if err != nil {
panic(err)
}
defer f.Close()
_, _, err = segmentFMP4ReadHeader(f)
if err != nil {
panic(err)
}
}()
}
}
func TestSegmentFMP4CanBeConcatenated(t *testing.T) {
baseTime := time.Date(2024, 1, 1, 0, 0, 0, 0, time.UTC)
streamID1 := [16]byte{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16}
streamID2 := [16]byte{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 17}
baseTracks := []*fmp4.InitTrack{
{
ID: 1,
TimeScale: 90000,
Codec: &mcodecs.H264{
SPS: test.FormatH264.SPS,
PPS: test.FormatH264.PPS,
},
},
{
ID: 2,
TimeScale: 48000,
Codec: &mcodecs.MPEG4Audio{
Config: mpeg4audio.AudioSpecificConfig{
Type: mpeg4audio.ObjectTypeAACLC,
SampleRate: 48000,
ChannelCount: 2,
},
},
},
}
differentTracks := []*fmp4.InitTrack{
{
ID: 1,
TimeScale: 90000,
Codec: &mcodecs.H264{
SPS: test.FormatH264.SPS,
PPS: test.FormatH264.PPS,
},
},
}
for _, tt := range []struct {
name string
prevInit *fmp4.Init
prevEnd time.Time
curInit *fmp4.Init
curStart time.Time
want bool
}{
{
name: "with mtxi - consecutive segments, same stream",
prevInit: &fmp4.Init{
Tracks: baseTracks,
UserData: []amp4.IBox{
&recordstore.Mtxi{
StreamID: streamID1,
SegmentNumber: 1,
},
},
},
prevEnd: baseTime,
curInit: &fmp4.Init{
Tracks: baseTracks,
UserData: []amp4.IBox{
&recordstore.Mtxi{
StreamID: streamID1,
SegmentNumber: 2,
},
},
},
curStart: baseTime.Add(5 * time.Second),
want: true,
},
{
name: "with mtxi - non-consecutive segments, same stream",
prevInit: &fmp4.Init{
Tracks: baseTracks,
UserData: []amp4.IBox{
&recordstore.Mtxi{
StreamID: streamID1,
SegmentNumber: 1,
},
},
},
prevEnd: baseTime,
curInit: &fmp4.Init{
Tracks: baseTracks,
UserData: []amp4.IBox{
&recordstore.Mtxi{
StreamID: streamID1,
SegmentNumber: 3,
},
},
},
curStart: baseTime.Add(5 * time.Second),
want: false,
},
{
name: "with mtxi - consecutive segments, different streams",
prevInit: &fmp4.Init{
Tracks: baseTracks,
UserData: []amp4.IBox{
&recordstore.Mtxi{
StreamID: streamID1,
SegmentNumber: 1,
},
},
},
prevEnd: baseTime,
curInit: &fmp4.Init{
Tracks: baseTracks,
UserData: []amp4.IBox{
&recordstore.Mtxi{
StreamID: streamID2,
SegmentNumber: 2,
},
},
},
curStart: baseTime.Add(5 * time.Second),
want: false,
},
{
name: "prev has mtxi, current does not",
prevInit: &fmp4.Init{
Tracks: baseTracks,
UserData: []amp4.IBox{
&recordstore.Mtxi{
StreamID: streamID1,
SegmentNumber: 1,
},
},
},
prevEnd: baseTime,
curInit: &fmp4.Init{
Tracks: baseTracks,
UserData: []amp4.IBox{},
},
curStart: baseTime.Add(5 * time.Second),
want: false,
},
{
name: "prev does not have mtxi, current has mtxi",
prevInit: &fmp4.Init{
Tracks: baseTracks,
UserData: []amp4.IBox{},
},
prevEnd: baseTime,
curInit: &fmp4.Init{
Tracks: baseTracks,
UserData: []amp4.IBox{
&recordstore.Mtxi{
StreamID: streamID1,
SegmentNumber: 1,
},
},
},
curStart: baseTime.Add(5 * time.Second),
want: false,
},
{
name: "legacy mode - same tracks, within time tolerance",
prevInit: &fmp4.Init{
Tracks: baseTracks,
UserData: []amp4.IBox{},
},
prevEnd: baseTime.Add(10 * time.Second),
curInit: &fmp4.Init{
Tracks: baseTracks,
UserData: []amp4.IBox{},
},
curStart: baseTime.Add(10 * time.Second),
want: true,
},
{
name: "legacy mode - same tracks, exactly at tolerance boundary (before)",
prevInit: &fmp4.Init{
Tracks: baseTracks,
UserData: []amp4.IBox{},
},
prevEnd: baseTime.Add(10 * time.Second),
curInit: &fmp4.Init{
Tracks: baseTracks,
UserData: []amp4.IBox{},
},
curStart: baseTime.Add(9 * time.Second),
want: true,
},
{
name: "legacy mode - same tracks, exactly at tolerance boundary (after)",
prevInit: &fmp4.Init{
Tracks: baseTracks,
UserData: []amp4.IBox{},
},
prevEnd: baseTime.Add(10 * time.Second),
curInit: &fmp4.Init{
Tracks: baseTracks,
UserData: []amp4.IBox{},
},
curStart: baseTime.Add(11 * time.Second),
want: true,
},
{
name: "legacy mode - same tracks, outside time tolerance (too early)",
prevInit: &fmp4.Init{
Tracks: baseTracks,
UserData: []amp4.IBox{},
},
prevEnd: baseTime.Add(10 * time.Second),
curInit: &fmp4.Init{
Tracks: baseTracks,
UserData: []amp4.IBox{},
},
curStart: baseTime.Add(8*time.Second + 999*time.Millisecond),
want: false,
},
{
name: "legacy mode - same tracks, outside time tolerance (too late)",
prevInit: &fmp4.Init{
Tracks: baseTracks,
UserData: []amp4.IBox{},
},
prevEnd: baseTime.Add(10 * time.Second),
curInit: &fmp4.Init{
Tracks: baseTracks,
UserData: []amp4.IBox{},
},
curStart: baseTime.Add(11*time.Second + 1*time.Millisecond),
want: false,
},
{
name: "legacy mode - different number of tracks",
prevInit: &fmp4.Init{
Tracks: baseTracks,
UserData: []amp4.IBox{},
},
prevEnd: baseTime,
curInit: &fmp4.Init{
Tracks: differentTracks,
UserData: []amp4.IBox{},
},
curStart: baseTime.Add(5 * time.Second),
want: false,
},
{
name: "legacy mode - different track IDs",
prevInit: &fmp4.Init{
Tracks: []*fmp4.InitTrack{
{
ID: 1,
TimeScale: 90000,
Codec: &mcodecs.H264{
SPS: test.FormatH264.SPS,
PPS: test.FormatH264.PPS,
},
},
},
UserData: []amp4.IBox{},
},
prevEnd: baseTime,
curInit: &fmp4.Init{
Tracks: []*fmp4.InitTrack{
{
ID: 2,
TimeScale: 90000,
Codec: &mcodecs.H264{
SPS: test.FormatH264.SPS,
PPS: test.FormatH264.PPS,
},
},
},
UserData: []amp4.IBox{},
},
curStart: baseTime.Add(5 * time.Second),
want: false,
},
{
name: "legacy mode - different time scales",
prevInit: &fmp4.Init{
Tracks: []*fmp4.InitTrack{
{
ID: 1,
TimeScale: 90000,
Codec: &mcodecs.H264{
SPS: test.FormatH264.SPS,
PPS: test.FormatH264.PPS,
},
},
},
UserData: []amp4.IBox{},
},
prevEnd: baseTime,
curInit: &fmp4.Init{
Tracks: []*fmp4.InitTrack{
{
ID: 1,
TimeScale: 48000,
Codec: &mcodecs.H264{
SPS: test.FormatH264.SPS,
PPS: test.FormatH264.PPS,
},
},
},
UserData: []amp4.IBox{},
},
curStart: baseTime.Add(5 * time.Second),
want: false,
},
{
name: "legacy mode - different codec types",
prevInit: &fmp4.Init{
Tracks: []*fmp4.InitTrack{
{
ID: 1,
TimeScale: 90000,
Codec: &mcodecs.H264{
SPS: test.FormatH264.SPS,
PPS: test.FormatH264.PPS,
},
},
},
UserData: []amp4.IBox{},
},
prevEnd: baseTime,
curInit: &fmp4.Init{
Tracks: []*fmp4.InitTrack{
{
ID: 1,
TimeScale: 90000,
Codec: &mcodecs.MPEG4Audio{
Config: mpeg4audio.AudioSpecificConfig{
Type: mpeg4audio.ObjectTypeAACLC,
SampleRate: 48000,
ChannelCount: 2,
},
},
},
},
UserData: []amp4.IBox{},
},
curStart: baseTime.Add(5 * time.Second),
want: false,
},
} {
t.Run(tt.name, func(t *testing.T) {
got := segmentFMP4CanBeConcatenated(tt.prevInit, tt.prevEnd, tt.curInit, tt.curStart)
require.Equal(t, tt.want, got)
})
}
}
================================================
FILE: internal/playback/server.go
================================================
// Package playback contains the playback server.
package playback
import (
"net"
"net/http"
"sync"
"time"
"github.com/bluenviron/mediamtx/internal/auth"
"github.com/bluenviron/mediamtx/internal/conf"
"github.com/bluenviron/mediamtx/internal/defs"
"github.com/bluenviron/mediamtx/internal/logger"
"github.com/bluenviron/mediamtx/internal/protocols/httpp"
"github.com/gin-gonic/gin"
)
type serverAuthManager interface {
Authenticate(req *auth.Request) (string, *auth.Error)
}
// Server is the playback server.
type Server struct {
Address string
DumpPackets bool
Encryption bool
ServerKey string
ServerCert string
AllowOrigins []string
TrustedProxies conf.IPNetworks
ReadTimeout conf.Duration
WriteTimeout conf.Duration
PathConfs map[string]*conf.Path
AuthManager serverAuthManager
Parent logger.Writer
httpServer *httpp.Server
mutex sync.RWMutex
}
// Initialize initializes Server.
func (s *Server) Initialize() error {
router := gin.New()
router.SetTrustedProxies(s.TrustedProxies.ToTrustedProxies()) //nolint:errcheck
router.Use(s.middlewarePreflightRequests)
router.GET("/list", s.onList)
router.GET("/get", s.onGet)
s.httpServer = &httpp.Server{
Address: s.Address,
AllowOrigins: s.AllowOrigins,
DumpPackets: s.DumpPackets,
DumpPacketsPrefix: "playback_server_conn",
ReadTimeout: time.Duration(s.ReadTimeout),
WriteTimeout: time.Duration(s.WriteTimeout),
Encryption: s.Encryption,
ServerCert: s.ServerCert,
ServerKey: s.ServerKey,
Handler: router,
Parent: s,
}
err := s.httpServer.Initialize()
if err != nil {
return err
}
s.Log(logger.Info, "listener opened on "+s.Address)
return nil
}
// Close closes Server.
func (s *Server) Close() {
s.Log(logger.Info, "listener is closing")
s.httpServer.Close()
}
// Log implements logger.Writer.
func (s *Server) Log(level logger.Level, format string, args ...any) {
s.Parent.Log(level, "[playback] "+format, args...)
}
// ReloadPathConfs is called by core.Core.
func (s *Server) ReloadPathConfs(pathConfs map[string]*conf.Path) {
s.mutex.Lock()
defer s.mutex.Unlock()
s.PathConfs = pathConfs
}
func (s *Server) writeError(ctx *gin.Context, status int, err error) {
// show error in logs
s.Log(logger.Error, err.Error())
// add error to response
ctx.String(status, err.Error())
}
func (s *Server) safeFindPathConf(name string) (*conf.Path, error) {
s.mutex.RLock()
defer s.mutex.RUnlock()
pathConf, _, err := conf.FindPathConf(s.PathConfs, name)
return pathConf, err
}
func (s *Server) middlewarePreflightRequests(ctx *gin.Context) {
if ctx.Request.Method == http.MethodOptions &&
ctx.Request.Header.Get("Access-Control-Request-Method") != "" {
ctx.Header("Access-Control-Allow-Methods", "OPTIONS, GET")
ctx.Header("Access-Control-Allow-Headers", "Authorization")
ctx.AbortWithStatus(http.StatusNoContent)
return
}
}
func (s *Server) doAuth(ctx *gin.Context, pathName string) bool {
req := &auth.Request{
Action: conf.AuthActionPlayback,
Path: pathName,
Query: ctx.Request.URL.RawQuery,
Credentials: httpp.Credentials(ctx.Request),
IP: net.ParseIP(ctx.ClientIP()),
}
_, err := s.AuthManager.Authenticate(req)
if err != nil {
if err.AskCredentials {
ctx.Header("WWW-Authenticate", `Basic realm="mediamtx"`)
ctx.AbortWithStatusJSON(http.StatusUnauthorized, &defs.APIError{
Status: defs.APIErrorStatusError,
Error: "authentication error",
})
return false
}
s.Log(logger.Info, "connection %v failed to authenticate: %v",
httpp.RemoteAddr(ctx), err.Wrapped)
// wait some seconds to delay brute force attacks
<-time.After(auth.PauseAfterError)
ctx.AbortWithStatusJSON(http.StatusUnauthorized, &defs.APIError{
Status: defs.APIErrorStatusError,
Error: "authentication error",
})
return false
}
return true
}
================================================
FILE: internal/playback/server_test.go
================================================
package playback
import (
"fmt"
"io"
"net/http"
"net/url"
"testing"
"time"
"github.com/bluenviron/mediamtx/internal/auth"
"github.com/bluenviron/mediamtx/internal/conf"
"github.com/bluenviron/mediamtx/internal/logger"
"github.com/bluenviron/mediamtx/internal/test"
"github.com/stretchr/testify/require"
)
func TestPreflightRequest(t *testing.T) {
s := &Server{
Address: "127.0.0.1:9996",
AllowOrigins: []string{"*"},
ReadTimeout: conf.Duration(10 * time.Second),
WriteTimeout: conf.Duration(10 * time.Second),
Parent: test.NilLogger,
}
err := s.Initialize()
require.NoError(t, err)
defer s.Close()
tr := &http.Transport{}
defer tr.CloseIdleConnections()
hc := &http.Client{Transport: tr}
req, err := http.NewRequest(http.MethodOptions, "http://localhost:9996", nil)
require.NoError(t, err)
req.Header.Add("Access-Control-Request-Method", "GET")
res, err := hc.Do(req)
require.NoError(t, err)
defer res.Body.Close()
require.Equal(t, http.StatusNoContent, res.StatusCode)
byts, err := io.ReadAll(res.Body)
require.NoError(t, err)
require.Equal(t, "*", res.Header.Get("Access-Control-Allow-Origin"))
require.Equal(t, "true", res.Header.Get("Access-Control-Allow-Credentials"))
require.Equal(t, "OPTIONS, GET", res.Header.Get("Access-Control-Allow-Methods"))
require.Equal(t, "Authorization", res.Header.Get("Access-Control-Allow-Headers"))
require.Equal(t, byts, []byte{})
}
func TestAuthError(t *testing.T) {
n := 0
s := &Server{
Address: "127.0.0.1:9996",
ReadTimeout: conf.Duration(10 * time.Second),
WriteTimeout: conf.Duration(10 * time.Second),
AuthManager: &test.AuthManager{
AuthenticateImpl: func(req *auth.Request) (string, *auth.Error) {
if req.Credentials.User == "" {
return "", &auth.Error{AskCredentials: true, Wrapped: fmt.Errorf("auth error")}
}
return "", &auth.Error{Wrapped: fmt.Errorf("auth error")}
},
},
Parent: test.Logger(func(l logger.Level, s string, i ...any) {
if l == logger.Info {
if n == 1 {
require.Regexp(t, "failed to authenticate: auth error$", fmt.Sprintf(s, i...))
}
n++
}
}),
}
err := s.Initialize()
require.NoError(t, err)
defer s.Close()
u, err := url.Parse("http://localhost:9996/list")
require.NoError(t, err)
v := url.Values{}
v.Set("path", "mypath")
u.RawQuery = v.Encode()
req, err := http.NewRequest(http.MethodGet, u.String(), nil)
require.NoError(t, err)
res, err := http.DefaultClient.Do(req)
require.NoError(t, err)
defer res.Body.Close()
require.Equal(t, http.StatusUnauthorized, res.StatusCode)
require.Equal(t, `Basic realm="mediamtx"`, res.Header.Get("WWW-Authenticate"))
u, err = url.Parse("http://myuser:mypass@localhost:9996/list")
require.NoError(t, err)
v = url.Values{}
v.Set("path", "mypath")
u.RawQuery = v.Encode()
req, err = http.NewRequest(http.MethodGet, u.String(), nil)
require.NoError(t, err)
start := time.Now()
res, err = http.DefaultClient.Do(req)
require.NoError(t, err)
defer res.Body.Close()
require.Greater(t, time.Since(start), 2*time.Second)
require.Equal(t, http.StatusUnauthorized, res.StatusCode)
require.Equal(t, 2, n)
}
================================================
FILE: internal/pprof/pprof.go
================================================
// Package pprof contains a pprof exporter.
package pprof //nolint:revive
import (
"net"
"net/http"
"time"
"github.com/gin-contrib/pprof"
"github.com/gin-gonic/gin"
"github.com/bluenviron/mediamtx/internal/auth"
"github.com/bluenviron/mediamtx/internal/conf"
"github.com/bluenviron/mediamtx/internal/defs"
"github.com/bluenviron/mediamtx/internal/logger"
"github.com/bluenviron/mediamtx/internal/protocols/httpp"
)
type pprofAuthManager interface {
Authenticate(req *auth.Request) (string, *auth.Error)
}
type pprofParent interface {
logger.Writer
}
// PPROF is a pprof exporter.
type PPROF struct {
Address string
DumpPackets bool
Encryption bool
ServerKey string
ServerCert string
AllowOrigins []string
TrustedProxies conf.IPNetworks
ReadTimeout conf.Duration
WriteTimeout conf.Duration
AuthManager pprofAuthManager
Parent pprofParent
httpServer *httpp.Server
}
// Initialize initializes PPROF.
func (pp *PPROF) Initialize() error {
router := gin.New()
router.SetTrustedProxies(pp.TrustedProxies.ToTrustedProxies()) //nolint:errcheck
router.Use(pp.middlewarePreflightRequests)
router.Use(pp.middlewareAuth)
pprof.Register(router)
pp.httpServer = &httpp.Server{
Address: pp.Address,
DumpPackets: pp.DumpPackets,
AllowOrigins: pp.AllowOrigins,
DumpPacketsPrefix: "pprof_server_conn",
ReadTimeout: time.Duration(pp.ReadTimeout),
WriteTimeout: time.Duration(pp.WriteTimeout),
Encryption: pp.Encryption,
ServerCert: pp.ServerCert,
ServerKey: pp.ServerKey,
Handler: router,
Parent: pp,
}
err := pp.httpServer.Initialize()
if err != nil {
return err
}
pp.Log(logger.Info, "listener opened on "+pp.Address)
return nil
}
// Close closes PPROF.
func (pp *PPROF) Close() {
pp.Log(logger.Info, "listener is closing")
pp.httpServer.Close()
}
// Log implements logger.Writer.
func (pp *PPROF) Log(level logger.Level, format string, args ...any) {
pp.Parent.Log(level, "[pprof] "+format, args...)
}
func (pp *PPROF) middlewarePreflightRequests(ctx *gin.Context) {
if ctx.Request.Method == http.MethodOptions &&
ctx.Request.Header.Get("Access-Control-Request-Method") != "" {
ctx.Header("Access-Control-Allow-Methods", "OPTIONS, GET")
ctx.Header("Access-Control-Allow-Headers", "Authorization")
ctx.AbortWithStatus(http.StatusNoContent)
return
}
}
func (pp *PPROF) middlewareAuth(ctx *gin.Context) {
req := &auth.Request{
Action: conf.AuthActionPprof,
Query: ctx.Request.URL.RawQuery,
Credentials: httpp.Credentials(ctx.Request),
IP: net.ParseIP(ctx.ClientIP()),
}
_, err := pp.AuthManager.Authenticate(req)
if err != nil {
if err.AskCredentials {
ctx.Header("WWW-Authenticate", `Basic realm="mediamtx"`)
ctx.AbortWithStatusJSON(http.StatusUnauthorized, &defs.APIError{
Status: defs.APIErrorStatusError,
Error: "authentication error",
})
return
}
pp.Log(logger.Info, "connection %v failed to authenticate: %v", httpp.RemoteAddr(ctx), err.Wrapped)
// wait some seconds to delay brute force attacks
<-time.After(auth.PauseAfterError)
ctx.AbortWithStatusJSON(http.StatusUnauthorized, &defs.APIError{
Status: defs.APIErrorStatusError,
Error: "authentication error",
})
return
}
}
================================================
FILE: internal/pprof/pprof_test.go
================================================
package pprof //nolint:revive
import (
"fmt"
"io"
"net/http"
"testing"
"time"
"github.com/bluenviron/mediamtx/internal/auth"
"github.com/bluenviron/mediamtx/internal/conf"
"github.com/bluenviron/mediamtx/internal/logger"
"github.com/bluenviron/mediamtx/internal/test"
"github.com/stretchr/testify/require"
)
func TestPreflightRequest(t *testing.T) {
s := &PPROF{
Address: "127.0.0.1:9999",
AllowOrigins: []string{"*"},
ReadTimeout: conf.Duration(10 * time.Second),
WriteTimeout: conf.Duration(10 * time.Second),
Parent: test.NilLogger,
}
err := s.Initialize()
require.NoError(t, err)
defer s.Close()
tr := &http.Transport{}
defer tr.CloseIdleConnections()
hc := &http.Client{Transport: tr}
req, err := http.NewRequest(http.MethodOptions, "http://localhost:9999", nil)
require.NoError(t, err)
req.Header.Add("Access-Control-Request-Method", "GET")
res, err := hc.Do(req)
require.NoError(t, err)
defer res.Body.Close()
require.Equal(t, http.StatusNoContent, res.StatusCode)
byts, err := io.ReadAll(res.Body)
require.NoError(t, err)
require.Equal(t, "*", res.Header.Get("Access-Control-Allow-Origin"))
require.Equal(t, "true", res.Header.Get("Access-Control-Allow-Credentials"))
require.Equal(t, "OPTIONS, GET", res.Header.Get("Access-Control-Allow-Methods"))
require.Equal(t, "Authorization", res.Header.Get("Access-Control-Allow-Headers"))
require.Equal(t, byts, []byte{})
}
func TestPprof(t *testing.T) {
checked := false
s := &PPROF{
Address: "127.0.0.1:9999",
AllowOrigins: []string{"*"},
ReadTimeout: conf.Duration(10 * time.Second),
WriteTimeout: conf.Duration(10 * time.Second),
AuthManager: &test.AuthManager{
AuthenticateImpl: func(req *auth.Request) (string, *auth.Error) {
require.Equal(t, conf.AuthActionPprof, req.Action)
require.Equal(t, "myuser", req.Credentials.User)
require.Equal(t, "mypass", req.Credentials.Pass)
checked = true
return req.Credentials.User, nil
},
},
Parent: test.NilLogger,
}
err := s.Initialize()
require.NoError(t, err)
defer s.Close()
tr := &http.Transport{}
defer tr.CloseIdleConnections()
hc := &http.Client{Transport: tr}
req, err := http.NewRequest(http.MethodGet, "http://myuser:mypass@127.0.0.1:9999/debug/pprof/heap", nil)
require.NoError(t, err)
res, err := hc.Do(req)
require.NoError(t, err)
defer res.Body.Close()
require.Equal(t, http.StatusOK, res.StatusCode)
byts, err := io.ReadAll(res.Body)
require.NoError(t, err)
require.NotEmpty(t, byts)
require.True(t, checked)
}
func TestAuthError(t *testing.T) {
n := 0
s := &PPROF{
Address: "127.0.0.1:9999",
AllowOrigins: []string{"*"},
ReadTimeout: conf.Duration(10 * time.Second),
WriteTimeout: conf.Duration(10 * time.Second),
AuthManager: &test.AuthManager{
AuthenticateImpl: func(req *auth.Request) (string, *auth.Error) {
if req.Credentials.User == "" {
return "", &auth.Error{AskCredentials: true, Wrapped: fmt.Errorf("auth error")}
}
return "", &auth.Error{Wrapped: fmt.Errorf("auth error")}
},
},
Parent: test.Logger(func(l logger.Level, s string, i ...any) {
if l == logger.Info {
if n == 1 {
require.Regexp(t, "failed to authenticate: auth error$", fmt.Sprintf(s, i...))
}
n++
}
}),
}
err := s.Initialize()
require.NoError(t, err)
defer s.Close()
tr := &http.Transport{}
defer tr.CloseIdleConnections()
hc := &http.Client{Transport: tr}
req, err := http.NewRequest(http.MethodGet, "http://127.0.0.1:9999/debug/pprof/heap", nil)
require.NoError(t, err)
res, err := hc.Do(req)
require.NoError(t, err)
defer res.Body.Close()
require.Equal(t, http.StatusUnauthorized, res.StatusCode)
require.Equal(t, `Basic realm="mediamtx"`, res.Header.Get("WWW-Authenticate"))
req, err = http.NewRequest(http.MethodGet, "http://myuser:mypass@127.0.0.1:9999/debug/pprof/heap", nil)
require.NoError(t, err)
res, err = hc.Do(req)
require.NoError(t, err)
defer res.Body.Close()
require.Equal(t, http.StatusUnauthorized, res.StatusCode)
require.Equal(t, 2, n)
}
================================================
FILE: internal/protocols/hls/from_stream.go
================================================
// Package hls contains HLS utilities.
package hls
import (
"errors"
"fmt"
"slices"
"github.com/bluenviron/gohlslib/v2"
"github.com/bluenviron/gohlslib/v2/pkg/codecs"
"github.com/bluenviron/gortsplib/v5/pkg/description"
"github.com/bluenviron/gortsplib/v5/pkg/format"
"github.com/bluenviron/mediacommon/v2/pkg/codecs/mpeg4audio"
"github.com/bluenviron/mediamtx/internal/logger"
"github.com/bluenviron/mediamtx/internal/stream"
"github.com/bluenviron/mediamtx/internal/unit"
)
// ErrNoSupportedCodecs is returned by FromStream when there are no supported codecs.
var ErrNoSupportedCodecs = errors.New(
"the stream doesn't contain any supported codec, which are currently AV1, VP9, H265, H264, Opus, MPEG-4 Audio")
func setupVideoTrack(
desc *description.Session,
r *stream.Reader,
muxer *gohlslib.Muxer,
) {
addTrack := func(
media *description.Media,
forma format.Format,
track *gohlslib.Track,
onData stream.OnDataFunc,
) {
muxer.Tracks = append(muxer.Tracks, track)
r.OnData(media, forma, onData)
}
var videoFormatAV1 *format.AV1
videoMedia := desc.FindFormat(&videoFormatAV1)
if videoFormatAV1 != nil {
track := &gohlslib.Track{
Codec: &codecs.AV1{},
ClockRate: videoFormatAV1.ClockRate(),
}
addTrack(
videoMedia,
videoFormatAV1,
track,
func(u *unit.Unit) error {
if u.NilPayload() {
return nil
}
err := muxer.WriteAV1(
track,
u.NTP,
u.PTS, // no conversion is needed since we set gohlslib.Track.ClockRate = format.ClockRate
u.Payload.(unit.PayloadAV1))
if err != nil {
return fmt.Errorf("muxer error: %w", err)
}
return nil
})
return
}
var videoFormatVP9 *format.VP9
videoMedia = desc.FindFormat(&videoFormatVP9)
if videoFormatVP9 != nil {
track := &gohlslib.Track{
Codec: &codecs.VP9{},
ClockRate: videoFormatVP9.ClockRate(),
}
addTrack(
videoMedia,
videoFormatVP9,
track,
func(u *unit.Unit) error {
if u.NilPayload() {
return nil
}
err := muxer.WriteVP9(
track,
u.NTP,
u.PTS, // no conversion is needed since we set gohlslib.Track.ClockRate = format.ClockRate
u.Payload.(unit.PayloadVP9))
if err != nil {
return fmt.Errorf("muxer error: %w", err)
}
return nil
})
return
}
var videoFormatH265 *format.H265
videoMedia = desc.FindFormat(&videoFormatH265)
if videoFormatH265 != nil {
vps, sps, pps := videoFormatH265.SafeParams()
track := &gohlslib.Track{
Codec: &codecs.H265{
VPS: vps,
SPS: sps,
PPS: pps,
},
ClockRate: videoFormatH265.ClockRate(),
}
addTrack(
videoMedia,
videoFormatH265,
track,
func(u *unit.Unit) error {
if u.NilPayload() {
return nil
}
err := muxer.WriteH265(
track,
u.NTP,
u.PTS, // no conversion is needed since we set gohlslib.Track.ClockRate = format.ClockRate
u.Payload.(unit.PayloadH265))
if err != nil {
return fmt.Errorf("muxer error: %w", err)
}
return nil
})
return
}
var videoFormatH264 *format.H264
videoMedia = desc.FindFormat(&videoFormatH264)
if videoFormatH264 != nil {
sps, pps := videoFormatH264.SafeParams()
track := &gohlslib.Track{
Codec: &codecs.H264{
SPS: sps,
PPS: pps,
},
ClockRate: videoFormatH264.ClockRate(),
}
addTrack(
videoMedia,
videoFormatH264,
track,
func(u *unit.Unit) error {
if u.NilPayload() {
return nil
}
err := muxer.WriteH264(
track,
u.NTP,
u.PTS, // no conversion is needed since we set gohlslib.Track.ClockRate = format.ClockRate
u.Payload.(unit.PayloadH264))
if err != nil {
return fmt.Errorf("muxer error: %w", err)
}
return nil
})
return
}
}
func setupAudioTracks(
desc *description.Session,
r *stream.Reader,
muxer *gohlslib.Muxer,
) {
addTrack := func(
medi *description.Media,
forma format.Format,
track *gohlslib.Track,
onData stream.OnDataFunc,
) {
muxer.Tracks = append(muxer.Tracks, track)
r.OnData(medi, forma, onData)
}
for _, media := range desc.Medias {
for _, forma := range media.Formats {
switch forma := forma.(type) {
case *format.Opus:
track := &gohlslib.Track{
Codec: &codecs.Opus{
ChannelCount: forma.ChannelCount,
},
ClockRate: forma.ClockRate(),
}
addTrack(
media,
forma,
track,
func(u *unit.Unit) error {
err := muxer.WriteOpus(
track,
u.NTP,
u.PTS, // no conversion is needed since we set gohlslib.Track.ClockRate = format.ClockRate
u.Payload.(unit.PayloadOpus))
if err != nil {
return fmt.Errorf("muxer error: %w", err)
}
return nil
})
case *format.MPEG4Audio:
track := &gohlslib.Track{
Codec: &codecs.MPEG4Audio{
Config: *forma.Config,
},
ClockRate: forma.ClockRate(),
}
addTrack(
media,
forma,
track,
func(u *unit.Unit) error {
if u.NilPayload() {
return nil
}
err := muxer.WriteMPEG4Audio(
track,
u.NTP,
u.PTS, // no conversion is needed since we set gohlslib.Track.ClockRate = format.ClockRate
u.Payload.(unit.PayloadMPEG4Audio))
if err != nil {
return fmt.Errorf("muxer error: %w", err)
}
return nil
})
case *format.MPEG4AudioLATM:
if !forma.CPresent {
track := &gohlslib.Track{
Codec: &codecs.MPEG4Audio{
Config: *forma.StreamMuxConfig.Programs[0].Layers[0].AudioSpecificConfig,
},
ClockRate: forma.ClockRate(),
}
addTrack(
media,
forma,
track,
func(u *unit.Unit) error {
if u.NilPayload() {
return nil
}
var ame mpeg4audio.AudioMuxElement
ame.StreamMuxConfig = forma.StreamMuxConfig
err := ame.Unmarshal(u.Payload.(unit.PayloadMPEG4AudioLATM))
if err != nil {
return err
}
return muxer.WriteMPEG4Audio(
track,
u.NTP,
u.PTS, // no conversion is needed since we set gohlslib.Track.ClockRate = format.ClockRate
[][]byte{ame.Payloads[0][0][0]})
})
}
}
}
}
}
// FromStream maps a MediaMTX stream to a HLS muxer.
func FromStream(
desc *description.Session,
r *stream.Reader,
muxer *gohlslib.Muxer,
) error {
setupVideoTrack(
desc,
r,
muxer,
)
setupAudioTracks(
desc,
r,
muxer,
)
if len(muxer.Tracks) == 0 {
return ErrNoSupportedCodecs
}
setuppedFormats := r.Formats()
n := 1
for _, media := range desc.Medias {
for _, forma := range media.Formats {
if !slices.Contains(setuppedFormats, forma) {
r.Parent.Log(logger.Warn, "skipping track %d (%s)", n, forma.Codec())
}
n++
}
}
return nil
}
================================================
FILE: internal/protocols/hls/from_stream_test.go
================================================
package hls
import (
"fmt"
"testing"
"github.com/bluenviron/gohlslib/v2"
"github.com/bluenviron/gortsplib/v5/pkg/description"
"github.com/bluenviron/gortsplib/v5/pkg/format"
"github.com/bluenviron/mediamtx/internal/logger"
"github.com/bluenviron/mediamtx/internal/stream"
"github.com/bluenviron/mediamtx/internal/test"
"github.com/stretchr/testify/require"
)
func TestFromStreamNoSupportedCodecs(t *testing.T) {
desc := &description.Session{Medias: []*description.Media{{
Type: description.MediaTypeVideo,
Formats: []format.Format{&format.VP8{}},
}}}
r := &stream.Reader{
Parent: test.Logger(func(logger.Level, string, ...any) {
t.Error("should not happen")
}),
}
m := &gohlslib.Muxer{}
err := FromStream(desc, r, m)
require.Equal(t, ErrNoSupportedCodecs, err)
}
func TestFromStreamSkipUnsupportedTracks(t *testing.T) {
desc := &description.Session{Medias: []*description.Media{
{
Type: description.MediaTypeVideo,
Formats: []format.Format{&format.VP9{}},
},
{
Type: description.MediaTypeVideo,
Formats: []format.Format{&format.VP8{}},
},
{
Type: description.MediaTypeAudio,
Formats: []format.Format{&format.MPEG1Audio{}},
},
}}
m := &gohlslib.Muxer{}
n := 0
r := &stream.Reader{
Parent: test.Logger(func(l logger.Level, format string, args ...any) {
require.Equal(t, logger.Warn, l)
switch n {
case 0:
require.Equal(t, "skipping track 2 (VP8)", fmt.Sprintf(format, args...))
case 1:
require.Equal(t, "skipping track 3 (MPEG-1/2 Audio)", fmt.Sprintf(format, args...))
}
n++
}),
}
err := FromStream(desc, r, m)
require.NoError(t, err)
require.Equal(t, 2, n)
}
================================================
FILE: internal/protocols/hls/to_stream.go
================================================
package hls
import (
"sync"
"time"
"github.com/bluenviron/gohlslib/v2"
"github.com/bluenviron/gohlslib/v2/pkg/codecs"
"github.com/bluenviron/gortsplib/v5/pkg/description"
"github.com/bluenviron/gortsplib/v5/pkg/format"
"github.com/bluenviron/mediamtx/internal/conf"
"github.com/bluenviron/mediamtx/internal/ntpestimator"
"github.com/bluenviron/mediamtx/internal/stream"
"github.com/bluenviron/mediamtx/internal/unit"
)
type ntpState int
const (
ntpStateInitial ntpState = iota
ntpStateUnavailable
ntpStateAvailable
ntpStateReplace
)
func multiplyAndDivide(v, m, d int64) int64 {
secs := v / d
dec := v % d
return (secs*m + dec*m/d)
}
// ToStream maps a HLS stream to a MediaMTX stream.
func ToStream(
c *gohlslib.Client,
tracks []*gohlslib.Track,
pathConf *conf.Path,
subStream **stream.SubStream,
) ([]*description.Media, error) {
var ntpStat ntpState
var ntpStatMutex sync.Mutex
if !pathConf.UseAbsoluteTimestamp {
ntpStat = ntpStateReplace
}
var medias []*description.Media //nolint:prealloc
for _, track := range tracks {
ctrack := track
ntpEstimator := &ntpestimator.Estimator{ClockRate: track.ClockRate}
handleNTP := func(pts int64) time.Time {
ntpStatMutex.Lock()
defer ntpStatMutex.Unlock()
switch ntpStat {
case ntpStateInitial:
ntp, avail := c.AbsoluteTime(ctrack)
if !avail {
ntpStat = ntpStateUnavailable
return ntpEstimator.Estimate(pts)
}
ntpStat = ntpStateAvailable
return ntp
case ntpStateAvailable:
ntp, avail := c.AbsoluteTime(ctrack)
if !avail {
panic("should not happen")
}
return ntp
case ntpStateUnavailable:
_, avail := c.AbsoluteTime(ctrack)
if avail {
// absolute timestamp appeared after stream started, we are not using it
ntpStat = ntpStateReplace
}
return ntpEstimator.Estimate(pts)
default: // ntpStateReplace
return ntpEstimator.Estimate(pts)
}
}
var medi *description.Media
switch tcodec := ctrack.Codec.(type) {
case *codecs.AV1:
medi = &description.Media{
Type: description.MediaTypeVideo,
Formats: []format.Format{&format.AV1{
PayloadTyp: 96,
}},
}
newClockRate := medi.Formats[0].ClockRate()
c.OnDataAV1(ctrack, func(pts int64, tu [][]byte) {
(*subStream).WriteUnit(medi, medi.Formats[0], &unit.Unit{
NTP: handleNTP(pts),
PTS: multiplyAndDivide(pts, int64(newClockRate), int64(ctrack.ClockRate)),
Payload: unit.PayloadAV1(tu),
})
})
case *codecs.VP9:
medi = &description.Media{
Type: description.MediaTypeVideo,
Formats: []format.Format{&format.VP9{
PayloadTyp: 96,
}},
}
newClockRate := medi.Formats[0].ClockRate()
c.OnDataVP9(ctrack, func(pts int64, frame []byte) {
(*subStream).WriteUnit(medi, medi.Formats[0], &unit.Unit{
NTP: handleNTP(pts),
PTS: multiplyAndDivide(pts, int64(newClockRate), int64(ctrack.ClockRate)),
Payload: unit.PayloadVP9(frame),
})
})
case *codecs.H265:
medi = &description.Media{
Type: description.MediaTypeVideo,
Formats: []format.Format{&format.H265{
PayloadTyp: 96,
VPS: tcodec.VPS,
SPS: tcodec.SPS,
PPS: tcodec.PPS,
}},
}
newClockRate := medi.Formats[0].ClockRate()
c.OnDataH26x(ctrack, func(pts int64, _ int64, au [][]byte) {
(*subStream).WriteUnit(medi, medi.Formats[0], &unit.Unit{
NTP: handleNTP(pts),
PTS: multiplyAndDivide(pts, int64(newClockRate), int64(ctrack.ClockRate)),
Payload: unit.PayloadH265(au),
})
})
case *codecs.H264:
medi = &description.Media{
Type: description.MediaTypeVideo,
Formats: []format.Format{&format.H264{
PayloadTyp: 96,
PacketizationMode: 1,
SPS: tcodec.SPS,
PPS: tcodec.PPS,
}},
}
newClockRate := medi.Formats[0].ClockRate()
c.OnDataH26x(ctrack, func(pts int64, _ int64, au [][]byte) {
(*subStream).WriteUnit(medi, medi.Formats[0], &unit.Unit{
NTP: handleNTP(pts),
PTS: multiplyAndDivide(pts, int64(newClockRate), int64(ctrack.ClockRate)),
Payload: unit.PayloadH264(au),
})
})
case *codecs.Opus:
medi = &description.Media{
Type: description.MediaTypeAudio,
Formats: []format.Format{&format.Opus{
PayloadTyp: 96,
ChannelCount: tcodec.ChannelCount,
}},
}
newClockRate := medi.Formats[0].ClockRate()
c.OnDataOpus(ctrack, func(pts int64, packets [][]byte) {
(*subStream).WriteUnit(medi, medi.Formats[0], &unit.Unit{
NTP: handleNTP(pts),
PTS: multiplyAndDivide(pts, int64(newClockRate), int64(ctrack.ClockRate)),
Payload: unit.PayloadOpus(packets),
})
})
case *codecs.MPEG4Audio:
medi = &description.Media{
Type: description.MediaTypeAudio,
Formats: []format.Format{&format.MPEG4Audio{
PayloadTyp: 96,
SizeLength: 13,
IndexLength: 3,
IndexDeltaLength: 3,
Config: &tcodec.Config,
}},
}
newClockRate := medi.Formats[0].ClockRate()
c.OnDataMPEG4Audio(ctrack, func(pts int64, aus [][]byte) {
(*subStream).WriteUnit(medi, medi.Formats[0], &unit.Unit{
NTP: handleNTP(pts),
PTS: multiplyAndDivide(pts, int64(newClockRate), int64(ctrack.ClockRate)),
Payload: unit.PayloadMPEG4Audio(aus),
})
})
default:
panic("should not happen")
}
medias = append(medias, medi)
}
if len(medias) == 0 {
return nil, ErrNoSupportedCodecs
}
return medias, nil
}
================================================
FILE: internal/protocols/hls/to_stream_test.go
================================================
package hls
import (
"context"
"net"
"net/http"
"testing"
"time"
"github.com/bluenviron/gohlslib/v2"
"github.com/bluenviron/gortsplib/v5/pkg/description"
"github.com/bluenviron/gortsplib/v5/pkg/format"
"github.com/bluenviron/mediacommon/v2/pkg/formats/mpegts"
tscodecs "github.com/bluenviron/mediacommon/v2/pkg/formats/mpegts/codecs"
"github.com/bluenviron/mediamtx/internal/conf"
"github.com/bluenviron/mediamtx/internal/stream"
"github.com/bluenviron/mediamtx/internal/test"
"github.com/bluenviron/mediamtx/internal/unit"
"github.com/stretchr/testify/require"
)
func TestToStreamNoSupportedCodecs(t *testing.T) {
_, err := ToStream(nil, []*gohlslib.Track{}, &conf.Path{}, nil)
require.Equal(t, ErrNoSupportedCodecs, err)
}
// this is impossible to test since currently we support all gohlslib.Tracks.
// func TestToStreamSkipUnsupportedTracks(t *testing.T)
func TestToStream(t *testing.T) {
track1 := &mpegts.Track{
Codec: &tscodecs.H264{},
}
s := &http.Server{
Handler: http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
switch {
case r.Method == http.MethodGet && r.URL.Path == "/stream.m3u8":
w.Header().Set("Content-Type", `application/vnd.apple.mpegurl`)
w.Write([]byte("#EXTM3U\n" +
"#EXT-X-VERSION:3\n" +
"#EXT-X-ALLOW-CACHE:NO\n" +
"#EXT-X-TARGETDURATION:2\n" +
"#EXT-X-MEDIA-SEQUENCE:0\n" +
"#EXT-X-PROGRAM-DATE-TIME:2018-05-20T08:17:15Z\n" +
"#EXTINF:2,\n" +
"segment1.ts\n" +
"#EXTINF:2,\n" +
"segment2.ts\n" +
"#EXTINF:2,\n" +
"segment3.ts\n" +
"#EXT-X-ENDLIST\n"))
case r.Method == http.MethodGet && r.URL.Path == "/segment1.ts":
w.Header().Set("Content-Type", `video/MP2T`)
w := &mpegts.Writer{W: w, Tracks: []*mpegts.Track{track1}}
err := w.Initialize()
require.NoError(t, err)
err = w.WriteH264(track1, 2*90000, 2*90000, [][]byte{
{7, 1, 2, 3}, // SPS
{8}, // PPS
{5, 1},
})
require.NoError(t, err)
case r.Method == http.MethodGet && r.URL.Path == "/segment2.ts":
w.Header().Set("Content-Type", `video/MP2T`)
w := &mpegts.Writer{W: w, Tracks: []*mpegts.Track{track1}}
err := w.Initialize()
require.NoError(t, err)
err = w.WriteH264(track1, 2*90000, 2*90000, [][]byte{
{5, 2},
})
require.NoError(t, err)
}
}),
}
ln, err := net.Listen("tcp", "localhost:5781")
require.NoError(t, err)
go s.Serve(ln)
defer s.Shutdown(context.Background())
var strm *stream.Stream
var subStream *stream.SubStream
done := make(chan struct{})
r := &stream.Reader{Parent: test.NilLogger}
var c *gohlslib.Client
c = &gohlslib.Client{
URI: "http://localhost:5781/stream.m3u8",
OnTracks: func(tracks []*gohlslib.Track) error {
medias, err2 := ToStream(c, tracks, &conf.Path{
UseAbsoluteTimestamp: true,
}, &subStream)
require.NoError(t, err2)
require.Equal(t, []*description.Media{{
Type: description.MediaTypeVideo,
Formats: []format.Format{&format.H264{
PayloadTyp: 96,
PacketizationMode: 1,
}},
}}, medias)
strm = &stream.Stream{
Desc: &description.Session{Medias: medias},
WriteQueueSize: 512,
RTPMaxPayloadSize: 1450,
Parent: test.NilLogger,
}
err2 = strm.Initialize()
require.NoError(t, err2)
subStream = &stream.SubStream{
Stream: strm,
UseRTPPackets: false,
}
err2 = subStream.Initialize()
require.NoError(t, err2)
n := 0
r.OnData(
medias[0],
medias[0].Formats[0],
func(u *unit.Unit) error {
switch n {
case 0:
require.Equal(t, unit.PayloadH264{
{7, 1, 2, 3},
{8},
{5, 1},
}, u.Payload)
require.Equal(t, time.Date(2018, 0o5, 20, 8, 17, 15, 0, time.UTC), u.NTP)
case 1:
require.Equal(t, unit.PayloadH264{
{7, 1, 2, 3},
{8},
{5, 2},
}, u.Payload)
require.Equal(t, time.Date(2018, 0o5, 20, 8, 17, 15, 0, time.UTC), u.NTP)
close(done)
default:
t.Error("should not happen")
}
n++
return nil
})
strm.AddReader(r)
return nil
},
}
err = c.Start()
require.NoError(t, err)
defer c.Close()
<-done
strm.RemoveReader(r)
strm.Close()
}
================================================
FILE: internal/protocols/httpp/content_type.go
================================================
package httpp
import "strings"
// ParseContentType parses a Content-Type header and returns the content type.
func ParseContentType(v string) string {
return strings.TrimSpace(strings.Split(v, ";")[0])
}
================================================
FILE: internal/protocols/httpp/credentials.go
================================================
package httpp
import (
"net/http"
"strings"
"github.com/bluenviron/mediamtx/internal/auth"
)
// Credentials extracts credentials from a HTTP request.
func Credentials(h *http.Request) *auth.Credentials {
c := &auth.Credentials{}
for _, auth := range h.Header["Authorization"] {
if strings.HasPrefix(auth, "Bearer ") {
// user:pass in Authorization Bearer
if parts := strings.Split(auth[len("Bearer "):], ":"); len(parts) == 2 {
c.User = parts[0]
c.Pass = parts[1]
return c
}
// JWT in Authorization Bearer
c.Token = auth[len("Bearer "):]
return c
}
}
// user:pass in Authorization Basic
c.User, c.Pass, _ = h.BasicAuth()
return c
}
================================================
FILE: internal/protocols/httpp/credentials_test.go
================================================
package httpp
import (
"net/http"
"net/url"
"testing"
"github.com/bluenviron/mediamtx/internal/auth"
"github.com/stretchr/testify/require"
)
func TestCredentials(t *testing.T) {
t.Run("user and pass in basic", func(t *testing.T) {
h := &http.Request{
URL: &url.URL{},
Header: http.Header{
"Authorization": []string{
"Basic bXl1c2VyOm15cGFzcw==",
},
},
}
c := Credentials(h)
require.Equal(t, &auth.Credentials{
User: "myuser",
Pass: "mypass",
}, c)
})
t.Run("user and pass in bearer", func(t *testing.T) {
h := &http.Request{
URL: &url.URL{},
Header: http.Header{
"Authorization": []string{
"Bearer myuser:mypass",
},
},
}
c := Credentials(h)
require.Equal(t, &auth.Credentials{
User: "myuser",
Pass: "mypass",
}, c)
})
t.Run("token in bearer", func(t *testing.T) {
h := &http.Request{
URL: &url.URL{},
Header: http.Header{
"Authorization": []string{
"Bearer testing123",
},
},
}
c := Credentials(h)
require.Equal(t, &auth.Credentials{
Token: "testing123",
}, c)
})
t.Run("user and pass and token", func(t *testing.T) {
h := &http.Request{
URL: &url.URL{},
Header: http.Header{
"Authorization": []string{
"Basic bXl1c2VyOm15cGFzcw==",
"Bearer testing123",
},
},
}
c := Credentials(h)
require.Equal(t, &auth.Credentials{
Token: "testing123",
}, c)
})
}
================================================
FILE: internal/protocols/httpp/handler_exit_on_panic.go
================================================
package httpp
import (
"fmt"
"net/http"
"os"
"runtime"
)
// exit when there's a panic inside the HTTP handler.
// https://github.com/golang/go/issues/16542
type handlerExitOnPanic struct {
h http.Handler
}
func (h *handlerExitOnPanic) ServeHTTP(w http.ResponseWriter, r *http.Request) {
defer func() {
err := recover()
if err != nil {
buf := make([]byte, 1<<20)
n := runtime.Stack(buf, true)
fmt.Fprintf(os.Stderr, "panic: %v\n\n%s", err, buf[:n])
os.Exit(1)
}
}()
h.h.ServeHTTP(w, r)
}
================================================
FILE: internal/protocols/httpp/handler_filter_requests.go
================================================
package httpp
import (
"net/http"
)
// reject requests with empty paths.
type handlerFilterRequests struct {
h http.Handler
}
func (h *handlerFilterRequests) ServeHTTP(w http.ResponseWriter, r *http.Request) {
if r.URL.Path == "" || r.URL.Path[0] != '/' {
w.WriteHeader(http.StatusBadRequest)
return
}
h.h.ServeHTTP(w, r)
}
================================================
FILE: internal/protocols/httpp/handler_filter_requests_test.go
================================================
package httpp
import (
"net"
"net/http"
"strings"
"testing"
"time"
"github.com/bluenviron/mediamtx/internal/test"
"github.com/stretchr/testify/require"
)
func TestHandlerFilterRequests(t *testing.T) {
s := &Server{
Address: "localhost:4555",
ReadTimeout: 10 * time.Second,
WriteTimeout: 10 * time.Second,
Parent: test.NilLogger,
Handler: http.HandlerFunc(func(w http.ResponseWriter, _ *http.Request) {
w.WriteHeader(http.StatusOK)
}),
}
err := s.Initialize()
require.NoError(t, err)
defer s.Close()
conn, err := net.Dial("tcp", "localhost:4555")
require.NoError(t, err)
defer conn.Close()
_, err = conn.Write([]byte("OPTIONS / HTTP/1.1\n" +
"Host: localhost:8889\n\n"))
require.NoError(t, err)
buf := make([]byte, 200)
n, err := conn.Read(buf)
require.NoError(t, err)
res := strings.Split(string(buf[:n]), "\r\n")
require.Equal(t, "HTTP/1.1 200 OK", res[0])
}
================================================
FILE: internal/protocols/httpp/handler_logger.go
================================================
package httpp
import (
"bytes"
"fmt"
"net/http"
"net/http/httputil"
"github.com/bluenviron/mediamtx/internal/logger"
)
type loggerWriter struct {
w http.ResponseWriter
status int
size int
}
func (w *loggerWriter) Header() http.Header {
return w.w.Header()
}
func (w *loggerWriter) Write(b []byte) (int, error) {
if w.status == 0 {
w.status = http.StatusOK
}
w.size += len(b)
return w.w.Write(b)
}
func (w *loggerWriter) WriteHeader(statusCode int) {
w.status = statusCode
w.w.WriteHeader(statusCode)
}
func (w *loggerWriter) dump() string {
var buf bytes.Buffer
fmt.Fprintf(&buf, "%s %d %s\n", "HTTP/1.1", w.status, http.StatusText(w.status))
w.w.Header().Write(&buf) //nolint:errcheck
buf.Write([]byte("\n"))
if w.size > 0 {
fmt.Fprintf(&buf, "(body of %d bytes)", w.size)
}
return buf.String()
}
// log requests and responses.
type handlerLogger struct {
h http.Handler
log logger.Writer
}
func (h *handlerLogger) ServeHTTP(w http.ResponseWriter, r *http.Request) {
byts, _ := httputil.DumpRequest(r, true)
h.log.Log(logger.Debug, "[conn %v] [c->s] %s", r.RemoteAddr, string(byts))
logw := &loggerWriter{w: w}
h.h.ServeHTTP(logw, r)
h.log.Log(logger.Debug, "[conn %v] [s->c] %s", r.RemoteAddr, logw.dump())
}
================================================
FILE: internal/protocols/httpp/handler_origin.go
================================================
package httpp
import (
"net"
"net/http"
"net/url"
"regexp"
"strings"
)
func isOriginAllowed(origin string, allowOrigins []string) (string, bool) {
if len(allowOrigins) == 0 {
return "", false
}
for _, o := range allowOrigins {
if o == "*" {
return o, true
}
}
if origin == "" {
return "", false
}
originURL, err := url.Parse(origin)
if err != nil || originURL.Scheme == "" {
return "", false
}
if originURL.Port() == "" && originURL.Scheme != "" {
switch originURL.Scheme {
case "http":
originURL.Host = net.JoinHostPort(originURL.Host, "80")
case "https":
originURL.Host = net.JoinHostPort(originURL.Host, "443")
}
}
for _, o := range allowOrigins {
allowedURL, errAllowed := url.Parse(o)
if errAllowed != nil {
continue
}
if allowedURL.Port() == "" {
switch allowedURL.Scheme {
case "http":
allowedURL.Host = net.JoinHostPort(allowedURL.Host, "80")
case "https":
allowedURL.Host = net.JoinHostPort(allowedURL.Host, "443")
}
}
if allowedURL.Scheme == originURL.Scheme &&
allowedURL.Host == originURL.Host &&
allowedURL.Port() == originURL.Port() {
return origin, true
}
if strings.Contains(allowedURL.Host, "*") {
pattern := strings.ReplaceAll(allowedURL.Host, "*.", "(.*\\.)?")
pattern = strings.ReplaceAll(pattern, "*", ".*")
matched, errMatched := regexp.MatchString("^"+pattern+"$", originURL.Host)
if errMatched == nil && matched {
return origin, true
}
}
}
return "", false
}
// add Access-Control-Allow-Origin and Access-Control-Allow-Credentials headers.
type handlerOrigin struct {
h http.Handler
allowOrigins []string
}
func (h *handlerOrigin) ServeHTTP(w http.ResponseWriter, r *http.Request) {
origin, ok := isOriginAllowed(r.Header.Get("Origin"), h.allowOrigins)
if ok {
w.Header().Set("Access-Control-Allow-Origin", origin)
w.Header().Set("Access-Control-Allow-Credentials", "true")
}
h.h.ServeHTTP(w, r)
}
================================================
FILE: internal/protocols/httpp/handler_origin_test.go
================================================
package httpp
import (
"net/http"
"testing"
"time"
"github.com/bluenviron/mediamtx/internal/test"
"github.com/stretchr/testify/require"
)
func TestHandlerOrigin(t *testing.T) {
for _, ca := range []struct {
name string
origin string
allowedOrigins []string
expected string
}{
{
"empty",
"",
[]string{},
"",
},
{
"not allowed",
"http://another.com",
[]string{"http://example.com"},
"",
},
{
"everything allowed, no origin",
"",
[]string{"*"},
"*",
},
{
"everything allowed, with origin",
"https://example.com",
[]string{"*"},
"*",
},
{
"allowed",
"https://example.org",
[]string{"http://example.com", "https://example.org"},
"https://example.org",
},
{
"wildcard",
"https://test.example.org",
[]string{"https://*.example.org"},
"https://test.example.org",
},
} {
t.Run(ca.name, func(t *testing.T) {
s := &Server{
Address: "localhost:4555",
AllowOrigins: ca.allowedOrigins,
ReadTimeout: 10 * time.Second,
WriteTimeout: 10 * time.Second,
Parent: test.NilLogger,
Handler: http.HandlerFunc(func(w http.ResponseWriter, _ *http.Request) {
w.WriteHeader(http.StatusOK)
}),
}
err := s.Initialize()
require.NoError(t, err)
defer s.Close()
tr := &http.Transport{}
defer tr.CloseIdleConnections()
hc := &http.Client{Transport: tr}
req, err := http.NewRequest(http.MethodGet, "http://localhost:4555", nil)
require.NoError(t, err)
req.Header.Set("Origin", ca.origin)
res, err := hc.Do(req)
require.NoError(t, err)
defer res.Body.Close()
require.Equal(t, ca.expected, res.Header.Get("Access-Control-Allow-Origin"))
})
}
}
================================================
FILE: internal/protocols/httpp/handler_server_header.go
================================================
package httpp
import (
"net/http"
)
// set the Server header.
type handlerServerHeader struct {
h http.Handler
}
func (h *handlerServerHeader) ServeHTTP(w http.ResponseWriter, r *http.Request) {
w.Header().Set("Server", "mediamtx")
h.h.ServeHTTP(w, r)
}
================================================
FILE: internal/protocols/httpp/handler_tracker.go
================================================
package httpp
import (
"net/http"
"sync"
)
type handlerTracker struct {
h http.Handler
mutex sync.Mutex
wg sync.WaitGroup
closed bool
}
func (h *handlerTracker) close() {
h.mutex.Lock()
h.closed = true
h.mutex.Unlock()
h.wg.Wait()
}
func (h *handlerTracker) ServeHTTP(w http.ResponseWriter, r *http.Request) {
h.mutex.Lock()
if h.closed {
h.mutex.Unlock()
return
}
h.wg.Add(1)
h.mutex.Unlock()
defer h.wg.Done()
h.h.ServeHTTP(w, r)
}
================================================
FILE: internal/protocols/httpp/handler_tracker_test.go
================================================
package httpp
import (
"net/http"
"testing"
"time"
"github.com/bluenviron/mediamtx/internal/test"
"github.com/stretchr/testify/require"
)
func TestHandlerTracker(t *testing.T) {
requestReceived := make(chan struct{})
s := &Server{
Address: "localhost:4667",
ReadTimeout: 10 * time.Second,
WriteTimeout: 10 * time.Second,
Parent: test.NilLogger,
Handler: http.HandlerFunc(func(_ http.ResponseWriter, _ *http.Request) {
close(requestReceived)
time.Sleep(1 * time.Second)
}),
}
err := s.Initialize()
require.NoError(t, err)
go func() {
tr := &http.Transport{}
defer tr.CloseIdleConnections()
hc := &http.Client{Transport: tr}
_, err2 := hc.Get("http://localhost:4667/test") //nolint:bodyclose
require.Error(t, err2)
}()
<-requestReceived
beforeClose := time.Now()
s.Close()
require.Greater(t, time.Since(beforeClose), 1*time.Second)
}
================================================
FILE: internal/protocols/httpp/handler_write_timeout.go
================================================
package httpp
import (
"net/http"
"time"
)
type writeTimeoutWriter struct {
w http.ResponseWriter
rc *http.ResponseController
timeout time.Duration
}
func (w *writeTimeoutWriter) Header() http.Header {
return w.w.Header()
}
func (w *writeTimeoutWriter) Write(p []byte) (int, error) {
w.rc.SetWriteDeadline(time.Now().Add(w.timeout)) //nolint:errcheck
return w.w.Write(p)
}
func (w *writeTimeoutWriter) WriteHeader(statusCode int) {
w.rc.SetWriteDeadline(time.Now().Add(w.timeout)) //nolint:errcheck
w.w.WriteHeader(statusCode)
}
// apply write deadline before every Write() call.
// this allows to write long responses, splitted in chunks,
// without causing timeouts.
type handlerWriteTimeout struct {
h http.Handler
timeout time.Duration
}
func (h *handlerWriteTimeout) ServeHTTP(w http.ResponseWriter, r *http.Request) {
ww := &writeTimeoutWriter{
w: w,
rc: http.NewResponseController(w),
timeout: h.timeout,
}
h.h.ServeHTTP(ww, r)
}
================================================
FILE: internal/protocols/httpp/remote_addr.go
================================================
package httpp
import (
"net"
"github.com/gin-gonic/gin"
)
// RemoteAddr returns the remote address of an HTTP client,
// with the IP replaced by the real IP passed by any proxy in between.
func RemoteAddr(ctx *gin.Context) string {
ip := ctx.ClientIP()
_, port, _ := net.SplitHostPort(ctx.Request.RemoteAddr)
return net.JoinHostPort(ip, port)
}
================================================
FILE: internal/protocols/httpp/server.go
================================================
// Package httpp contains HTTP utilities.
package httpp
import (
"crypto/tls"
"fmt"
"log"
"net"
"net/http"
"os"
"strings"
"time"
"github.com/bluenviron/mediamtx/internal/certloader"
"github.com/bluenviron/mediamtx/internal/logger"
"github.com/bluenviron/mediamtx/internal/packetdumper"
"github.com/bluenviron/mediamtx/internal/restrictnetwork"
)
type nilWriter struct{}
func (nilWriter) Write(p []byte) (int, error) {
return len(p), nil
}
// Server is a wrapper around http.Server that provides:
// - net.Listener allocation and closure
// - TLS allocation
// - exit on panic
// - logging
// - server header
// - filtering of invalid requests
type Server struct {
Address string
AllowOrigins []string
DumpPackets bool
DumpPacketsPrefix string
ReadTimeout time.Duration
WriteTimeout time.Duration
Encryption bool
ServerCert string
ServerKey string
Handler http.Handler
Parent logger.Writer
ln net.Listener
inner *http.Server
loader *certloader.CertLoader
tracker *handlerTracker
}
// Initialize initializes a Server.
func (s *Server) Initialize() error {
if s.ReadTimeout == 0 {
return fmt.Errorf("invalid ReadTimeout")
}
if s.WriteTimeout == 0 {
return fmt.Errorf("invalid WriteTimeout")
}
var tlsConfig *tls.Config
if s.Encryption {
if s.ServerCert == "" {
return fmt.Errorf("server cert is missing")
}
s.loader = &certloader.CertLoader{
CertPath: s.ServerCert,
KeyPath: s.ServerKey,
Parent: s.Parent,
}
err := s.loader.Initialize()
if err != nil {
return err
}
tlsConfig = &tls.Config{
GetCertificate: s.loader.GetCertificate(),
}
}
var network string
var address string
if strings.HasPrefix(s.Address, "unix://") {
network = "unix"
address = s.Address[len("unix://"):]
} else {
network, address = restrictnetwork.Restrict("tcp", s.Address)
}
if network == "unix" {
os.Remove(address)
}
var err error
s.ln, err = net.Listen(network, address)
if err != nil {
return err
}
if s.DumpPackets {
s.ln = &packetdumper.Listener{
Prefix: s.DumpPacketsPrefix,
Listener: s.ln,
}
}
if network == "unix" {
os.Chmod(address, 0o755) //nolint:errcheck
}
h := s.Handler
h = &handlerOrigin{h, s.AllowOrigins}
h = &handlerServerHeader{h}
h = &handlerFilterRequests{h}
h = &handlerLogger{h, s.Parent}
h = &handlerExitOnPanic{h}
h = &handlerWriteTimeout{h, s.WriteTimeout}
s.tracker = &handlerTracker{h: h}
h = s.tracker
s.inner = &http.Server{
Handler: h,
TLSConfig: tlsConfig,
// applied before reading any request
ReadTimeout: s.ReadTimeout,
// applied after HTTP handler has returned
IdleTimeout: 30 * time.Second,
ErrorLog: log.New(&nilWriter{}, "", 0),
}
if tlsConfig != nil {
go s.inner.ServeTLS(s.ln, "", "")
} else {
go s.inner.Serve(s.ln)
}
return nil
}
// Close closes all resources and waits for all routines to return.
func (s *Server) Close() {
s.ln.Close()
s.inner.Close() //nolint:errcheck
s.tracker.close()
if s.loader != nil {
s.loader.Close()
}
}
================================================
FILE: internal/protocols/httpp/server_test.go
================================================
package httpp
import (
"net"
"net/http"
"os"
"strings"
"testing"
"time"
"github.com/stretchr/testify/require"
"github.com/bluenviron/mediamtx/internal/test"
)
func TestUnixSocket(t *testing.T) {
s := &Server{
Address: "unix://http.sock",
ReadTimeout: 10 * time.Second,
WriteTimeout: 10 * time.Second,
Parent: test.NilLogger,
Handler: http.HandlerFunc(func(w http.ResponseWriter, _ *http.Request) {
w.WriteHeader(http.StatusOK)
}),
}
err := s.Initialize()
require.NoError(t, err)
_, err = os.Stat("http.sock")
require.NoError(t, err)
conn, err := net.Dial("unix", "http.sock")
require.NoError(t, err)
_, err = conn.Write([]byte("OPTIONS / HTTP/1.1\n" +
"Host: localhost:8889\n\n"))
require.NoError(t, err)
buf := make([]byte, 200)
n, err := conn.Read(buf)
require.NoError(t, err)
res := strings.Split(string(buf[:n]), "\r\n")
require.Equal(t, "HTTP/1.1 200 OK", res[0])
conn.Close()
s.Close()
_, err = os.Stat("http.sock")
require.EqualError(t, err, "stat http.sock: no such file or directory")
}
================================================
FILE: internal/protocols/mpegts/enhanced_reader.go
================================================
package mpegts
import (
"io"
"github.com/bluenviron/mediacommon/v2/pkg/codecs/mpeg4audio"
mcmpegts "github.com/bluenviron/mediacommon/v2/pkg/formats/mpegts"
tscodecs "github.com/bluenviron/mediacommon/v2/pkg/formats/mpegts/codecs"
"github.com/bluenviron/mediacommon/v2/pkg/rewindablereader"
)
// EnhancedReader is a mpegts.Reader wrapper
// That provides additional informations that are needed in order
// to perform conversion to RTSP.
type EnhancedReader struct {
R io.Reader
*mcmpegts.Reader
latmConfigs map[uint16]*mpeg4audio.StreamMuxConfig
}
// Initialize initializes EnhancedReader.
func (r *EnhancedReader) Initialize() error {
rr := &rewindablereader.Reader{R: r.R}
mr := &mcmpegts.Reader{R: rr}
err := mr.Initialize()
if err != nil {
return err
}
r.latmConfigs = make(map[uint16]*mpeg4audio.StreamMuxConfig)
tracksToParse := 0
for _, track := range mr.Tracks() {
if _, ok := track.Codec.(*tscodecs.MPEG4AudioLATM); ok {
cpid := track.PID
done := false
tracksToParse++
mr.OnDataMPEG4AudioLATM(track, func(_ int64, els [][]byte) error {
if done {
return nil
}
var ame mpeg4audio.AudioMuxElement
ame.MuxConfigPresent = true
err2 := ame.Unmarshal(els[0])
if err2 != nil {
return nil //nolint:nilerr
}
if ame.MuxConfigPresent {
r.latmConfigs[cpid] = ame.StreamMuxConfig
tracksToParse--
done = true
}
return nil
})
}
}
for tracksToParse > 0 {
err = mr.Read()
if err != nil {
return err
}
}
rr.Rewind()
r.Reader = &mcmpegts.Reader{R: rr}
err = r.Reader.Initialize()
if err != nil {
return err
}
return err
}
================================================
FILE: internal/protocols/mpegts/from_stream.go
================================================
package mpegts
import (
"bufio"
"fmt"
"slices"
"time"
"github.com/bluenviron/gortsplib/v5/pkg/description"
"github.com/bluenviron/gortsplib/v5/pkg/format"
"github.com/bluenviron/mediacommon/v2/pkg/codecs/ac3"
"github.com/bluenviron/mediacommon/v2/pkg/codecs/h264"
"github.com/bluenviron/mediacommon/v2/pkg/codecs/h265"
"github.com/bluenviron/mediacommon/v2/pkg/codecs/mpeg4audio"
mcmpegts "github.com/bluenviron/mediacommon/v2/pkg/formats/mpegts"
tscodecs "github.com/bluenviron/mediacommon/v2/pkg/formats/mpegts/codecs"
"github.com/bluenviron/mediacommon/v2/pkg/formats/mpegts/substructs"
srt "github.com/datarhei/gosrt"
"github.com/bluenviron/mediamtx/internal/logger"
"github.com/bluenviron/mediamtx/internal/stream"
"github.com/bluenviron/mediamtx/internal/unit"
)
func multiplyAndDivide(v, m, d int64) int64 {
secs := v / d
dec := v % d
return (secs*m + dec*m/d)
}
// FromStream maps a MediaMTX stream to a MPEG-TS writer.
func FromStream(
desc *description.Session,
r *stream.Reader,
bw *bufio.Writer,
sconn srt.Conn,
writeTimeout time.Duration,
) error {
var w *mcmpegts.Writer
var tracks []*mcmpegts.Track
addTrack := func(
media *description.Media,
forma format.Format,
track *mcmpegts.Track,
onData stream.OnDataFunc,
) {
tracks = append(tracks, track)
r.OnData(media, forma, onData)
}
for _, media := range desc.Medias {
for _, forma := range media.Formats {
clockRate := forma.ClockRate()
switch forma := forma.(type) {
case *format.H265: //nolint:dupl
track := &mcmpegts.Track{Codec: &tscodecs.H265{}}
var dtsExtractor *h265.DTSExtractor
addTrack(
media,
forma,
track,
func(u *unit.Unit) error {
if u.NilPayload() {
return nil
}
if dtsExtractor == nil {
if !h265.IsRandomAccess(u.Payload.(unit.PayloadH265)) {
return nil
}
dtsExtractor = &h265.DTSExtractor{}
dtsExtractor.Initialize()
}
dts, err := dtsExtractor.Extract(u.Payload.(unit.PayloadH265), u.PTS)
if err != nil {
return err
}
sconn.SetWriteDeadline(time.Now().Add(writeTimeout))
err = (*w).WriteH265(
track,
u.PTS, // no conversion is needed since clock rate is 90khz in both MPEG-TS and RTSP
dts,
u.Payload.(unit.PayloadH265))
if err != nil {
return err
}
return bw.Flush()
})
case *format.H264: //nolint:dupl
track := &mcmpegts.Track{Codec: &tscodecs.H264{}}
var dtsExtractor *h264.DTSExtractor
addTrack(
media,
forma,
track,
func(u *unit.Unit) error {
if u.NilPayload() {
return nil
}
idrPresent := h264.IsRandomAccess(u.Payload.(unit.PayloadH264))
if dtsExtractor == nil {
if !idrPresent {
return nil
}
dtsExtractor = &h264.DTSExtractor{}
dtsExtractor.Initialize()
}
dts, err := dtsExtractor.Extract(u.Payload.(unit.PayloadH264), u.PTS)
if err != nil {
return err
}
sconn.SetWriteDeadline(time.Now().Add(writeTimeout))
err = (*w).WriteH264(
track,
u.PTS, // no conversion is needed since clock rate is 90khz in both MPEG-TS and RTSP
dts,
u.Payload.(unit.PayloadH264))
if err != nil {
return err
}
return bw.Flush()
})
case *format.MPEG4Video:
track := &mcmpegts.Track{Codec: &tscodecs.MPEG4Video{}}
firstReceived := false
var lastPTS int64
addTrack(
media,
forma,
track,
func(u *unit.Unit) error {
if u.NilPayload() {
return nil
}
if !firstReceived {
firstReceived = true
} else if u.PTS < lastPTS {
return fmt.Errorf("MPEG-4 Video streams with B-frames are not supported (yet)")
}
lastPTS = u.PTS
sconn.SetWriteDeadline(time.Now().Add(writeTimeout))
err := (*w).WriteMPEG4Video(
track,
u.PTS, // no conversion is needed since clock rate is 90khz in both MPEG-TS and RTSP
u.Payload.(unit.PayloadMPEG4Video))
if err != nil {
return err
}
return bw.Flush()
})
case *format.MPEG1Video:
track := &mcmpegts.Track{Codec: &tscodecs.MPEG1Video{}}
firstReceived := false
var lastPTS int64
addTrack(
media,
forma,
track,
func(u *unit.Unit) error {
if u.NilPayload() {
return nil
}
if !firstReceived {
firstReceived = true
} else if u.PTS < lastPTS {
return fmt.Errorf("MPEG-1 Video streams with B-frames are not supported (yet)")
}
lastPTS = u.PTS
sconn.SetWriteDeadline(time.Now().Add(writeTimeout))
err := (*w).WriteMPEG1Video(
track,
u.PTS, // no conversion is needed since clock rate is 90khz in both MPEG-TS and RTSP
u.Payload.(unit.PayloadMPEG1Video))
if err != nil {
return err
}
return bw.Flush()
})
case *format.Opus:
track := &mcmpegts.Track{Codec: &tscodecs.Opus{
Desc: &substructs.OpusAudioDescriptor{
ChannelConfigCode: uint8(forma.ChannelCount),
},
}}
addTrack(
media,
forma,
track,
func(u *unit.Unit) error {
if u.NilPayload() {
return nil
}
sconn.SetWriteDeadline(time.Now().Add(writeTimeout))
err := (*w).WriteOpus(
track,
multiplyAndDivide(u.PTS, 90000, int64(clockRate)),
u.Payload.(unit.PayloadOpus))
if err != nil {
return err
}
return bw.Flush()
})
case *format.KLV:
track := &mcmpegts.Track{
Codec: &tscodecs.KLV{
Synchronous: true,
},
}
addTrack(
media,
forma,
track,
func(u *unit.Unit) error {
if u.NilPayload() {
return nil
}
sconn.SetWriteDeadline(time.Now().Add(writeTimeout))
err := (*w).WriteKLV(track, multiplyAndDivide(u.PTS, 90000, 90000), u.Payload.(unit.PayloadKLV))
if err != nil {
return err
}
return bw.Flush()
})
case *format.MPEG4Audio:
track := &mcmpegts.Track{Codec: &tscodecs.MPEG4Audio{
Config: *forma.Config,
}}
addTrack(
media,
forma,
track,
func(u *unit.Unit) error {
if u.NilPayload() {
return nil
}
sconn.SetWriteDeadline(time.Now().Add(writeTimeout))
err := (*w).WriteMPEG4Audio(
track,
multiplyAndDivide(u.PTS, 90000, int64(clockRate)),
u.Payload.(unit.PayloadMPEG4Audio))
if err != nil {
return err
}
return bw.Flush()
})
case *format.MPEG4AudioLATM:
track := &mcmpegts.Track{Codec: &tscodecs.MPEG4AudioLATM{}}
if !forma.CPresent {
addTrack(
media,
forma,
track,
func(u *unit.Unit) error {
if u.NilPayload() {
return nil
}
var elIn mpeg4audio.AudioMuxElement
elIn.MuxConfigPresent = false
elIn.StreamMuxConfig = forma.StreamMuxConfig
err := elIn.Unmarshal(u.Payload.(unit.PayloadMPEG4AudioLATM))
if err != nil {
return err
}
var elOut mpeg4audio.AudioMuxElement
elOut.MuxConfigPresent = true
elOut.StreamMuxConfig = forma.StreamMuxConfig
elOut.UseSameStreamMux = false
elOut.Payloads = elIn.Payloads
buf, err := elOut.Marshal()
if err != nil {
return err
}
sconn.SetWriteDeadline(time.Now().Add(writeTimeout))
err = (*w).WriteMPEG4AudioLATM(
track,
multiplyAndDivide(u.PTS, 90000, int64(clockRate)),
[][]byte{buf})
if err != nil {
return err
}
return bw.Flush()
})
} else {
addTrack(
media,
forma,
track,
func(u *unit.Unit) error {
if u.NilPayload() {
return nil
}
sconn.SetWriteDeadline(time.Now().Add(writeTimeout))
err := (*w).WriteMPEG4AudioLATM(
track,
multiplyAndDivide(u.PTS, 90000, int64(clockRate)),
[][]byte{u.Payload.(unit.PayloadMPEG4AudioLATM)})
if err != nil {
return err
}
return bw.Flush()
})
}
case *format.MPEG1Audio:
track := &mcmpegts.Track{Codec: &tscodecs.MPEG1Audio{}}
addTrack(
media,
forma,
track,
func(u *unit.Unit) error {
if u.NilPayload() {
return nil
}
sconn.SetWriteDeadline(time.Now().Add(writeTimeout))
err := (*w).WriteMPEG1Audio(
track,
u.PTS, // no conversion is needed since clock rate is 90khz in both MPEG-TS and RTSP
u.Payload.(unit.PayloadMPEG1Audio))
if err != nil {
return err
}
return bw.Flush()
})
case *format.AC3:
track := &mcmpegts.Track{Codec: &tscodecs.AC3{}}
addTrack(
media,
forma,
track,
func(u *unit.Unit) error {
if u.NilPayload() {
return nil
}
for i, frame := range u.Payload.(unit.PayloadAC3) {
framePTS := u.PTS + int64(i)*ac3.SamplesPerFrame
sconn.SetWriteDeadline(time.Now().Add(writeTimeout))
err := (*w).WriteAC3(
track,
multiplyAndDivide(framePTS, 90000, int64(clockRate)),
frame)
if err != nil {
return err
}
}
return bw.Flush()
})
}
}
}
if len(tracks) == 0 {
return errNoSupportedCodecs
}
setuppedFormats := r.Formats()
n := 1
for _, medi := range desc.Medias {
for _, forma := range medi.Formats {
if !slices.Contains(setuppedFormats, forma) {
r.Parent.Log(logger.Warn, "skipping track %d (%s)", n, forma.Codec())
}
n++
}
}
w = &mcmpegts.Writer{W: bw, Tracks: tracks}
return w.Initialize()
}
================================================
FILE: internal/protocols/mpegts/from_stream_test.go
================================================
package mpegts
import (
"fmt"
"testing"
"github.com/bluenviron/gortsplib/v5/pkg/description"
"github.com/bluenviron/gortsplib/v5/pkg/format"
"github.com/bluenviron/mediamtx/internal/logger"
"github.com/bluenviron/mediamtx/internal/stream"
"github.com/bluenviron/mediamtx/internal/test"
"github.com/stretchr/testify/require"
)
func TestFromStreamNoSupportedCodecs(t *testing.T) {
desc := &description.Session{Medias: []*description.Media{{
Type: description.MediaTypeVideo,
Formats: []format.Format{&format.VP8{}},
}}}
r := &stream.Reader{
Parent: test.Logger(func(logger.Level, string, ...any) {
t.Error("should not happen")
}),
}
err := FromStream(desc, r, nil, nil, 0)
require.Equal(t, errNoSupportedCodecs, err)
}
func TestFromStreamSkipUnsupportedTracks(t *testing.T) {
desc := &description.Session{Medias: []*description.Media{
{
Type: description.MediaTypeVideo,
Formats: []format.Format{&format.H265{}},
},
{
Type: description.MediaTypeVideo,
Formats: []format.Format{&format.VP8{}},
},
}}
n := 0
r := &stream.Reader{
Parent: test.Logger(func(l logger.Level, format string, args ...any) {
require.Equal(t, logger.Warn, l)
if n == 0 {
require.Equal(t, "skipping track 2 (VP8)", fmt.Sprintf(format, args...))
}
n++
}),
}
err := FromStream(desc, r, nil, nil, 0)
require.NoError(t, err)
require.Equal(t, 1, n)
}
================================================
FILE: internal/protocols/mpegts/to_stream.go
================================================
// Package mpegts contains MPEG-ts utilities.
package mpegts
import (
"errors"
"fmt"
"reflect"
"github.com/bluenviron/gortsplib/v5/pkg/description"
"github.com/bluenviron/gortsplib/v5/pkg/format"
"github.com/bluenviron/mediacommon/v2/pkg/codecs/mpeg4audio"
"github.com/bluenviron/mediacommon/v2/pkg/formats/mpegts"
tscodecs "github.com/bluenviron/mediacommon/v2/pkg/formats/mpegts/codecs"
"github.com/bluenviron/mediamtx/internal/logger"
"github.com/bluenviron/mediamtx/internal/stream"
"github.com/bluenviron/mediamtx/internal/unit"
)
var errNoSupportedCodecs = errors.New(
"the stream doesn't contain any supported codec, which are currently " +
"H265, H264, MPEG-4 Video, MPEG-1/2 Video, Opus, MPEG-4 Audio, MPEG-1 Audio, AC-3")
// ToStream maps a MPEG-TS stream to a MediaMTX stream.
func ToStream(
r *EnhancedReader,
subStream **stream.SubStream,
l logger.Writer,
) ([]*description.Media, error) {
var medias []*description.Media //nolint:prealloc
var unsupportedTracks []int
td := &mpegts.TimeDecoder{}
td.Initialize()
for i, track := range r.Tracks() { //nolint:dupl
var medi *description.Media
switch codec := track.Codec.(type) {
case *tscodecs.H265:
medi = &description.Media{
Type: description.MediaTypeVideo,
Formats: []format.Format{&format.H265{
PayloadTyp: 96,
}},
}
r.OnDataH265(track, func(pts int64, _ int64, au [][]byte) error {
pts = td.Decode(pts)
(*subStream).WriteUnit(medi, medi.Formats[0], &unit.Unit{
PTS: pts, // no conversion is needed since clock rate is 90khz in both MPEG-TS and RTSP
Payload: unit.PayloadH265(au),
})
return nil
})
case *tscodecs.H264:
medi = &description.Media{
Type: description.MediaTypeVideo,
Formats: []format.Format{&format.H264{
PayloadTyp: 96,
PacketizationMode: 1,
}},
}
r.OnDataH264(track, func(pts int64, _ int64, au [][]byte) error {
pts = td.Decode(pts)
(*subStream).WriteUnit(medi, medi.Formats[0], &unit.Unit{
PTS: pts, // no conversion is needed since clock rate is 90khz in both MPEG-TS and RTSP
Payload: unit.PayloadH264(au),
})
return nil
})
case *tscodecs.MPEG4Video:
medi = &description.Media{
Type: description.MediaTypeVideo,
Formats: []format.Format{&format.MPEG4Video{
PayloadTyp: 96,
}},
}
r.OnDataMPEGxVideo(track, func(pts int64, frame []byte) error {
pts = td.Decode(pts)
(*subStream).WriteUnit(medi, medi.Formats[0], &unit.Unit{
PTS: pts, // no conversion is needed since clock rate is 90khz in both MPEG-TS and RTSP
Payload: unit.PayloadMPEG4Video(frame),
})
return nil
})
case *tscodecs.MPEG1Video:
medi = &description.Media{
Type: description.MediaTypeVideo,
Formats: []format.Format{&format.MPEG1Video{}},
}
r.OnDataMPEGxVideo(track, func(pts int64, frame []byte) error {
pts = td.Decode(pts)
(*subStream).WriteUnit(medi, medi.Formats[0], &unit.Unit{
PTS: pts, // no conversion is needed since clock rate is 90khz in both MPEG-TS and RTSP
Payload: unit.PayloadMPEG1Video(frame),
})
return nil
})
case *tscodecs.Opus:
medi = &description.Media{
Type: description.MediaTypeAudio,
Formats: []format.Format{&format.Opus{
PayloadTyp: 96,
ChannelCount: codec.Desc.ChannelCount(),
}},
}
r.OnDataOpus(track, func(pts int64, packets [][]byte) error {
pts = td.Decode(pts)
(*subStream).WriteUnit(medi, medi.Formats[0], &unit.Unit{
PTS: multiplyAndDivide(pts, int64(medi.Formats[0].ClockRate()), 90000),
Payload: unit.PayloadOpus(packets),
})
return nil
})
case *tscodecs.KLV:
medi = &description.Media{
Type: description.MediaTypeApplication,
Formats: []format.Format{&format.KLV{
PayloadTyp: 96,
}},
}
r.OnDataKLV(track, func(pts int64, uni []byte) error {
pts = td.Decode(pts)
(*subStream).WriteUnit(medi, medi.Formats[0], &unit.Unit{
PTS: pts,
Payload: unit.PayloadKLV(uni),
})
return nil
})
case *tscodecs.MPEG4Audio:
medi = &description.Media{
Type: description.MediaTypeAudio,
Formats: []format.Format{&format.MPEG4Audio{
PayloadTyp: 96,
SizeLength: 13,
IndexLength: 3,
IndexDeltaLength: 3,
Config: &codec.Config,
}},
}
r.OnDataMPEG4Audio(track, func(pts int64, aus [][]byte) error {
pts = td.Decode(pts)
(*subStream).WriteUnit(medi, medi.Formats[0], &unit.Unit{
PTS: multiplyAndDivide(pts, int64(medi.Formats[0].ClockRate()), 90000),
Payload: unit.PayloadMPEG4Audio(aus),
})
return nil
})
case *tscodecs.MPEG4AudioLATM:
// We are dealing with a LATM stream with in-band configuration.
// Although in theory this can be streamed with RTSP (RFC6416 with cpresent=1),
// in practice there is no player that supports it.
// Therefore, convert the stream to a LATM stream with out-of-band configuration.
streamMuxConfig := r.latmConfigs[track.PID]
medi = &description.Media{
Type: description.MediaTypeAudio,
Formats: []format.Format{&format.MPEG4AudioLATM{
PayloadTyp: 96,
CPresent: false,
ProfileLevelID: 30,
StreamMuxConfig: streamMuxConfig,
}},
}
clockRate := medi.Formats[0].ClockRate()
r.OnDataMPEG4AudioLATM(track, func(pts int64, els [][]byte) error {
pts = td.Decode(pts)
pts = multiplyAndDivide(pts, int64(clockRate), 90000)
for _, el := range els {
var elIn mpeg4audio.AudioMuxElement
elIn.MuxConfigPresent = true
elIn.StreamMuxConfig = streamMuxConfig
err := elIn.Unmarshal(el)
if err != nil {
return err
}
if !reflect.DeepEqual(elIn.StreamMuxConfig, streamMuxConfig) {
return fmt.Errorf("dynamic stream mux config is not supported")
}
var elOut mpeg4audio.AudioMuxElement
elOut.MuxConfigPresent = false
elOut.StreamMuxConfig = streamMuxConfig
elOut.Payloads = elIn.Payloads
buf, err := elOut.Marshal()
if err != nil {
return err
}
(*subStream).WriteUnit(medi, medi.Formats[0], &unit.Unit{
PTS: pts,
Payload: unit.PayloadMPEG4AudioLATM(buf),
})
pts += mpeg4audio.SamplesPerAccessUnit
}
return nil
})
case *tscodecs.MPEG1Audio:
medi = &description.Media{
Type: description.MediaTypeAudio,
Formats: []format.Format{&format.MPEG1Audio{}},
}
r.OnDataMPEG1Audio(track, func(pts int64, frames [][]byte) error {
pts = td.Decode(pts)
(*subStream).WriteUnit(medi, medi.Formats[0], &unit.Unit{
PTS: pts, // no conversion is needed since clock rate is 90khz in both MPEG-TS and RTSP
Payload: unit.PayloadMPEG1Audio(frames),
})
return nil
})
case *tscodecs.AC3:
medi = &description.Media{
Type: description.MediaTypeAudio,
Formats: []format.Format{&format.AC3{
PayloadTyp: 96,
SampleRate: codec.SampleRate,
ChannelCount: codec.ChannelCount,
}},
}
r.OnDataAC3(track, func(pts int64, frame []byte) error {
pts = td.Decode(pts)
(*subStream).WriteUnit(medi, medi.Formats[0], &unit.Unit{
PTS: multiplyAndDivide(pts, int64(medi.Formats[0].ClockRate()), 90000),
Payload: unit.PayloadAC3{frame},
})
return nil
})
default:
unsupportedTracks = append(unsupportedTracks, i+1)
continue
}
medias = append(medias, medi)
}
if len(medias) == 0 {
return nil, errNoSupportedCodecs
}
for _, id := range unsupportedTracks {
l.Log(logger.Warn, "skipping track %d (unsupported codec)", id)
}
return medias, nil
}
================================================
FILE: internal/protocols/mpegts/to_stream_test.go
================================================
package mpegts
import (
"bytes"
"context"
"fmt"
"testing"
"github.com/asticode/go-astits"
"github.com/bluenviron/gortsplib/v5/pkg/description"
"github.com/bluenviron/gortsplib/v5/pkg/format"
"github.com/bluenviron/mediacommon/v2/pkg/codecs/mpeg4audio"
"github.com/bluenviron/mediamtx/internal/logger"
"github.com/bluenviron/mediamtx/internal/test"
"github.com/stretchr/testify/require"
)
func TestToStream(t *testing.T) {
for _, ca := range []string{
"h265",
"h264",
"mpeg-4 audio latm",
} {
t.Run(ca, func(t *testing.T) {
var buf bytes.Buffer
mux := astits.NewMuxer(context.Background(), &buf)
switch ca {
case "h265":
err := mux.AddElementaryStream(astits.PMTElementaryStream{
ElementaryPID: 122,
StreamType: astits.StreamTypeH265Video,
})
require.NoError(t, err)
mux.SetPCRPID(122)
_, err = mux.WriteTables()
require.NoError(t, err)
case "h264":
err := mux.AddElementaryStream(astits.PMTElementaryStream{
ElementaryPID: 122,
StreamType: astits.StreamTypeH264Video,
})
require.NoError(t, err)
mux.SetPCRPID(122)
_, err = mux.WriteTables()
require.NoError(t, err)
case "mpeg-4 audio latm":
err := mux.AddElementaryStream(astits.PMTElementaryStream{
ElementaryPID: 122,
StreamType: astits.StreamTypeAACLATMAudio,
})
require.NoError(t, err)
mux.SetPCRPID(122)
enc1, err := mpeg4audio.AudioMuxElement{
MuxConfigPresent: true,
StreamMuxConfig: &mpeg4audio.StreamMuxConfig{
Programs: []*mpeg4audio.StreamMuxConfigProgram{{
Layers: []*mpeg4audio.StreamMuxConfigLayer{{
AudioSpecificConfig: &mpeg4audio.AudioSpecificConfig{
Type: 2,
SampleRate: 48000,
ChannelCount: 2,
},
LatmBufferFullness: 255,
}},
}},
},
Payloads: [][][][]byte{{{{1, 2, 3, 4}}}},
}.Marshal()
require.NoError(t, err)
enc2, err := mpeg4audio.AudioSyncStream{
AudioMuxElements: [][]byte{enc1},
}.Marshal()
require.NoError(t, err)
_, err = mux.WriteData(&astits.MuxerData{
PID: 122,
PES: &astits.PESData{
Header: &astits.PESHeader{
OptionalHeader: &astits.PESOptionalHeader{
MarkerBits: 2,
PTSDTSIndicator: astits.PTSDTSIndicatorOnlyPTS,
PTS: &astits.ClockReference{Base: 90000},
},
StreamID: 192,
},
Data: enc2,
},
})
require.NoError(t, err)
}
r := &EnhancedReader{R: &buf}
err := r.Initialize()
require.NoError(t, err)
desc, err := ToStream(r, nil, nil)
require.NoError(t, err)
switch ca {
case "h265":
require.Equal(t, []*description.Media{{
Type: description.MediaTypeVideo,
Formats: []format.Format{&format.H265{
PayloadTyp: 96,
}},
}}, desc)
case "h264":
require.Equal(t, []*description.Media{{
Type: description.MediaTypeVideo,
Formats: []format.Format{&format.H264{
PayloadTyp: 96,
PacketizationMode: 1,
}},
}}, desc)
case "mpeg-4 audio latm":
require.Equal(t, []*description.Media{{
Type: description.MediaTypeAudio,
Formats: []format.Format{&format.MPEG4AudioLATM{
PayloadTyp: 96,
ProfileLevelID: 30,
StreamMuxConfig: &mpeg4audio.StreamMuxConfig{
Programs: []*mpeg4audio.StreamMuxConfigProgram{{
Layers: []*mpeg4audio.StreamMuxConfigLayer{{
AudioSpecificConfig: &mpeg4audio.AudioSpecificConfig{
Type: 2,
SampleRate: 48000,
ChannelCount: 2,
ChannelConfig: 2,
},
LatmBufferFullness: 255,
}},
}},
},
}},
}}, desc)
}
})
}
}
func TestToStreamNoSupportedCodecs(t *testing.T) {
var buf bytes.Buffer
mux := astits.NewMuxer(context.Background(), &buf)
err := mux.AddElementaryStream(astits.PMTElementaryStream{
ElementaryPID: 122,
StreamType: astits.StreamTypeDTSAudio,
})
require.NoError(t, err)
mux.SetPCRPID(122)
_, err = mux.WriteTables()
require.NoError(t, err)
r := &EnhancedReader{R: &buf}
err = r.Initialize()
require.NoError(t, err)
l := test.Logger(func(logger.Level, string, ...any) {
t.Error("should not happen")
})
_, err = ToStream(r, nil, l)
require.Equal(t, errNoSupportedCodecs, err)
}
func TestToStreamSkipUnsupportedTracks(t *testing.T) {
var buf bytes.Buffer
mux := astits.NewMuxer(context.Background(), &buf)
err := mux.AddElementaryStream(astits.PMTElementaryStream{
ElementaryPID: 122,
StreamType: astits.StreamTypeDTSAudio,
})
require.NoError(t, err)
err = mux.AddElementaryStream(astits.PMTElementaryStream{
ElementaryPID: 123,
StreamType: astits.StreamTypeH264Video,
})
require.NoError(t, err)
mux.SetPCRPID(122)
_, err = mux.WriteTables()
require.NoError(t, err)
r := &EnhancedReader{R: &buf}
err = r.Initialize()
require.NoError(t, err)
n := 0
l := test.Logger(func(l logger.Level, format string, args ...any) {
require.Equal(t, logger.Warn, l)
if n == 0 {
require.Equal(t, "skipping track 1 (unsupported codec)", fmt.Sprintf(format, args...))
}
n++
})
_, err = ToStream(r, nil, l)
require.NoError(t, err)
}
================================================
FILE: internal/protocols/rtmp/from_stream.go
================================================
// Package rtmp provides RTMP utilities.
package rtmp
import (
"errors"
"net"
"slices"
"time"
"github.com/bluenviron/gortmplib"
"github.com/bluenviron/gortmplib/pkg/codecs"
"github.com/bluenviron/gortmplib/pkg/message"
"github.com/bluenviron/gortsplib/v5/pkg/description"
"github.com/bluenviron/gortsplib/v5/pkg/format"
"github.com/bluenviron/mediacommon/v2/pkg/codecs/ac3"
"github.com/bluenviron/mediacommon/v2/pkg/codecs/h264"
"github.com/bluenviron/mediacommon/v2/pkg/codecs/h265"
"github.com/bluenviron/mediacommon/v2/pkg/codecs/mpeg1audio"
"github.com/bluenviron/mediacommon/v2/pkg/codecs/mpeg4audio"
"github.com/bluenviron/mediacommon/v2/pkg/codecs/opus"
"github.com/bluenviron/mediamtx/internal/logger"
"github.com/bluenviron/mediamtx/internal/stream"
"github.com/bluenviron/mediamtx/internal/unit"
)
var errNoSupportedCodecsFrom = errors.New(
"the stream doesn't contain any supported codec, which are currently " +
"AV1, VP9, H265, H264, Opus, MPEG-4 Audio, MPEG-1/2 Audio, AC-3, G711, LPCM")
func multiplyAndDivide2(v, m, d time.Duration) time.Duration {
secs := v / d
dec := v % d
return (secs*m + dec*m/d)
}
func timestampToDuration(t int64, clockRate int) time.Duration {
return multiplyAndDivide2(time.Duration(t), time.Second, time.Duration(clockRate))
}
// FromStream maps a MediaMTX stream to a RTMP stream.
func FromStream(
desc *description.Session,
r *stream.Reader,
conn *gortmplib.ServerConn,
nconn net.Conn,
writeTimeout time.Duration,
) error {
var tracks []*gortmplib.Track
var w *gortmplib.Writer
isEnhanced := len(conn.FourCcList) != 0
legacyVideoTrackCount := 0
legacyAudioTrackCount := 0
for _, media := range desc.Medias {
for _, forma := range media.Formats {
switch forma := forma.(type) {
case *format.AV1:
if slices.Contains(conn.FourCcList, any(fourCCToString(message.FourCCAV1))) {
track := &gortmplib.Track{
Codec: &codecs.AV1{},
}
tracks = append(tracks, track)
r.OnData(
media,
forma,
func(u *unit.Unit) error {
if u.NilPayload() {
return nil
}
nconn.SetWriteDeadline(time.Now().Add(writeTimeout))
return (*w).WriteAV1(
track,
timestampToDuration(u.PTS, forma.ClockRate()),
u.Payload.(unit.PayloadAV1))
})
}
case *format.VP9:
if slices.Contains(conn.FourCcList, any(fourCCToString(message.FourCCVP9))) {
track := &gortmplib.Track{
Codec: &codecs.VP9{},
}
tracks = append(tracks, track)
r.OnData(
media,
forma,
func(u *unit.Unit) error {
if u.NilPayload() {
return nil
}
nconn.SetWriteDeadline(time.Now().Add(writeTimeout))
return (*w).WriteVP9(
track,
timestampToDuration(u.PTS, forma.ClockRate()),
u.Payload.(unit.PayloadVP9))
})
}
case *format.H265:
if slices.Contains(conn.FourCcList, any(fourCCToString(message.FourCCHEVC))) {
vps, sps, pps := forma.SafeParams()
track := &gortmplib.Track{
Codec: &codecs.H265{
VPS: vps,
SPS: sps,
PPS: pps,
},
}
tracks = append(tracks, track)
var videoDTSExtractor *h265.DTSExtractor
r.OnData(
media,
forma,
func(u *unit.Unit) error {
if u.NilPayload() {
return nil
}
if videoDTSExtractor == nil {
if !h265.IsRandomAccess(u.Payload.(unit.PayloadH265)) {
return nil
}
videoDTSExtractor = &h265.DTSExtractor{}
videoDTSExtractor.Initialize()
}
dts, err := videoDTSExtractor.Extract(u.Payload.(unit.PayloadH265), u.PTS)
if err != nil {
return err
}
nconn.SetWriteDeadline(time.Now().Add(writeTimeout))
return (*w).WriteH265(
track,
timestampToDuration(u.PTS, forma.ClockRate()),
timestampToDuration(dts, forma.ClockRate()),
u.Payload.(unit.PayloadH265))
})
}
case *format.H264:
if isEnhanced || legacyVideoTrackCount == 0 {
legacyVideoTrackCount++
sps, pps := forma.SafeParams()
track := &gortmplib.Track{
Codec: &codecs.H264{
SPS: sps,
PPS: pps,
},
}
tracks = append(tracks, track)
var videoDTSExtractor *h264.DTSExtractor
r.OnData(
media,
forma,
func(u *unit.Unit) error {
if u.NilPayload() {
return nil
}
idrPresent := false
nonIDRPresent := false
for _, nalu := range u.Payload.(unit.PayloadH264) {
typ := h264.NALUType(nalu[0] & 0x1F)
switch typ {
case h264.NALUTypeIDR:
idrPresent = true
case h264.NALUTypeNonIDR:
nonIDRPresent = true
}
}
// wait until we receive an IDR
if videoDTSExtractor == nil {
if !idrPresent {
return nil
}
videoDTSExtractor = &h264.DTSExtractor{}
videoDTSExtractor.Initialize()
} else if !idrPresent && !nonIDRPresent {
return nil
}
dts, err := videoDTSExtractor.Extract(u.Payload.(unit.PayloadH264), u.PTS)
if err != nil {
return err
}
nconn.SetWriteDeadline(time.Now().Add(writeTimeout))
return (*w).WriteH264(
track,
timestampToDuration(u.PTS, forma.ClockRate()),
timestampToDuration(dts, forma.ClockRate()),
u.Payload.(unit.PayloadH264))
})
}
case *format.Opus:
if slices.Contains(conn.FourCcList, any(fourCCToString(message.FourCCOpus))) {
track := &gortmplib.Track{
Codec: &codecs.Opus{
ChannelCount: forma.ChannelCount,
},
}
tracks = append(tracks, track)
r.OnData(
media,
forma,
func(u *unit.Unit) error {
if u.NilPayload() {
return nil
}
pts := u.PTS
for _, pkt := range u.Payload.(unit.PayloadOpus) {
nconn.SetWriteDeadline(time.Now().Add(writeTimeout))
err := (*w).WriteOpus(
track,
timestampToDuration(pts, forma.ClockRate()),
pkt,
)
if err != nil {
return err
}
pts += opus.PacketDuration2(pkt)
}
return nil
})
}
case *format.MPEG4Audio:
if isEnhanced || legacyAudioTrackCount == 0 {
legacyAudioTrackCount++
track := &gortmplib.Track{
Codec: &codecs.MPEG4Audio{
Config: forma.Config,
},
}
tracks = append(tracks, track)
r.OnData(
media,
forma,
func(u *unit.Unit) error {
if u.NilPayload() {
return nil
}
for i, au := range u.Payload.(unit.PayloadMPEG4Audio) {
pts := u.PTS + int64(i)*mpeg4audio.SamplesPerAccessUnit
nconn.SetWriteDeadline(time.Now().Add(writeTimeout))
err := (*w).WriteMPEG4Audio(
track,
timestampToDuration(pts, forma.ClockRate()),
au,
)
if err != nil {
return err
}
}
return nil
})
}
case *format.MPEG4AudioLATM:
if !forma.CPresent && (isEnhanced || legacyAudioTrackCount == 0) {
legacyAudioTrackCount++
track := &gortmplib.Track{
Codec: &codecs.MPEG4Audio{
Config: forma.StreamMuxConfig.Programs[0].Layers[0].AudioSpecificConfig,
},
}
tracks = append(tracks, track)
r.OnData(
media,
forma,
func(u *unit.Unit) error {
if u.NilPayload() {
return nil
}
var ame mpeg4audio.AudioMuxElement
ame.StreamMuxConfig = forma.StreamMuxConfig
err := ame.Unmarshal(u.Payload.(unit.PayloadMPEG4AudioLATM))
if err != nil {
return err
}
nconn.SetWriteDeadline(time.Now().Add(writeTimeout))
return (*w).WriteMPEG4Audio(
track,
timestampToDuration(u.PTS, forma.ClockRate()),
ame.Payloads[0][0][0],
)
})
}
case *format.MPEG1Audio:
if isEnhanced || legacyAudioTrackCount == 0 {
legacyAudioTrackCount++
track := &gortmplib.Track{
Codec: &codecs.MPEG1Audio{},
}
tracks = append(tracks, track)
r.OnData(
media,
forma,
func(u *unit.Unit) error {
if u.NilPayload() {
return nil
}
pts := u.PTS
for _, frame := range u.Payload.(unit.PayloadMPEG1Audio) {
var h mpeg1audio.FrameHeader
err := h.Unmarshal(frame)
if err != nil {
return err
}
nconn.SetWriteDeadline(time.Now().Add(writeTimeout))
err = (*w).WriteMPEG1Audio(
track,
timestampToDuration(pts, forma.ClockRate()),
frame)
if err != nil {
return err
}
pts += int64(h.SampleCount()) *
int64(forma.ClockRate()) / int64(h.SampleRate)
}
return nil
})
}
case *format.AC3:
if slices.Contains(conn.FourCcList, any(fourCCToString(message.FourCCAC3))) {
track := &gortmplib.Track{
Codec: &codecs.AC3{
SampleRate: forma.SampleRate,
ChannelCount: forma.ChannelCount,
},
}
tracks = append(tracks, track)
r.OnData(
media,
forma,
func(u *unit.Unit) error {
if u.NilPayload() {
return nil
}
for i, frame := range u.Payload.(unit.PayloadAC3) {
pts := u.PTS + int64(i)*ac3.SamplesPerFrame
nconn.SetWriteDeadline(time.Now().Add(writeTimeout))
err := (*w).WriteAC3(
track,
timestampToDuration(pts, forma.ClockRate()),
frame)
if err != nil {
return err
}
}
return nil
})
}
case *format.G711:
if forma.SampleRate == 8000 && (isEnhanced || legacyAudioTrackCount == 0) {
legacyAudioTrackCount++
track := &gortmplib.Track{
Codec: &codecs.G711{
MULaw: forma.MULaw,
ChannelCount: forma.ChannelCount,
},
}
tracks = append(tracks, track)
r.OnData(
media,
forma,
func(u *unit.Unit) error {
if u.NilPayload() {
return nil
}
nconn.SetWriteDeadline(time.Now().Add(writeTimeout))
return (*w).WriteG711(
track,
timestampToDuration(u.PTS, forma.ClockRate()),
u.Payload.(unit.PayloadG711),
)
})
}
case *format.LPCM:
if (forma.ChannelCount == 1 || forma.ChannelCount == 2) &&
(forma.SampleRate == 5512 ||
forma.SampleRate == 11025 ||
forma.SampleRate == 22050 ||
forma.SampleRate == 44100) &&
(isEnhanced || legacyAudioTrackCount == 0) {
legacyAudioTrackCount++
track := &gortmplib.Track{
Codec: &codecs.LPCM{
BitDepth: forma.BitDepth,
SampleRate: forma.SampleRate,
ChannelCount: forma.ChannelCount,
},
}
tracks = append(tracks, track)
r.OnData(
media,
forma,
func(u *unit.Unit) error {
if u.NilPayload() {
return nil
}
nconn.SetWriteDeadline(time.Now().Add(writeTimeout))
return (*w).WriteLPCM(
track,
timestampToDuration(u.PTS, forma.ClockRate()),
u.Payload.(unit.PayloadLPCM),
)
})
}
}
}
}
if len(tracks) == 0 {
return errNoSupportedCodecsFrom
}
w = &gortmplib.Writer{
Conn: conn,
Tracks: tracks,
}
err := w.Initialize()
if err != nil {
return err
}
setuppedFormats := r.Formats()
n := 1
for _, media := range desc.Medias {
for _, forma := range media.Formats {
if !slices.Contains(setuppedFormats, forma) {
r.Parent.Log(logger.Warn, "skipping track %d (%s)", n, forma.Codec())
}
n++
}
}
return nil
}
================================================
FILE: internal/protocols/rtmp/from_stream_test.go
================================================
package rtmp
import (
"context"
"fmt"
"net"
"net/url"
"testing"
"time"
"github.com/bluenviron/gortmplib"
"github.com/bluenviron/gortmplib/pkg/codecs"
"github.com/bluenviron/gortsplib/v5/pkg/description"
"github.com/bluenviron/gortsplib/v5/pkg/format"
"github.com/bluenviron/mediacommon/v2/pkg/codecs/mpeg4audio"
"github.com/bluenviron/mediamtx/internal/logger"
"github.com/bluenviron/mediamtx/internal/stream"
"github.com/bluenviron/mediamtx/internal/test"
"github.com/bluenviron/mediamtx/internal/unit"
"github.com/stretchr/testify/require"
)
var (
h265DefaultVPS = []byte{
0x40, 0x01, 0x0c, 0x01, 0xff, 0xff, 0x02, 0x20,
0x00, 0x00, 0x03, 0x00, 0xb0, 0x00, 0x00, 0x03,
0x00, 0x00, 0x03, 0x00, 0x7b, 0x18, 0xb0, 0x24,
}
h265DefaultSPS = []byte{
0x42, 0x01, 0x01, 0x02, 0x20, 0x00, 0x00, 0x03,
0x00, 0xb0, 0x00, 0x00, 0x03, 0x00, 0x00, 0x03,
0x00, 0x7b, 0xa0, 0x07, 0x82, 0x00, 0x88, 0x7d,
0xb6, 0x71, 0x8b, 0x92, 0x44, 0x80, 0x53, 0x88,
0x88, 0x92, 0xcf, 0x24, 0xa6, 0x92, 0x72, 0xc9,
0x12, 0x49, 0x22, 0xdc, 0x91, 0xaa, 0x48, 0xfc,
0xa2, 0x23, 0xff, 0x00, 0x01, 0x00, 0x01, 0x6a,
0x02, 0x02, 0x02, 0x01,
}
h265DefaultPPS = []byte{
0x44, 0x01, 0xc0, 0x25, 0x2f, 0x05, 0x32, 0x40,
}
h264DefaultSPS = []byte{ // 1920x1080 baseline
0x67, 0x42, 0xc0, 0x28, 0xd9, 0x00, 0x78, 0x02,
0x27, 0xe5, 0x84, 0x00, 0x00, 0x03, 0x00, 0x04,
0x00, 0x00, 0x03, 0x00, 0xf0, 0x3c, 0x60, 0xc9, 0x20,
}
h264DefaultPPS = []byte{0x08, 0x06, 0x07, 0x08}
)
func TestFromStream(t *testing.T) {
h265VPS := []byte{
0x40, 0x01, 0x0c, 0x01, 0xff, 0xff, 0x01, 0x60,
0x00, 0x00, 0x03, 0x00, 0x90, 0x00, 0x00, 0x03,
0x00, 0x00, 0x03, 0x00, 0x78, 0xba, 0x02, 0x40,
}
h265SPS := []byte{
0x42, 0x01, 0x01, 0x01, 0x60, 0x00, 0x00, 0x03,
0x00, 0x90, 0x00, 0x00, 0x03, 0x00, 0x00, 0x03,
0x00, 0x78, 0xa0, 0x03, 0xc0, 0x80, 0x11, 0x07,
0xcb, 0x96, 0xe9, 0x29, 0x30, 0xbc, 0x05, 0xa0,
0x20, 0x00, 0x00, 0x03, 0x00, 0x20, 0x00, 0x00,
0x03, 0x03, 0xc1,
}
h265PPS := []byte{
0x44, 0x01, 0xc0, 0x73, 0xc1, 0x89,
}
cases := []struct {
name string
medias []*description.Media
expectedTracks []*gortmplib.Track
writeUnits func([]*description.Media, *stream.SubStream)
}{
{
name: "h264 + aac",
medias: []*description.Media{
{
Formats: []format.Format{test.FormatH264},
},
{
Formats: []format.Format{test.FormatMPEG4Audio},
},
},
expectedTracks: []*gortmplib.Track{
{Codec: &codecs.H264{
SPS: test.FormatH264.SPS,
PPS: test.FormatH264.PPS,
}},
{Codec: &codecs.MPEG4Audio{
Config: test.FormatMPEG4Audio.Config,
}},
},
writeUnits: func(medias []*description.Media, subStream *stream.SubStream) {
subStream.WriteUnit(medias[0], medias[0].Formats[0], &unit.Unit{
PTS: 0,
Payload: unit.PayloadH264{
{5, 2}, // IDR
},
})
subStream.WriteUnit(medias[1], medias[1].Formats[0], &unit.Unit{
PTS: 90000 * 5,
Payload: unit.PayloadMPEG4Audio{
{3, 4},
},
})
},
},
{
name: "av1",
medias: []*description.Media{
{
Formats: []format.Format{&format.AV1{
PayloadTyp: 96,
}},
},
},
expectedTracks: []*gortmplib.Track{
{Codec: &codecs.AV1{}},
},
writeUnits: func(medias []*description.Media, subStream *stream.SubStream) {
for i := range 2 {
subStream.WriteUnit(medias[0], medias[0].Formats[0], &unit.Unit{
PTS: 90000 * 2 * int64(i),
Payload: unit.PayloadAV1{{
0x0a, 0x0e, 0x00, 0x00, 0x00, 0x4a, 0xab, 0xbf,
0xc3, 0x77, 0x6b, 0xe4, 0x40, 0x40, 0x40, 0x41,
}},
})
}
},
},
{
name: "vp9",
medias: []*description.Media{
{
Formats: []format.Format{&format.VP9{
PayloadTyp: 96,
}},
},
},
expectedTracks: []*gortmplib.Track{
{Codec: &codecs.VP9{}},
},
writeUnits: func(medias []*description.Media, subStream *stream.SubStream) {
for i := range 2 {
subStream.WriteUnit(medias[0], medias[0].Formats[0], &unit.Unit{
PTS: 90000 * 2 * int64(i),
Payload: unit.PayloadVP9{1, 2},
})
}
},
},
{
name: "h265",
medias: []*description.Media{
{
Formats: []format.Format{
&format.H265{
PayloadTyp: 96,
VPS: h265VPS,
SPS: h265SPS,
PPS: h265PPS,
},
},
},
},
expectedTracks: []*gortmplib.Track{
{Codec: &codecs.H265{
VPS: h265VPS,
SPS: h265SPS,
PPS: h265PPS,
}},
},
writeUnits: func(medias []*description.Media, subStream *stream.SubStream) {
for i := range 2 {
subStream.WriteUnit(medias[0], medias[0].Formats[0], &unit.Unit{
PTS: 90000 * 2 * int64(i),
Payload: unit.PayloadH265{{
0x2a, 0x01, 0xad, 0xe0, 0xf5, 0x34, 0x11, 0x0b,
0x41, 0xe8,
}},
})
}
},
},
{
name: "h264",
medias: []*description.Media{
{
Formats: []format.Format{test.FormatH264},
},
},
expectedTracks: []*gortmplib.Track{
{Codec: &codecs.H264{
SPS: test.FormatH264.SPS,
PPS: test.FormatH264.PPS,
}},
},
writeUnits: func(medias []*description.Media, subStream *stream.SubStream) {
for i := range 2 {
subStream.WriteUnit(medias[0], medias[0].Formats[0], &unit.Unit{
PTS: 90000 * 2 * int64(i),
Payload: unit.PayloadH264{
{5, 2}, // IDR
},
})
}
},
},
{
name: "opus",
medias: []*description.Media{
{
Formats: []format.Format{&format.Opus{
PayloadTyp: 96,
ChannelCount: 2,
}},
},
},
expectedTracks: []*gortmplib.Track{
{Codec: &codecs.Opus{
ChannelCount: 2,
}},
},
writeUnits: func(medias []*description.Media, subStream *stream.SubStream) {
for i := range 2 {
subStream.WriteUnit(medias[0], medias[0].Formats[0], &unit.Unit{
PTS: 90000 * 5 * int64(i),
Payload: unit.PayloadOpus{
{3, 4},
},
})
}
},
},
{
name: "aac",
medias: []*description.Media{
{
Formats: []format.Format{test.FormatMPEG4Audio},
},
},
expectedTracks: []*gortmplib.Track{
{Codec: &codecs.MPEG4Audio{
Config: test.FormatMPEG4Audio.Config,
}},
},
writeUnits: func(medias []*description.Media, subStream *stream.SubStream) {
for i := range 2 {
subStream.WriteUnit(medias[0], medias[0].Formats[0], &unit.Unit{
PTS: 90000 * 5 * int64(i),
Payload: unit.PayloadMPEG4Audio{
{3, 4},
},
})
}
},
},
{
name: "mp3",
medias: []*description.Media{
{
Formats: []format.Format{&format.MPEG1Audio{}},
},
},
expectedTracks: []*gortmplib.Track{
{Codec: &codecs.MPEG1Audio{}},
},
writeUnits: func(medias []*description.Media, subStream *stream.SubStream) {
for i := range 2 {
subStream.WriteUnit(medias[0], medias[0].Formats[0], &unit.Unit{
PTS: 90000 * 5 * int64(i),
Payload: unit.PayloadMPEG1Audio{
{
0xff, 0xfa, 0x52, 0x04, 0x00,
},
},
})
}
},
},
{
name: "ac-3",
medias: []*description.Media{
{
Formats: []format.Format{&format.AC3{
SampleRate: 44100,
ChannelCount: 2,
}},
},
},
expectedTracks: []*gortmplib.Track{
{Codec: &codecs.AC3{
SampleRate: 48000,
ChannelCount: 1,
}},
},
writeUnits: func(medias []*description.Media, subStream *stream.SubStream) {
for i := range 2 {
subStream.WriteUnit(medias[0], medias[0].Formats[0], &unit.Unit{
PTS: 90000 * 5 * int64(i),
Payload: unit.PayloadAC3{
{
0x0b, 0x77, 0x47, 0x11, 0x0c, 0x40, 0x2f, 0x84,
0x2b, 0xc1, 0x07, 0x7a, 0xb0, 0xfa, 0xbb, 0xea,
0xef, 0x9f, 0x57, 0x7c, 0xf9, 0xf3, 0xf7, 0xcf,
0x9f, 0x3e, 0x32, 0xfe, 0xd5, 0xc1, 0x50, 0xde,
0xc5, 0x1e, 0x73, 0xd2, 0x6c, 0xa6, 0x94, 0x46,
0x4e, 0x92, 0x8c, 0x0f, 0xb9, 0xcf, 0xad, 0x07,
0x54, 0x4a, 0x2e, 0xf3, 0x7d, 0x07, 0x2e, 0xa4,
0x2f, 0xba, 0xbf, 0x39, 0xb5, 0xc9, 0x92, 0xa6,
0xe1, 0xb4, 0x70, 0xc5, 0xc4, 0xb5, 0xe6, 0x5d,
0x0f, 0xa8, 0x71, 0xa4, 0xcc, 0xc5, 0xbc, 0x75,
0x67, 0x92, 0x52, 0x4f, 0x7e, 0x62, 0x1c, 0xa9,
0xd9, 0xb5, 0x19, 0x6a, 0xd7, 0xb0, 0x44, 0x92,
0x30, 0x3b, 0xf7, 0x61, 0xd6, 0x49, 0x96, 0x66,
0x98, 0x28, 0x1a, 0x95, 0xa9, 0x42, 0xad, 0xb7,
0x50, 0x90, 0xad, 0x1c, 0x34, 0x80, 0xe2, 0xef,
0xcd, 0x41, 0x0b, 0xf0, 0x9d, 0x57, 0x62, 0x78,
0xfd, 0xc6, 0xc2, 0x19, 0x9e, 0x26, 0x31, 0xca,
0x1e, 0x75, 0xb1, 0x7a, 0x8e, 0xb5, 0x51, 0x3a,
0xfe, 0xe4, 0xf1, 0x0b, 0x4f, 0x14, 0x90, 0xdb,
0x9f, 0x44, 0x50, 0xbb, 0xef, 0x74, 0x00, 0x8c,
0x1f, 0x97, 0xa1, 0xa2, 0xfa, 0x72, 0x16, 0x47,
0xc6, 0xc0, 0xe5, 0xfe, 0x67, 0x03, 0x9c, 0xfe,
0x62, 0x01, 0xa1, 0x00, 0x5d, 0xff, 0xa5, 0x03,
0x59, 0xfa, 0xa8, 0x25, 0x5f, 0x6b, 0x83, 0x51,
0xf2, 0xc0, 0x44, 0xff, 0x2d, 0x05, 0x4b, 0xee,
0xe0, 0x54, 0x9e, 0xae, 0x86, 0x45, 0xf3, 0xbd,
0x0e, 0x42, 0xf2, 0xbf, 0x0f, 0x7f, 0xc6, 0x09,
0x07, 0xdc, 0x22, 0x11, 0x77, 0xbe, 0x31, 0x27,
0x5b, 0xa4, 0x13, 0x47, 0x07, 0x32, 0x9f, 0x1f,
0xcb, 0xb0, 0xdf, 0x3e, 0x7d, 0x0d, 0xf3, 0xe7,
0xcf, 0x9f, 0x3e, 0xae, 0xf9, 0xf3, 0xe7, 0xcf,
0x9f, 0x3e, 0x85, 0x5d, 0xf3, 0xe7, 0xcf, 0x9f,
0x3e, 0x7c, 0xf9, 0xf3, 0xe7, 0xcf, 0x9f, 0x3f,
0x53, 0x5d, 0xf3, 0xe7, 0xcf, 0x9f, 0x3e, 0x7c,
0xf9, 0xf3, 0xe7, 0xcf, 0x9f, 0x3e, 0x7c, 0xf9,
0xf3, 0xe7, 0xcf, 0x9f, 0x3e, 0x7c, 0xf9, 0xf3,
0xe7, 0xcf, 0x9f, 0x3e, 0x00, 0x46, 0x28, 0x26,
0x20, 0x4a, 0x5a, 0xc0, 0x8a, 0xc5, 0xae, 0xa0,
0x55, 0x78, 0x82, 0x7a, 0x38, 0x10, 0x09, 0xc9,
0xb8, 0x0c, 0xfa, 0x5b, 0xc9, 0xd2, 0xec, 0x44,
0x25, 0xf8, 0x20, 0xf2, 0xc8, 0x8a, 0xe9, 0x40,
0x18, 0x06, 0xc6, 0x2b, 0xc8, 0xed, 0x8f, 0x33,
0x09, 0x92, 0x28, 0x1e, 0xc4, 0x24, 0xd8, 0x33,
0xa5, 0x00, 0xf5, 0xea, 0x18, 0xfa, 0x90, 0x97,
0x97, 0xe8, 0x39, 0x6a, 0xcf, 0xf1, 0xdd, 0xff,
0x9e, 0x8e, 0x04, 0x02, 0xae, 0x65, 0x87, 0x5c,
0x4e, 0x72, 0xfd, 0x3c, 0x01, 0x86, 0xfe, 0x56,
0x59, 0x74, 0x44, 0x3a, 0x40, 0x00, 0xec, 0xfc,
},
},
})
}
},
},
{
name: "pcma",
medias: []*description.Media{
{
Formats: []format.Format{&format.G711{
MULaw: false,
SampleRate: 8000,
ChannelCount: 1,
}},
},
},
expectedTracks: []*gortmplib.Track{
{Codec: &codecs.G711{
MULaw: false,
ChannelCount: 1,
}},
},
writeUnits: func(medias []*description.Media, subStream *stream.SubStream) {
for i := range 2 {
subStream.WriteUnit(medias[0], medias[0].Formats[0], &unit.Unit{
PTS: 90000 * 5 * int64(i),
Payload: unit.PayloadG711{
3, 4,
},
})
}
},
},
{
name: "pcmu",
medias: []*description.Media{
{
Formats: []format.Format{&format.G711{
MULaw: true,
SampleRate: 8000,
ChannelCount: 1,
}},
},
},
expectedTracks: []*gortmplib.Track{
{Codec: &codecs.G711{
MULaw: true,
ChannelCount: 1,
}},
},
writeUnits: func(medias []*description.Media, subStream *stream.SubStream) {
for i := range 2 {
subStream.WriteUnit(medias[0], medias[0].Formats[0], &unit.Unit{
PTS: 90000 * 5 * int64(i),
Payload: unit.PayloadG711{
3, 4,
},
})
}
},
},
{
name: "lpcm",
medias: []*description.Media{
{
Formats: []format.Format{&format.LPCM{
BitDepth: 16,
SampleRate: 44100,
ChannelCount: 2,
}},
},
},
expectedTracks: []*gortmplib.Track{
{Codec: &codecs.LPCM{
BitDepth: 16,
SampleRate: 44100,
ChannelCount: 2,
}},
},
writeUnits: func(medias []*description.Media, subStream *stream.SubStream) {
for i := range 2 {
subStream.WriteUnit(medias[0], medias[0].Formats[0], &unit.Unit{
PTS: 90000 * 5 * int64(i),
Payload: unit.PayloadLPCM{
3, 4, 5, 6,
},
})
}
},
},
{
name: "h265 + h264 + vp9 + av1 + opus + aac",
medias: []*description.Media{
{
Formats: []format.Format{&format.H265{}},
},
{
Formats: []format.Format{&format.H264{}},
},
{
Formats: []format.Format{&format.VP9{}},
},
{
Formats: []format.Format{&format.AV1{}},
},
{
Formats: []format.Format{&format.Opus{
PayloadTyp: 96,
ChannelCount: 2,
}},
},
{
Formats: []format.Format{&format.MPEG4Audio{
PayloadTyp: 96,
Config: test.FormatMPEG4Audio.Config,
SizeLength: 13,
IndexLength: 3,
IndexDeltaLength: 3,
}},
},
},
expectedTracks: []*gortmplib.Track{
{Codec: &codecs.H265{
VPS: h265DefaultVPS,
SPS: h265DefaultSPS,
PPS: h265DefaultPPS,
}},
{Codec: &codecs.H264{
SPS: h264DefaultSPS,
PPS: h264DefaultPPS,
}},
{Codec: &codecs.VP9{}},
{Codec: &codecs.AV1{}},
{Codec: &codecs.Opus{
ChannelCount: 2,
}},
{Codec: &codecs.MPEG4Audio{
Config: test.FormatMPEG4Audio.Config,
}},
},
writeUnits: func(medias []*description.Media, subStream *stream.SubStream) {
subStream.WriteUnit(medias[0], medias[0].Formats[0], &unit.Unit{
Payload: unit.PayloadH265{
{
0x40, 0x01, 0x0c, 0x01, 0xff, 0xff, 0x01, 0x60,
0x00, 0x00, 0x03, 0x00, 0x90, 0x00, 0x00, 0x03,
0x00, 0x00, 0x03, 0x00, 0x78, 0xba, 0x02, 0x40,
},
{
0x42, 0x01, 0x01, 0x01, 0x60, 0x00, 0x00, 0x03,
0x00, 0x90, 0x00, 0x00, 0x03, 0x00, 0x00, 0x03,
0x00, 0x78, 0xa0, 0x03, 0xc0, 0x80, 0x11, 0x07,
0xcb, 0x96, 0xe9, 0x29, 0x30, 0xbc, 0x05, 0xa0,
0x20, 0x00, 0x00, 0x03, 0x00, 0x20, 0x00, 0x00,
0x03, 0x03, 0xc1,
},
{
0x44, 0x01, 0xc0, 0x73, 0xc1, 0x89,
},
{
0x2a, 0x01, 0xad, 0xe0, 0xf5, 0x34, 0x11, 0x0b,
0x41, 0xe8,
},
},
})
subStream.WriteUnit(medias[1], medias[1].Formats[0], &unit.Unit{
Payload: unit.PayloadH264{
h264DefaultSPS,
h264DefaultPPS,
{5, 2}, // IDR
},
})
subStream.WriteUnit(medias[2], medias[2].Formats[0], &unit.Unit{
Payload: unit.PayloadVP9{1, 2},
})
subStream.WriteUnit(medias[3], medias[3].Formats[0], &unit.Unit{
Payload: unit.PayloadAV1{{
0x0a, 0x0e, 0x00, 0x00, 0x00, 0x4a, 0xab, 0xbf,
0xc3, 0x77, 0x6b, 0xe4, 0x40, 0x40, 0x40, 0x41,
}},
})
subStream.WriteUnit(medias[4], medias[4].Formats[0], &unit.Unit{
Payload: unit.PayloadOpus{
{3, 4},
},
})
subStream.WriteUnit(medias[5], medias[5].Formats[0], &unit.Unit{
PTS: 90000 * 5,
Payload: unit.PayloadMPEG4Audio{
{3, 4},
},
})
},
},
}
for _, tc := range cases {
t.Run(tc.name, func(t *testing.T) {
medias := tc.medias
strm := &stream.Stream{
Desc: &description.Session{Medias: medias},
WriteQueueSize: 512,
RTPMaxPayloadSize: 1450,
Parent: test.NilLogger,
}
err := strm.Initialize()
require.NoError(t, err)
subStream := &stream.SubStream{
Stream: strm,
UseRTPPackets: false,
}
err = subStream.Initialize()
require.NoError(t, err)
ln, err := net.Listen("tcp", "127.0.0.1:9121")
require.NoError(t, err)
defer ln.Close()
done := make(chan struct{})
go func() {
u, err2 := url.Parse("rtmp://127.0.0.1:9121/stream")
require.NoError(t, err2)
c := &gortmplib.Client{
URL: u,
}
err2 = c.Initialize(context.Background())
require.NoError(t, err2)
r := &gortmplib.Reader{
Conn: c,
}
err2 = r.Initialize()
require.NoError(t, err2)
require.Equal(t, tc.expectedTracks, r.Tracks())
close(done)
}()
nconn, err := ln.Accept()
require.NoError(t, err)
defer nconn.Close()
conn := &gortmplib.ServerConn{
RW: nconn,
}
err = conn.Initialize()
require.NoError(t, err)
err = conn.Accept()
require.NoError(t, err)
r := &stream.Reader{Parent: test.NilLogger}
err = FromStream(strm.Desc, r, conn, nconn, 10*time.Second)
require.NoError(t, err)
strm.AddReader(r)
defer strm.RemoveReader(r)
tc.writeUnits(medias, subStream)
<-done
})
}
}
func TestFromStreamLegacyClientMultipleTracks(t *testing.T) {
// Test that legacy RTMP clients (without enhanced RTMP)
// only receive one H264 track and one MPEG4-audio track
// when multiple tracks of each type are available
h264SPS1 := []byte{
0x67, 0x42, 0xc0, 0x28, 0xd9, 0x00, 0x78, 0x02,
0x27, 0xe5, 0x84, 0x00, 0x00, 0x03, 0x00, 0x04,
0x00, 0x00, 0x03, 0x00, 0xf0, 0x3c, 0x60, 0xc9, 0x20,
}
h264PPS1 := []byte{0x08, 0x06, 0x07, 0x08}
h264SPS2 := []byte{
0x67, 0x42, 0xc0, 0x28, 0xd9, 0x00, 0x78, 0x02,
0x27, 0xe5, 0x84, 0x00, 0x00, 0x03, 0x00, 0x04,
0x00, 0x00, 0x03, 0x00, 0xf0, 0x3c, 0x60, 0xc9, 0x21,
}
h264PPS2 := []byte{0x08, 0x06, 0x07, 0x09}
aacConfig1 := test.FormatMPEG4Audio.Config
aacConfig2 := &mpeg4audio.AudioSpecificConfig{
Type: 2, // MPEG4-AAC LC
SampleRate: 48000,
ChannelCount: 2,
ChannelConfig: 2,
}
medias := []*description.Media{
{
Formats: []format.Format{&format.H264{
PayloadTyp: 96,
PacketizationMode: 1,
SPS: h264SPS1,
PPS: h264PPS1,
}},
},
{
Formats: []format.Format{&format.H264{
PayloadTyp: 97,
PacketizationMode: 1,
SPS: h264SPS2,
PPS: h264PPS2,
}},
},
{
Formats: []format.Format{&format.MPEG4Audio{
PayloadTyp: 98,
Config: aacConfig1,
SizeLength: 13,
IndexLength: 3,
IndexDeltaLength: 3,
}},
},
{
Formats: []format.Format{&format.MPEG4Audio{
PayloadTyp: 99,
Config: aacConfig2,
SizeLength: 13,
IndexLength: 3,
IndexDeltaLength: 3,
}},
},
}
strm := &stream.Stream{
Desc: &description.Session{Medias: medias},
WriteQueueSize: 512,
RTPMaxPayloadSize: 1450,
Parent: test.NilLogger,
}
err := strm.Initialize()
require.NoError(t, err)
subStream := &stream.SubStream{
Stream: strm,
UseRTPPackets: false,
}
err = subStream.Initialize()
require.NoError(t, err)
ln, err := net.Listen("tcp", "127.0.0.1:9121")
require.NoError(t, err)
defer ln.Close()
done := make(chan struct{})
go func() {
u, err2 := url.Parse("rtmp://127.0.0.1:9121/stream")
require.NoError(t, err2)
c := &gortmplib.Client{
URL: u,
}
err2 = c.Initialize(context.Background())
require.NoError(t, err2)
r := &gortmplib.Reader{
Conn: c,
}
err2 = r.Initialize()
require.NoError(t, err2)
require.Equal(t, []*gortmplib.Track{
{Codec: &codecs.H264{
SPS: h264SPS1,
PPS: h264PPS1,
}},
{Codec: &codecs.MPEG4Audio{
Config: aacConfig1,
}},
}, r.Tracks())
close(done)
}()
nconn, err := ln.Accept()
require.NoError(t, err)
defer nconn.Close()
conn := &gortmplib.ServerConn{
RW: nconn,
}
err = conn.Initialize()
require.NoError(t, err)
err = conn.Accept()
require.NoError(t, err)
// Simulate a legacy client by clearing the FourCcList
conn.FourCcList = []any{}
r := &stream.Reader{Parent: test.NilLogger}
err = FromStream(strm.Desc, r, conn, nconn, 10*time.Second)
require.NoError(t, err)
strm.AddReader(r)
defer strm.RemoveReader(r)
// Write units to trigger track setup
subStream.WriteUnit(medias[0], medias[0].Formats[0], &unit.Unit{
PTS: 0,
Payload: unit.PayloadH264{
{5, 1}, // IDR
},
})
subStream.WriteUnit(medias[2], medias[2].Formats[0], &unit.Unit{
PTS: 90000,
Payload: unit.PayloadMPEG4Audio{
{3, 4},
},
})
<-done
}
func TestFromStreamNoSupportedCodecs(t *testing.T) {
desc := &description.Session{Medias: []*description.Media{{
Type: description.MediaTypeVideo,
Formats: []format.Format{&format.VP8{}},
}}}
r := &stream.Reader{
Parent: test.Logger(func(logger.Level, string, ...any) {
t.Error("should not happen")
}),
}
conn := &gortmplib.ServerConn{}
err := FromStream(desc, r, conn, nil, 0)
require.Equal(t, errNoSupportedCodecsFrom, err)
}
func TestFromStreamSkipUnsupportedTracks(t *testing.T) {
desc := &description.Session{Medias: []*description.Media{
{
Type: description.MediaTypeVideo,
Formats: []format.Format{&format.VP8{}},
},
{
Type: description.MediaTypeVideo,
Formats: []format.Format{&format.H264{}},
},
}}
n := 0
r := &stream.Reader{
Parent: test.Logger(func(l logger.Level, format string, args ...any) {
require.Equal(t, logger.Warn, l)
if n == 0 {
require.Equal(t, "skipping track 1 (VP8)", fmt.Sprintf(format, args...))
}
n++
}),
}
ln, err := net.Listen("tcp", "127.0.0.1:9121")
require.NoError(t, err)
defer ln.Close()
go func() {
u, err2 := url.Parse("rtmp://127.0.0.1:9121/stream")
require.NoError(t, err2)
c := &gortmplib.Client{
URL: u,
}
err2 = c.Initialize(context.Background())
require.NoError(t, err2)
}()
nconn, err := ln.Accept()
require.NoError(t, err)
defer nconn.Close()
conn := &gortmplib.ServerConn{
RW: nconn,
}
err = conn.Initialize()
require.NoError(t, err)
err = conn.Accept()
require.NoError(t, err)
err = FromStream(desc, r, conn, nil, 0)
require.NoError(t, err)
require.Equal(t, 1, n)
}
================================================
FILE: internal/protocols/rtmp/to_stream.go
================================================
package rtmp
import (
"errors"
"time"
"github.com/bluenviron/gortmplib"
"github.com/bluenviron/gortmplib/pkg/codecs"
"github.com/bluenviron/gortmplib/pkg/message"
"github.com/bluenviron/gortsplib/v5/pkg/description"
"github.com/bluenviron/gortsplib/v5/pkg/format"
"github.com/bluenviron/mediamtx/internal/stream"
"github.com/bluenviron/mediamtx/internal/unit"
)
var errNoSupportedCodecsTo = errors.New(
"the stream doesn't contain any supported codec, which are currently " +
"AV1, VP9, H265, H264, MPEG-4 Audio, MPEG-1/2 Audio, G711, LPCM")
func multiplyAndDivide(v, m, d int64) int64 {
secs := v / d
dec := v % d
return (secs*m + dec*m/d)
}
func durationToTimestamp(d time.Duration, clockRate int) int64 {
return multiplyAndDivide(int64(d), int64(clockRate), int64(time.Second))
}
func fourCCToString(c message.FourCC) string {
return string([]byte{byte(c >> 24), byte(c >> 16), byte(c >> 8), byte(c)})
}
// ToStream maps a RTMP stream to a MediaMTX stream.
func ToStream(
r *gortmplib.Reader,
subStream **stream.SubStream,
) ([]*description.Media, error) {
var medias []*description.Media
for _, track := range r.Tracks() {
switch codec := track.Codec.(type) {
case *codecs.AV1:
forma := &format.AV1{
PayloadTyp: 96,
}
medi := &description.Media{
Type: description.MediaTypeVideo,
Formats: []format.Format{forma},
}
medias = append(medias, medi)
r.OnDataAV1(track, func(pts time.Duration, tu [][]byte) {
(*subStream).WriteUnit(medi, forma, &unit.Unit{
PTS: durationToTimestamp(pts, forma.ClockRate()),
Payload: unit.PayloadAV1(tu),
})
})
case *codecs.VP9:
forma := &format.VP9{
PayloadTyp: 96,
}
medi := &description.Media{
Type: description.MediaTypeVideo,
Formats: []format.Format{forma},
}
medias = append(medias, medi)
r.OnDataVP9(track, func(pts time.Duration, frame []byte) {
(*subStream).WriteUnit(medi, forma, &unit.Unit{
PTS: durationToTimestamp(pts, forma.ClockRate()),
Payload: unit.PayloadVP9(frame),
})
})
case *codecs.H265:
forma := &format.H265{
PayloadTyp: 96,
VPS: codec.VPS,
SPS: codec.SPS,
PPS: codec.PPS,
}
medi := &description.Media{
Type: description.MediaTypeVideo,
Formats: []format.Format{forma},
}
medias = append(medias, medi)
r.OnDataH265(track, func(pts time.Duration, _ time.Duration, au [][]byte) {
(*subStream).WriteUnit(medi, forma, &unit.Unit{
PTS: durationToTimestamp(pts, forma.ClockRate()),
Payload: unit.PayloadH265(au),
})
})
case *codecs.H264:
forma := &format.H264{
PayloadTyp: 96,
SPS: codec.SPS,
PPS: codec.PPS,
PacketizationMode: 1,
}
medi := &description.Media{
Type: description.MediaTypeVideo,
Formats: []format.Format{forma},
}
medias = append(medias, medi)
r.OnDataH264(track, func(pts time.Duration, _ time.Duration, au [][]byte) {
(*subStream).WriteUnit(medi, forma, &unit.Unit{
PTS: durationToTimestamp(pts, forma.ClockRate()),
Payload: unit.PayloadH264(au),
})
})
case *codecs.Opus:
forma := &format.Opus{
PayloadTyp: 96,
ChannelCount: codec.ChannelCount,
}
medi := &description.Media{
Type: description.MediaTypeAudio,
Formats: []format.Format{forma},
}
medias = append(medias, medi)
r.OnDataOpus(track, func(pts time.Duration, packet []byte) {
(*subStream).WriteUnit(medi, forma, &unit.Unit{
PTS: durationToTimestamp(pts, forma.ClockRate()),
Payload: unit.PayloadOpus{packet},
})
})
case *codecs.MPEG4Audio:
forma := &format.MPEG4Audio{
PayloadTyp: 96,
Config: codec.Config,
SizeLength: 13,
IndexLength: 3,
IndexDeltaLength: 3,
}
medi := &description.Media{
Type: description.MediaTypeAudio,
Formats: []format.Format{forma},
}
medias = append(medias, medi)
r.OnDataMPEG4Audio(track, func(pts time.Duration, au []byte) {
(*subStream).WriteUnit(medi, forma, &unit.Unit{
PTS: durationToTimestamp(pts, forma.ClockRate()),
Payload: unit.PayloadMPEG4Audio{au},
})
})
case *codecs.MPEG1Audio:
forma := &format.MPEG1Audio{}
medi := &description.Media{
Type: description.MediaTypeAudio,
Formats: []format.Format{forma},
}
medias = append(medias, medi)
r.OnDataMPEG1Audio(track, func(pts time.Duration, frame []byte) {
(*subStream).WriteUnit(medi, forma, &unit.Unit{
PTS: durationToTimestamp(pts, forma.ClockRate()),
Payload: unit.PayloadMPEG1Audio{frame},
})
})
case *codecs.AC3:
forma := &format.AC3{
PayloadTyp: 96,
SampleRate: codec.SampleRate,
ChannelCount: codec.ChannelCount,
}
medi := &description.Media{
Type: description.MediaTypeAudio,
Formats: []format.Format{forma},
}
medias = append(medias, medi)
r.OnDataAC3(track, func(pts time.Duration, frame []byte) {
(*subStream).WriteUnit(medi, forma, &unit.Unit{
PTS: durationToTimestamp(pts, forma.ClockRate()),
Payload: unit.PayloadAC3{frame},
})
})
case *codecs.G711:
forma := &format.G711{
PayloadTyp: func() uint8 {
switch {
case codec.ChannelCount == 1 && codec.MULaw:
return 0
case codec.ChannelCount == 1 && !codec.MULaw:
return 8
default:
return 96
}
}(),
MULaw: codec.MULaw,
SampleRate: 8000,
ChannelCount: codec.ChannelCount,
}
medi := &description.Media{
Type: description.MediaTypeAudio,
Formats: []format.Format{forma},
}
medias = append(medias, medi)
r.OnDataG711(track, func(pts time.Duration, samples []byte) {
(*subStream).WriteUnit(medi, forma, &unit.Unit{
PTS: durationToTimestamp(pts, forma.ClockRate()),
Payload: unit.PayloadG711(samples),
})
})
case *codecs.LPCM:
forma := &format.LPCM{
PayloadTyp: 96,
BitDepth: codec.BitDepth,
SampleRate: codec.SampleRate,
ChannelCount: codec.ChannelCount,
}
medi := &description.Media{
Type: description.MediaTypeAudio,
Formats: []format.Format{forma},
}
medias = append(medias, medi)
r.OnDataLPCM(track, func(pts time.Duration, samples []byte) {
(*subStream).WriteUnit(medi, forma, &unit.Unit{
PTS: durationToTimestamp(pts, forma.ClockRate()),
Payload: unit.PayloadLPCM(samples),
})
})
default:
panic("should not happen")
}
}
if len(medias) == 0 {
return nil, errNoSupportedCodecsTo
}
return medias, nil
}
================================================
FILE: internal/protocols/rtmp/to_stream_test.go
================================================
package rtmp
import (
"testing"
"github.com/bluenviron/gortmplib"
"github.com/stretchr/testify/require"
)
func TestToStreamNoSupportedCodecs(t *testing.T) {
r := &gortmplib.Reader{}
_, err := ToStream(r, nil)
require.Equal(t, errNoSupportedCodecsTo, err)
}
// this is impossible to test since currently we support all RTMP tracks.
// func TestToStreamSkipUnsupportedTracks(t *testing.T)
================================================
FILE: internal/protocols/rtsp/credentials.go
================================================
package rtsp
import (
"github.com/bluenviron/gortsplib/v5/pkg/base"
"github.com/bluenviron/gortsplib/v5/pkg/headers"
"github.com/bluenviron/mediamtx/internal/auth"
)
// Credentials extracts credentials from a RTSP request.
func Credentials(rt *base.Request) *auth.Credentials {
c := &auth.Credentials{}
var rtspAuthHeader headers.Authorization
err := rtspAuthHeader.Unmarshal(rt.Header["Authorization"])
if err == nil {
c.User = rtspAuthHeader.Username
if rtspAuthHeader.Method == headers.AuthMethodBasic {
c.Pass = rtspAuthHeader.BasicPass
}
}
return c
}
================================================
FILE: internal/protocols/rtsp/credentials_test.go
================================================
package rtsp
import (
"testing"
"github.com/bluenviron/gortsplib/v5/pkg/base"
"github.com/bluenviron/mediamtx/internal/auth"
"github.com/stretchr/testify/require"
)
func TestCredentials(t *testing.T) {
rr := &base.Request{
Header: base.Header{
"Authorization": []string{
"Basic bXl1c2VyOm15cGFzcw==",
},
},
}
c := Credentials(rr)
require.Equal(t, &auth.Credentials{
User: "myuser",
Pass: "mypass",
}, c)
}
================================================
FILE: internal/protocols/rtsp/to_stream.go
================================================
// Package rtsp provides RTSP utilities.
package rtsp
import (
"time"
"github.com/bluenviron/gortsplib/v5"
"github.com/bluenviron/gortsplib/v5/pkg/description"
"github.com/bluenviron/gortsplib/v5/pkg/format"
"github.com/bluenviron/mediamtx/internal/conf"
"github.com/bluenviron/mediamtx/internal/logger"
"github.com/bluenviron/mediamtx/internal/stream"
"github.com/bluenviron/mediamtx/internal/unit"
"github.com/pion/rtp"
)
type ntpState int
const (
ntpStateInitial ntpState = iota
ntpStateReplace
ntpStateAvailable
)
type rtspSource interface {
PacketPTS(*description.Media, *rtp.Packet) (int64, bool)
PacketNTP(*description.Media, *rtp.Packet) (time.Time, bool)
OnPacketRTP(*description.Media, format.Format, gortsplib.OnPacketRTPFunc)
}
// ToStream maps a RTSP stream to a MediaMTX stream.
func ToStream(
source rtspSource,
medias []*description.Media,
pathConf *conf.Path,
subStream **stream.SubStream,
log logger.Writer,
) {
for _, medi := range medias {
for _, forma := range medi.Formats {
cmedi := medi
cforma := forma
var ntpStat ntpState
if !pathConf.UseAbsoluteTimestamp {
ntpStat = ntpStateReplace
}
handleNTP := func(pkt *rtp.Packet) (time.Time, bool) {
switch ntpStat {
case ntpStateReplace:
return time.Time{}, true
case ntpStateInitial:
ntp, avail := source.PacketNTP(cmedi, pkt)
if !avail {
log.Log(logger.Warn, "received RTP packet without absolute time, skipping it")
return time.Time{}, false
}
ntpStat = ntpStateAvailable
return ntp, true
default: // ntpStateAvailable
ntp, avail := source.PacketNTP(cmedi, pkt)
if !avail {
panic("should not happen")
}
return ntp, true
}
}
source.OnPacketRTP(cmedi, cforma, func(pkt *rtp.Packet) {
pts, ok := source.PacketPTS(cmedi, pkt)
if !ok {
return
}
ntp, ok := handleNTP(pkt)
if !ok {
return
}
(*subStream).WriteUnit(cmedi, cforma, &unit.Unit{
PTS: pts,
NTP: ntp,
RTPPackets: []*rtp.Packet{pkt},
})
})
}
}
}
================================================
FILE: internal/protocols/tls/make_config.go
================================================
// Package tls contains TLS utilities.
package tls //nolint:revive
import (
"crypto/sha256"
"crypto/tls"
"encoding/hex"
"fmt"
"strings"
)
// MakeConfig returns a tls.Config with:
// - server name indicator (SNI) support
// - fingerprint support
func MakeConfig(serverName string, fingerprint string) *tls.Config {
conf := &tls.Config{
ServerName: serverName,
}
if fingerprint != "" {
fingerprintLower := strings.ToLower(fingerprint)
conf.InsecureSkipVerify = true
conf.VerifyConnection = func(cs tls.ConnectionState) error {
h := sha256.New()
h.Write(cs.PeerCertificates[0].Raw)
hstr := hex.EncodeToString(h.Sum(nil))
if hstr != fingerprintLower {
return fmt.Errorf("source fingerprint does not match: expected %s, got %s",
fingerprintLower, hstr)
}
return nil
}
}
return conf
}
================================================
FILE: internal/protocols/tls/make_config_test.go
================================================
package tls //nolint:revive
import (
"crypto/tls"
"net"
"testing"
"github.com/stretchr/testify/require"
)
var testTLSCertPub = []byte(`-----BEGIN CERTIFICATE-----
MIIDazCCAlOgAwIBAgIUXw1hEC3LFpTsllv7D3ARJyEq7sIwDQYJKoZIhvcNAQEL
BQAwRTELMAkGA1UEBhMCQVUxEzARBgNVBAgMClNvbWUtU3RhdGUxITAfBgNVBAoM
GEludGVybmV0IFdpZGdpdHMgUHR5IEx0ZDAeFw0yMDEyMTMxNzQ0NThaFw0zMDEy
MTExNzQ0NThaMEUxCzAJBgNVBAYTAkFVMRMwEQYDVQQIDApTb21lLVN0YXRlMSEw
HwYDVQQKDBhJbnRlcm5ldCBXaWRnaXRzIFB0eSBMdGQwggEiMA0GCSqGSIb3DQEB
AQUAA4IBDwAwggEKAoIBAQDG8DyyS51810GsGwgWr5rjJK7OE1kTTLSNEEKax8Bj
zOyiaz8rA2JGl2VUEpi2UjDr9Cm7nd+YIEVs91IIBOb7LGqObBh1kGF3u5aZxLkv
NJE+HrLVvUhaDobK2NU+Wibqc/EI3DfUkt1rSINvv9flwTFu1qHeuLWhoySzDKEp
OzYxpFhwjVSokZIjT4Red3OtFz7gl2E6OAWe2qoh5CwLYVdMWtKR0Xuw3BkDPk9I
qkQKx3fqv97LPEzhyZYjDT5WvGrgZ1WDAN3booxXF3oA1H3GHQc4m/vcLatOtb8e
nI59gMQLEbnp08cl873bAuNuM95EZieXTHNbwUnq5iybAgMBAAGjUzBRMB0GA1Ud
DgQWBBQBKhJh8eWu0a4au9X/2fKhkFX2vjAfBgNVHSMEGDAWgBQBKhJh8eWu0a4a
u9X/2fKhkFX2vjAPBgNVHRMBAf8EBTADAQH/MA0GCSqGSIb3DQEBCwUAA4IBAQBj
3aCW0YPKukYgVK9cwN0IbVy/D0C1UPT4nupJcy/E0iC7MXPZ9D/SZxYQoAkdptdO
xfI+RXkpQZLdODNx9uvV+cHyZHZyjtE5ENu/i5Rer2cWI/mSLZm5lUQyx+0KZ2Yu
tEI1bsebDK30msa8QSTn0WidW9XhFnl3gRi4wRdimcQapOWYVs7ih+nAlSvng7NI
XpAyRs8PIEbpDDBMWnldrX4TP6EWYUi49gCp8OUDRREKX3l6Ls1vZ02F34yHIt/7
7IV/XSKG096bhW+icKBWV0IpcEsgTzPK1J1hMxgjhzIMxGboAeUU+kidthOob6Sd
XQxaORfgM//NzX9LhUPk
-----END CERTIFICATE-----
`)
var testTLSCertKey = []byte(`-----BEGIN RSA PRIVATE KEY-----
MIIEogIBAAKCAQEAxvA8skudfNdBrBsIFq+a4ySuzhNZE0y0jRBCmsfAY8zsoms/
KwNiRpdlVBKYtlIw6/Qpu53fmCBFbPdSCATm+yxqjmwYdZBhd7uWmcS5LzSRPh6y
1b1IWg6GytjVPlom6nPxCNw31JLda0iDb7/X5cExbtah3ri1oaMkswyhKTs2MaRY
cI1UqJGSI0+EXndzrRc+4JdhOjgFntqqIeQsC2FXTFrSkdF7sNwZAz5PSKpECsd3
6r/eyzxM4cmWIw0+Vrxq4GdVgwDd26KMVxd6ANR9xh0HOJv73C2rTrW/HpyOfYDE
CxG56dPHJfO92wLjbjPeRGYnl0xzW8FJ6uYsmwIDAQABAoIBACi0BKcyQ3HElSJC
kaAao+Uvnzh4yvPg8Nwf5JDIp/uDdTMyIEWLtrLczRWrjGVZYbsVROinP5VfnPTT
kYwkfKINj2u+gC6lsNuPnRuvHXikF8eO/mYvCTur1zZvsQnF5kp4GGwIqr+qoPUP
bB0UMndG1PdpoMryHe+JcrvTrLHDmCeH10TqOwMsQMLHYLkowvxwJWsmTY7/Qr5S
Wm3PPpOcW2i0uyPVuyuv4yD1368fqnqJ8QFsQp1K6QtYsNnJ71Hut1/IoxK/e6hj
5Z+byKtHVtmcLnABuoOT7BhleJNFBksX9sh83jid4tMBgci+zXNeGmgqo2EmaWAb
agQslkECgYEA8B1rzjOHVQx/vwSzDa4XOrpoHQRfyElrGNz9JVBvnoC7AorezBXQ
M9WTHQIFTGMjzD8pb+YJGi3gj93VN51r0SmJRxBaBRh1ZZI9kFiFzngYev8POgD3
ygmlS3kTHCNxCK/CJkB+/jMBgtPj5ygDpCWVcTSuWlQFphePkW7jaaECgYEA1Blz
ulqgAyJHZaqgcbcCsI2q6m527hVr9pjzNjIVmkwu38yS9RTCgdlbEVVDnS0hoifl
+jVMEGXjF3xjyMvL50BKbQUH+KAa+V4n1WGlnZOxX9TMny8MBjEuSX2+362vQ3BX
4vOlX00gvoc+sY+lrzvfx/OdPCHQGVYzoKCxhLsCgYA07HcviuIAV/HsO2/vyvhp
xF5gTu+BqNUHNOZDDDid+ge+Jre2yfQLCL8VPLXIQW3Jff53IH/PGl+NtjphuLvj
7UDJvgvpZZuymIojP6+2c3gJ3CASC9aR3JBnUzdoE1O9s2eaoMqc4scpe+SWtZYf
3vzSZ+cqF6zrD/Rf/M35IQKBgHTU4E6ShPm09CcoaeC5sp2WK8OevZw/6IyZi78a
r5Oiy18zzO97U/k6xVMy6F+38ILl/2Rn31JZDVJujniY6eSkIVsUHmPxrWoXV1HO
y++U32uuSFiXDcSLarfIsE992MEJLSAynbF1Rsgsr3gXbGiuToJRyxbIeVy7gwzD
94TpAoGAY4/PejWQj9psZfAhyk5dRGra++gYRQ/gK1IIc1g+Dd2/BxbT/RHr05GK
6vwrfjsoRyMWteC1SsNs/CurjfQ/jqCfHNP5XPvxgd5Ec8sRJIiV7V5RTuWJsPu1
+3K6cnKEyg+0ekYmLertRFIY6SwWmY1fyKgTvxudMcsBY7dC4xs=
-----END RSA PRIVATE KEY-----
`)
func TestMakeConfigSNI(t *testing.T) {
l, err := net.Listen("tcp", "localhost:8556")
require.NoError(t, err)
defer l.Close()
serverDone := make(chan struct{})
defer func() { <-serverDone }()
go func() {
defer close(serverDone)
nconn, err2 := l.Accept()
require.NoError(t, err2)
defer nconn.Close()
cert, err2 := tls.X509KeyPair(testTLSCertPub, testTLSCertKey)
require.NoError(t, err2)
tnconn := tls.Server(nconn, &tls.Config{
Certificates: []tls.Certificate{cert},
InsecureSkipVerify: true,
VerifyConnection: func(cs tls.ConnectionState) error {
require.Equal(t, "myhost", cs.ServerName)
return nil
},
})
err2 = tnconn.Handshake()
require.EqualError(t, err2, "remote error: tls: bad certificate")
}()
conf := MakeConfig("myhost", "")
_, err = tls.Dial("tcp", "localhost:8556", conf)
require.EqualError(t, err, "tls: failed to verify certificate: x509: "+
"certificate is not valid for any names, but wanted to match myhost")
}
func TestMakeConfigFingerprint(t *testing.T) {
l, err := net.Listen("tcp", "localhost:8556")
require.NoError(t, err)
defer l.Close()
serverDone := make(chan struct{})
defer func() { <-serverDone }()
go func() {
defer close(serverDone)
nconn, err2 := l.Accept()
require.NoError(t, err2)
defer nconn.Close()
cert, err2 := tls.X509KeyPair(testTLSCertPub, testTLSCertKey)
require.NoError(t, err2)
tnconn := tls.Server(nconn, &tls.Config{
Certificates: []tls.Certificate{cert},
InsecureSkipVerify: true,
VerifyConnection: func(cs tls.ConnectionState) error {
require.Equal(t, "myhost", cs.ServerName)
return nil
},
})
err2 = tnconn.Handshake()
require.NoError(t, err2)
}()
conf := MakeConfig("myhost", "33949e05fffb5ff3e8aa16f8213a6251b4d9363804ba53233c4da9a46d6f2739")
conn, err := tls.Dial("tcp", "localhost:8556", conf)
require.NoError(t, err)
defer conn.Close() //nolint:errcheck
}
================================================
FILE: internal/protocols/udp/listener.go
================================================
// Package udp contains utilities to work with the UDP protocol.
package udp
import (
"fmt"
"net"
"syscall"
"time"
"github.com/bluenviron/gortsplib/v5/pkg/multicast"
"github.com/bluenviron/gortsplib/v5/pkg/readbuffer"
"github.com/bluenviron/mediamtx/internal/restrictnetwork"
)
type packetConn interface {
net.PacketConn
SetReadBuffer(bytes int) error
SyscallConn() (syscall.RawConn, error)
}
func defaultInterfaceForMulticast(multicastAddr *net.UDPAddr) (*net.Interface, error) {
conn, err := net.Dial("udp4", multicastAddr.String())
if err != nil {
return nil, err
}
localAddr := conn.LocalAddr().(*net.UDPAddr)
conn.Close()
interfaces, err := net.Interfaces()
if err != nil {
return nil, err
}
for _, iface := range interfaces {
var addrs []net.Addr
addrs, err = iface.Addrs()
if err != nil {
continue
}
for _, addr := range addrs {
var ip net.IP
switch v := addr.(type) {
case *net.IPNet:
ip = v.IP
case *net.IPAddr:
ip = v.IP
}
if ip != nil && ip.Equal(localAddr.IP) {
return &iface, nil
}
}
}
return nil, fmt.Errorf("could not find any interface for using multicast address %s", multicastAddr)
}
// Listener is a listener on a UDP socket.
type Listener struct {
Address string
Source string
IntfName string
UDPReadBufferSize int
ListenPacket func(network, address string) (net.PacketConn, error)
pc packetConn
sourceIP net.IP
}
// Initialize initializes the listener.
func (l *Listener) Initialize() error {
if l.ListenPacket == nil {
l.ListenPacket = net.ListenPacket
}
if l.Source != "" {
l.sourceIP = net.ParseIP(l.Source)
if l.sourceIP == nil {
return fmt.Errorf("invalid source IP")
}
}
addr, err := net.ResolveUDPAddr("udp", l.Address)
if err != nil {
return err
}
if ip4 := addr.IP.To4(); ip4 != nil && addr.IP.IsMulticast() {
var intf *net.Interface
if l.IntfName != "" {
intf, err = net.InterfaceByName(l.IntfName)
if err != nil {
return err
}
} else {
intf, err = defaultInterfaceForMulticast(addr)
if err != nil {
return err
}
}
l.pc, err = multicast.NewSingleConn(intf, addr.String(), l.ListenPacket)
if err != nil {
return err
}
} else {
var tmp net.PacketConn
tmp, err = l.ListenPacket(restrictnetwork.Restrict("udp", addr.String()))
if err != nil {
return err
}
l.pc = tmp.(packetConn)
}
if l.UDPReadBufferSize != 0 {
err = readbuffer.SetReadBuffer(l.pc, l.UDPReadBufferSize)
if err != nil {
l.pc.Close()
return err
}
}
return nil
}
// Close closes the listener.
func (l *Listener) Close() error {
return l.pc.Close()
}
// Read implements net.Conn.
func (l *Listener) Read(p []byte) (int, error) {
for {
n, addr, err := l.pc.ReadFrom(p)
if l.sourceIP != nil && addr != nil && !addr.(*net.UDPAddr).IP.Equal(l.sourceIP) {
continue
}
return n, err
}
}
// Write implements net.Conn.
func (l *Listener) Write(_ []byte) (int, error) {
panic("unimplemented")
}
// LocalAddr implements net.Conn.
func (l *Listener) LocalAddr() net.Addr {
panic("unimplemented")
}
// RemoteAddr implements net.Conn.
func (l *Listener) RemoteAddr() net.Addr {
panic("unimplemented")
}
// SetDeadline implements net.Conn.
func (l *Listener) SetDeadline(_ time.Time) error {
panic("unimplemented")
}
// SetReadDeadline implements net.Conn.
func (l *Listener) SetReadDeadline(t time.Time) error {
return l.pc.SetReadDeadline(t)
}
// SetWriteDeadline implements net.Conn.
func (l *Listener) SetWriteDeadline(_ time.Time) error {
panic("unimplemented")
}
================================================
FILE: internal/protocols/udp/listener_test.go
================================================
package udp
import (
"net"
"testing"
"time"
"github.com/stretchr/testify/require"
)
func TestListen(t *testing.T) {
l := &Listener{
Address: "127.0.0.1:0",
UDPReadBufferSize: 4096,
}
err := l.Initialize()
require.NoError(t, err)
defer l.Close() //nolint:errcheck
done := make(chan struct{})
go func() {
defer close(done)
err2 := l.SetReadDeadline(time.Now().Add(2 * time.Second))
require.NoError(t, err2)
buf := make([]byte, 1024)
n, err2 := l.Read(buf)
require.NoError(t, err2)
require.Equal(t, []byte("testing"), buf[:n])
}()
localAddr := l.pc.LocalAddr().(*net.UDPAddr)
clientConn, err := net.DialUDP("udp", nil, localAddr)
require.NoError(t, err)
defer clientConn.Close() //nolint:errcheck
_, err = clientConn.Write([]byte("testing"))
require.NoError(t, err)
<-done
}
================================================
FILE: internal/protocols/udp/params.go
================================================
package udp
import "net/url"
// Params are the parameters of a UDP listener.
type Params struct {
Address string
Source string
IntfName string
}
// URLToParams converts a URL to Params.
func URLToParams(u *url.URL) *Params {
return &Params{
Address: u.Host,
Source: u.Query().Get("source"),
IntfName: u.Query().Get("interface"),
}
}
================================================
FILE: internal/protocols/unix/listener.go
================================================
// Package unix contains utilities to work with Unix sockets.
package unix
import (
"fmt"
"net"
"os"
"sync"
"time"
)
// Listener is a listener on a Unix socket.
type Listener struct {
Path string
l net.Listener
c net.Conn
mutex sync.Mutex
closed bool
deadline time.Time
}
// Initialize initializes the listener.
func (l *Listener) Initialize() error {
if l.Path == "" {
return fmt.Errorf("invalid unix path")
}
os.Remove(l.Path)
var err error
l.l, err = net.Listen("unix", l.Path)
if err != nil {
return err
}
return nil
}
// Close closes the listener.
func (l *Listener) Close() error {
l.mutex.Lock()
defer l.mutex.Unlock()
l.closed = true
l.l.Close()
if l.c != nil {
l.c.Close()
}
return nil
}
func (l *Listener) acceptWithDeadline() (net.Conn, error) {
done := make(chan struct{})
defer func() { <-done }()
terminate := make(chan struct{})
defer close(terminate)
go func() {
defer close(done)
select {
case <-time.After(time.Until(l.deadline)):
l.l.Close()
case <-terminate:
return
}
}()
c, err := l.l.Accept()
if err != nil {
if time.Now().After(l.deadline) {
return nil, fmt.Errorf("deadline exceeded")
}
return nil, err
}
return c, nil
}
func (l *Listener) setConn(c net.Conn) error {
l.mutex.Lock()
defer l.mutex.Unlock()
if l.closed {
return fmt.Errorf("closed")
}
l.c = c
return nil
}
func (l *Listener) Read(p []byte) (int, error) {
if l.c == nil {
c, err := l.acceptWithDeadline()
if err != nil {
return 0, err
}
err = l.setConn(c)
if err != nil {
return 0, err
}
}
l.c.SetReadDeadline(l.deadline)
return l.c.Read(p)
}
// Write implements net.Conn.
func (l *Listener) Write(_ []byte) (int, error) {
panic("unimplemented")
}
// LocalAddr implements net.Conn.
func (l *Listener) LocalAddr() net.Addr {
panic("unimplemented")
}
// RemoteAddr implements net.Conn.
func (l *Listener) RemoteAddr() net.Addr {
panic("unimplemented")
}
// SetDeadline implements net.Conn.
func (l *Listener) SetDeadline(_ time.Time) error {
panic("unimplemented")
}
// SetReadDeadline implements net.Conn.
func (l *Listener) SetReadDeadline(t time.Time) error {
l.deadline = t
return nil
}
// SetWriteDeadline implements net.Conn.
func (l *Listener) SetWriteDeadline(_ time.Time) error {
panic("unimplemented")
}
================================================
FILE: internal/protocols/unix/listener_test.go
================================================
package unix
import (
"net"
"os"
"testing"
"time"
"github.com/stretchr/testify/require"
)
func TestListen(t *testing.T) {
socket, err := os.CreateTemp(os.TempDir(), "mtx-unix-")
require.NoError(t, err)
socket.Close()
defer os.Remove(socket.Name())
l := &Listener{
Path: socket.Name(),
}
err = l.Initialize()
require.NoError(t, err)
defer l.Close() //nolint:errcheck
done := make(chan struct{})
go func() {
defer close(done)
buf := make([]byte, 1024)
l.SetReadDeadline(time.Now().Add(2 * time.Second)) //nolint:errcheck
n, err2 := l.Read(buf)
require.NoError(t, err2)
require.Equal(t, []byte("testing"), buf[:n])
}()
clientAddr, err := net.ResolveUnixAddr("unix", socket.Name())
require.NoError(t, err)
clientConn, err := net.DialUnix("unix", nil, clientAddr)
require.NoError(t, err)
defer clientConn.Close() //nolint:errcheck
_, err = clientConn.Write([]byte("testing"))
require.NoError(t, err)
<-done
}
================================================
FILE: internal/protocols/unix/params.go
================================================
package unix
import "net/url"
// Params are the parameters of a unix listener.
type Params struct {
Path string
}
// URLToParams converts a URL to Params.
func URLToParams(u *url.URL) *Params {
var pa string
if u.Path != "" {
pa = u.Path
} else {
pa = u.Host
}
return &Params{
Path: pa,
}
}
================================================
FILE: internal/protocols/webrtc/from_stream.go
================================================
package webrtc
import (
"crypto/rand"
"errors"
"fmt"
"slices"
"time"
"github.com/bluenviron/gortsplib/v5/pkg/description"
"github.com/bluenviron/gortsplib/v5/pkg/format"
"github.com/bluenviron/gortsplib/v5/pkg/format/rtpav1"
"github.com/bluenviron/gortsplib/v5/pkg/format/rtph264"
"github.com/bluenviron/gortsplib/v5/pkg/format/rtph265"
"github.com/bluenviron/gortsplib/v5/pkg/format/rtplpcm"
"github.com/bluenviron/gortsplib/v5/pkg/format/rtpvp8"
"github.com/bluenviron/gortsplib/v5/pkg/format/rtpvp9"
"github.com/bluenviron/mediacommon/v2/pkg/codecs/g711"
"github.com/bluenviron/mediacommon/v2/pkg/codecs/opus"
"github.com/bluenviron/mediamtx/internal/logger"
"github.com/bluenviron/mediamtx/internal/stream"
"github.com/bluenviron/mediamtx/internal/unit"
"github.com/pion/rtp"
"github.com/pion/webrtc/v4"
)
const (
webrtcPayloadMaxSize = 1188 // 1200 - 12 (RTP header)
)
var multichannelOpusSDP = map[int]string{
3: "channel_mapping=0,2,1;num_streams=2;coupled_streams=1",
4: "channel_mapping=0,1,2,3;num_streams=2;coupled_streams=2",
5: "channel_mapping=0,4,1,2,3;num_streams=3;coupled_streams=2",
6: "channel_mapping=0,4,1,2,3,5;num_streams=4;coupled_streams=2",
7: "channel_mapping=0,4,1,2,3,5,6;num_streams=4;coupled_streams=4",
8: "channel_mapping=0,6,1,4,5,2,3,7;num_streams=5;coupled_streams=4",
}
var errNoSupportedCodecsFrom = errors.New(
"the stream doesn't contain any supported codec, which are currently " +
"AV1, VP9, VP8, H265, H264, Opus, G722, G711, LPCM")
func ptrOf[T any](v T) *T {
p := new(T)
*p = v
return p
}
func randUint32() (uint32, error) {
var b [4]byte
_, err := rand.Read(b[:])
if err != nil {
return 0, err
}
return uint32(b[0])<<24 | uint32(b[1])<<16 | uint32(b[2])<<8 | uint32(b[3]), nil
}
func multiplyAndDivide2(v, m, d time.Duration) time.Duration {
secs := v / d
dec := v % d
return (secs*m + dec*m/d)
}
func timestampToDuration(t int64, clockRate int) time.Duration {
return multiplyAndDivide2(time.Duration(t), time.Second, time.Duration(clockRate))
}
func setupVideoTrack(
desc *description.Session,
r *stream.Reader,
) (*OutgoingTrack, error) {
var av1Format *format.AV1
media := desc.FindFormat(&av1Format)
if av1Format != nil { //nolint:dupl
track := &OutgoingTrack{
Caps: webrtc.RTPCodecCapability{
MimeType: webrtc.MimeTypeAV1,
ClockRate: 90000,
},
}
encoder := &rtpav1.Encoder{
PayloadType: 105,
PayloadMaxSize: webrtcPayloadMaxSize,
}
err := encoder.Init()
if err != nil {
return nil, err
}
r.OnData(
media,
av1Format,
func(u *unit.Unit) error {
if u.NilPayload() {
return nil
}
packets, err2 := encoder.Encode(u.Payload.(unit.PayloadAV1))
if err2 != nil {
return nil //nolint:nilerr
}
for _, pkt := range packets {
ntp := u.NTP.Add(timestampToDuration(int64(pkt.Timestamp), 90000))
pkt.Timestamp += u.RTPPackets[0].Timestamp
track.WriteRTPWithNTP(pkt, ntp) //nolint:errcheck
}
return nil
})
return track, nil
}
var vp9Format *format.VP9
media = desc.FindFormat(&vp9Format)
if vp9Format != nil {
track := &OutgoingTrack{
Caps: webrtc.RTPCodecCapability{
MimeType: webrtc.MimeTypeVP9,
ClockRate: 90000,
SDPFmtpLine: "profile-id=0",
},
}
encoder := &rtpvp9.Encoder{
PayloadType: 96,
PayloadMaxSize: webrtcPayloadMaxSize,
InitialPictureID: ptrOf(uint16(8445)),
}
err := encoder.Init()
if err != nil {
return nil, err
}
r.OnData(
media,
vp9Format,
func(u *unit.Unit) error {
if u.NilPayload() {
return nil
}
packets, err2 := encoder.Encode(u.Payload.(unit.PayloadVP9))
if err2 != nil {
return nil //nolint:nilerr
}
for _, pkt := range packets {
ntp := u.NTP.Add(timestampToDuration(int64(pkt.Timestamp), 90000))
pkt.Timestamp += u.RTPPackets[0].Timestamp
track.WriteRTPWithNTP(pkt, ntp) //nolint:errcheck
}
return nil
})
return track, nil
}
var vp8Format *format.VP8
media = desc.FindFormat(&vp8Format)
if vp8Format != nil { //nolint:dupl
track := &OutgoingTrack{
Caps: webrtc.RTPCodecCapability{
MimeType: webrtc.MimeTypeVP8,
ClockRate: 90000,
},
}
encoder := &rtpvp8.Encoder{
PayloadType: 96,
PayloadMaxSize: webrtcPayloadMaxSize,
}
err := encoder.Init()
if err != nil {
return nil, err
}
r.OnData(
media,
vp8Format,
func(u *unit.Unit) error {
if u.NilPayload() {
return nil
}
packets, err2 := encoder.Encode(u.Payload.(unit.PayloadVP8))
if err2 != nil {
return nil //nolint:nilerr
}
for _, pkt := range packets {
ntp := u.NTP.Add(timestampToDuration(int64(pkt.Timestamp), 90000))
pkt.Timestamp += u.RTPPackets[0].Timestamp
track.WriteRTPWithNTP(pkt, ntp) //nolint:errcheck
}
return nil
})
return track, nil
}
var h265Format *format.H265
media = desc.FindFormat(&h265Format)
if h265Format != nil { //nolint:dupl
track := &OutgoingTrack{
Caps: webrtc.RTPCodecCapability{
MimeType: webrtc.MimeTypeH265,
ClockRate: 90000,
SDPFmtpLine: "level-id=93;profile-id=1;tier-flag=0;tx-mode=SRST",
},
}
encoder := &rtph265.Encoder{
PayloadType: 96,
PayloadMaxSize: webrtcPayloadMaxSize,
}
err := encoder.Init()
if err != nil {
return nil, err
}
firstReceived := false
var lastPTS int64
r.OnData(
media,
h265Format,
func(u *unit.Unit) error {
if u.NilPayload() {
return nil
}
if !firstReceived {
firstReceived = true
} else if u.PTS < lastPTS {
return fmt.Errorf("WebRTC doesn't support H265 streams with B-frames")
}
lastPTS = u.PTS
packets, err2 := encoder.Encode(u.Payload.(unit.PayloadH265))
if err2 != nil {
return nil //nolint:nilerr
}
for _, pkt := range packets {
ntp := u.NTP.Add(timestampToDuration(int64(pkt.Timestamp), 90000))
pkt.Timestamp += u.RTPPackets[0].Timestamp
track.WriteRTPWithNTP(pkt, ntp) //nolint:errcheck
}
return nil
})
return track, nil
}
var h264Format *format.H264
media = desc.FindFormat(&h264Format)
if h264Format != nil { //nolint:dupl
track := &OutgoingTrack{
Caps: webrtc.RTPCodecCapability{
MimeType: webrtc.MimeTypeH264,
ClockRate: 90000,
SDPFmtpLine: "level-asymmetry-allowed=1;packetization-mode=1;profile-level-id=42e01f",
},
}
encoder := &rtph264.Encoder{
PayloadType: 96,
PayloadMaxSize: webrtcPayloadMaxSize,
}
err := encoder.Init()
if err != nil {
return nil, err
}
firstReceived := false
var lastPTS int64
r.OnData(
media,
h264Format,
func(u *unit.Unit) error {
if u.NilPayload() {
return nil
}
if !firstReceived {
firstReceived = true
} else if u.PTS < lastPTS {
return fmt.Errorf("WebRTC doesn't support H264 streams with B-frames")
}
lastPTS = u.PTS
packets, err2 := encoder.Encode(u.Payload.(unit.PayloadH264))
if err2 != nil {
return nil //nolint:nilerr
}
for _, pkt := range packets {
ntp := u.NTP.Add(timestampToDuration(int64(pkt.Timestamp), 90000))
pkt.Timestamp += u.RTPPackets[0].Timestamp
track.WriteRTPWithNTP(pkt, ntp) //nolint:errcheck
}
return nil
})
return track, nil
}
return nil, nil
}
func setupAudioTrack(
desc *description.Session,
r *stream.Reader,
) (*OutgoingTrack, error) {
var opusFormat *format.Opus
media := desc.FindFormat(&opusFormat)
if opusFormat != nil {
var caps webrtc.RTPCodecCapability
switch opusFormat.ChannelCount {
case 1, 2:
caps = webrtc.RTPCodecCapability{
MimeType: webrtc.MimeTypeOpus,
ClockRate: 48000,
Channels: 2,
SDPFmtpLine: func() string {
s := "minptime=10;useinbandfec=1"
if opusFormat.ChannelCount == 2 {
s += ";stereo=1;sprop-stereo=1"
}
return s
}(),
}
case 3, 4, 5, 6, 7, 8:
caps = webrtc.RTPCodecCapability{
MimeType: mimeTypeMultiopus,
ClockRate: 48000,
Channels: uint16(opusFormat.ChannelCount),
SDPFmtpLine: multichannelOpusSDP[opusFormat.ChannelCount],
}
default:
return nil, fmt.Errorf("unsupported channel count: %d", opusFormat.ChannelCount)
}
track := &OutgoingTrack{
Caps: caps,
}
curTimestamp, err := randUint32()
if err != nil {
return nil, err
}
r.OnData(
media,
opusFormat,
func(u *unit.Unit) error {
for _, orig := range u.RTPPackets {
pkt := &rtp.Packet{
Header: orig.Header,
Payload: orig.Payload,
}
// recompute timestamp from scratch.
// Chrome requires a precise timestamp that FFmpeg doesn't provide.
pkt.Timestamp = curTimestamp
curTimestamp += uint32(opus.PacketDuration2(pkt.Payload))
ntp := u.NTP.Add(timestampToDuration(int64(pkt.Timestamp-u.RTPPackets[0].Timestamp), 48000))
track.WriteRTPWithNTP(pkt, ntp) //nolint:errcheck
}
return nil
})
return track, nil
}
var g722Format *format.G722
media = desc.FindFormat(&g722Format)
if g722Format != nil {
track := &OutgoingTrack{
Caps: webrtc.RTPCodecCapability{
MimeType: webrtc.MimeTypeG722,
ClockRate: 8000,
},
}
r.OnData(
media,
g722Format,
func(u *unit.Unit) error {
for _, pkt := range u.RTPPackets {
ntp := u.NTP.Add(timestampToDuration(int64(pkt.Timestamp-u.RTPPackets[0].Timestamp), 8000))
track.WriteRTPWithNTP(pkt, ntp) //nolint:errcheck
}
return nil
})
return track, nil
}
var g711Format *format.G711
media = desc.FindFormat(&g711Format)
if g711Format != nil {
// These are the sample rates and channels supported by Chrome.
// Different sample rates and channels can be streamed too but we don't want compatibility issues.
// https://webrtc.googlesource.com/src/+/refs/heads/main/modules/audio_coding/codecs/pcm16b/audio_decoder_pcm16b.cc#23
if g711Format.ClockRate() != 8000 && g711Format.ClockRate() != 16000 &&
g711Format.ClockRate() != 32000 && g711Format.ClockRate() != 48000 {
return nil, fmt.Errorf("unsupported clock rate: %d", g711Format.ClockRate())
}
if g711Format.ChannelCount != 1 && g711Format.ChannelCount != 2 {
return nil, fmt.Errorf("unsupported channel count: %d", g711Format.ChannelCount)
}
var caps webrtc.RTPCodecCapability
if g711Format.ClockRate() == 8000 {
if g711Format.MULaw {
if g711Format.ChannelCount != 1 {
caps = webrtc.RTPCodecCapability{
MimeType: webrtc.MimeTypePCMU,
ClockRate: uint32(g711Format.ClockRate()),
Channels: uint16(g711Format.ChannelCount),
}
} else {
caps = webrtc.RTPCodecCapability{
MimeType: webrtc.MimeTypePCMU,
ClockRate: 8000,
}
}
} else {
if g711Format.ChannelCount != 1 {
caps = webrtc.RTPCodecCapability{
MimeType: webrtc.MimeTypePCMA,
ClockRate: uint32(g711Format.ClockRate()),
Channels: uint16(g711Format.ChannelCount),
}
} else {
caps = webrtc.RTPCodecCapability{
MimeType: webrtc.MimeTypePCMA,
ClockRate: 8000,
}
}
}
} else {
caps = webrtc.RTPCodecCapability{
MimeType: mimeTypeL16,
ClockRate: uint32(g711Format.ClockRate()),
Channels: uint16(g711Format.ChannelCount),
}
}
track := &OutgoingTrack{
Caps: caps,
}
if g711Format.ClockRate() == 8000 {
curTimestamp, err := randUint32()
if err != nil {
return nil, err
}
r.OnData(
media,
g711Format,
func(u *unit.Unit) error {
for _, orig := range u.RTPPackets {
pkt := &rtp.Packet{
Header: orig.Header,
Payload: orig.Payload,
}
// recompute timestamp from scratch.
// Chrome requires a precise timestamp that FFmpeg doesn't provide.
pkt.Timestamp = curTimestamp
curTimestamp += uint32(len(pkt.Payload)) / uint32(g711Format.ChannelCount)
ntp := u.NTP.Add(timestampToDuration(int64(pkt.Timestamp-u.RTPPackets[0].Timestamp), 8000))
track.WriteRTPWithNTP(pkt, ntp) //nolint:errcheck
}
return nil
})
} else {
encoder := &rtplpcm.Encoder{
PayloadType: 96,
PayloadMaxSize: webrtcPayloadMaxSize,
BitDepth: 16,
ChannelCount: g711Format.ChannelCount,
}
err := encoder.Init()
if err != nil {
return nil, err
}
curTimestamp, err := randUint32()
if err != nil {
return nil, err
}
r.OnData(
media,
g711Format,
func(u *unit.Unit) error {
if u.NilPayload() {
return nil
}
var lpcm []byte
if g711Format.MULaw {
var mu g711.Mulaw
mu.Unmarshal(u.Payload.(unit.PayloadG711))
lpcm = mu
} else {
var al g711.Alaw
al.Unmarshal(u.Payload.(unit.PayloadG711))
lpcm = al
}
packets, err2 := encoder.Encode(lpcm)
if err2 != nil {
return nil //nolint:nilerr
}
for _, pkt := range packets {
// recompute timestamp from scratch.
// Chrome requires a precise timestamp that FFmpeg doesn't provide.
pkt.Timestamp = curTimestamp
curTimestamp += uint32(len(pkt.Payload)) / 2 / uint32(g711Format.ChannelCount)
ntp := u.NTP.Add(timestampToDuration(int64(pkt.Timestamp-u.RTPPackets[0].Timestamp),
g711Format.ClockRate()))
track.WriteRTPWithNTP(pkt, ntp) //nolint:errcheck
}
return nil
})
}
return track, nil
}
var lpcmFormat *format.LPCM
media = desc.FindFormat(&lpcmFormat)
if lpcmFormat != nil {
if lpcmFormat.BitDepth != 16 {
return nil, fmt.Errorf("unsupported LPCM bit depth: %d", lpcmFormat.BitDepth)
}
// These are the sample rates and channels supported by Chrome.
// Different sample rates and channels can be streamed too but we don't want compatibility issues.
// https://webrtc.googlesource.com/src/+/refs/heads/main/modules/audio_coding/codecs/pcm16b/audio_decoder_pcm16b.cc#23
if lpcmFormat.ClockRate() != 8000 && lpcmFormat.ClockRate() != 16000 &&
lpcmFormat.ClockRate() != 32000 && lpcmFormat.ClockRate() != 48000 {
return nil, fmt.Errorf("unsupported clock rate: %d", lpcmFormat.ClockRate())
}
if lpcmFormat.ChannelCount != 1 && lpcmFormat.ChannelCount != 2 {
return nil, fmt.Errorf("unsupported channel count: %d", lpcmFormat.ChannelCount)
}
track := &OutgoingTrack{
Caps: webrtc.RTPCodecCapability{
MimeType: mimeTypeL16,
ClockRate: uint32(lpcmFormat.ClockRate()),
Channels: uint16(lpcmFormat.ChannelCount),
},
}
encoder := &rtplpcm.Encoder{
PayloadType: 96,
BitDepth: 16,
ChannelCount: lpcmFormat.ChannelCount,
PayloadMaxSize: webrtcPayloadMaxSize,
}
err := encoder.Init()
if err != nil {
return nil, err
}
curTimestamp, err := randUint32()
if err != nil {
return nil, err
}
r.OnData(
media,
lpcmFormat,
func(u *unit.Unit) error {
if u.NilPayload() {
return nil
}
packets, err2 := encoder.Encode(u.Payload.(unit.PayloadLPCM))
if err2 != nil {
return nil //nolint:nilerr
}
for _, pkt := range packets {
// recompute timestamp from scratch.
// Chrome requires a precise timestamp that FFmpeg doesn't provide.
pkt.Timestamp = curTimestamp
curTimestamp += uint32(len(pkt.Payload)) / 2 / uint32(lpcmFormat.ChannelCount)
ntp := u.NTP.Add(timestampToDuration(int64(pkt.Timestamp-u.RTPPackets[0].Timestamp),
lpcmFormat.ClockRate()))
track.WriteRTPWithNTP(pkt, ntp) //nolint:errcheck
}
return nil
})
return track, nil
}
return nil, nil
}
func setupKLVDataChannel(
desc *description.Session,
r *stream.Reader,
) (*OutgoingDataChannel, error) {
var klvFormat *format.KLV
media := desc.FindFormat(&klvFormat)
if klvFormat != nil {
dataChan := &OutgoingDataChannel{
Label: "KLV",
}
r.OnData(
media,
klvFormat,
func(u *unit.Unit) error {
if u.NilPayload() {
return nil
}
dataChan.Write(u.Payload.(unit.PayloadKLV))
return nil
})
return dataChan, nil
}
return nil, nil
}
// FromStream maps a MediaMTX stream to a WebRTC connection
func FromStream(
desc *description.Session,
r *stream.Reader,
pc *PeerConnection,
) error {
videoTrack, err := setupVideoTrack(desc, r)
if err != nil {
return err
}
if videoTrack != nil {
pc.OutgoingTracks = append(pc.OutgoingTracks, videoTrack)
}
audioTrack, err := setupAudioTrack(desc, r)
if err != nil {
return err
}
if audioTrack != nil {
pc.OutgoingTracks = append(pc.OutgoingTracks, audioTrack)
}
klvDataChan, err := setupKLVDataChannel(desc, r)
if err != nil {
return err
}
if klvDataChan != nil {
pc.OutgoingDataChannels = append(pc.OutgoingDataChannels, klvDataChan)
}
if len(pc.OutgoingTracks) == 0 && len(pc.OutgoingDataChannels) == 0 {
return errNoSupportedCodecsFrom
}
setuppedFormats := r.Formats()
n := 1
for _, media := range desc.Medias {
for _, forma := range media.Formats {
if !slices.Contains(setuppedFormats, forma) {
r.Parent.Log(logger.Warn, "skipping track %d (%s)", n, forma.Codec())
}
n++
}
}
return nil
}
================================================
FILE: internal/protocols/webrtc/from_stream_test.go
================================================
package webrtc
import (
"fmt"
"testing"
"time"
"github.com/bluenviron/gortsplib/v5/pkg/description"
"github.com/bluenviron/gortsplib/v5/pkg/format"
"github.com/bluenviron/mediamtx/internal/logger"
"github.com/bluenviron/mediamtx/internal/stream"
"github.com/bluenviron/mediamtx/internal/test"
"github.com/bluenviron/mediamtx/internal/unit"
"github.com/pion/rtp"
"github.com/stretchr/testify/require"
)
func TestFromStreamNoSupportedCodecs(t *testing.T) {
desc := &description.Session{Medias: []*description.Media{{
Type: description.MediaTypeVideo,
Formats: []format.Format{&format.MJPEG{}},
}}}
r := &stream.Reader{
Parent: test.Logger(func(logger.Level, string, ...any) {
t.Error("should not happen")
}),
}
pc := &PeerConnection{}
err := FromStream(desc, r, pc)
require.Equal(t, errNoSupportedCodecsFrom, err)
}
func TestFromStreamSkipUnsupportedTracks(t *testing.T) {
desc := &description.Session{Medias: []*description.Media{
{
Type: description.MediaTypeVideo,
Formats: []format.Format{&format.H264{}},
},
{
Type: description.MediaTypeVideo,
Formats: []format.Format{&format.MJPEG{}},
},
}}
n := 0
r := &stream.Reader{
Parent: test.Logger(func(l logger.Level, format string, args ...any) {
require.Equal(t, logger.Warn, l)
if n == 0 {
require.Equal(t, "skipping track 2 (M-JPEG)", fmt.Sprintf(format, args...))
}
n++
}),
}
pc := &PeerConnection{}
err := FromStream(desc, r, pc)
require.NoError(t, err)
require.Equal(t, 1, n)
}
func TestFromStream(t *testing.T) {
for _, ca := range toFromStreamCases {
t.Run(ca.name, func(t *testing.T) {
desc := &description.Session{
Medias: []*description.Media{{
Formats: []format.Format{ca.in},
}},
}
pc := &PeerConnection{}
r := &stream.Reader{Parent: test.NilLogger}
err := FromStream(desc, r, pc)
require.NoError(t, err)
require.Equal(t, ca.webrtcCaps, pc.OutgoingTracks[0].Caps)
})
}
}
func TestFromStreamResampleOpus(t *testing.T) {
strm := &stream.Stream{
Desc: &description.Session{Medias: []*description.Media{
{
Type: description.MediaTypeAudio,
Formats: []format.Format{&format.Opus{
ChannelCount: 2,
}},
},
}},
WriteQueueSize: 512,
RTPMaxPayloadSize: 1450,
ReplaceNTP: false,
Parent: test.NilLogger,
}
err := strm.Initialize()
require.NoError(t, err)
subStream := &stream.SubStream{
Stream: strm,
UseRTPPackets: true,
}
err = subStream.Initialize()
require.NoError(t, err)
pc1 := &PeerConnection{
LocalRandomUDP: true,
IPsFromInterfaces: true,
Publish: false,
Log: test.NilLogger,
}
err = pc1.Start()
require.NoError(t, err)
defer pc1.Close()
pc2 := &PeerConnection{
LocalRandomUDP: true,
IPsFromInterfaces: true,
Publish: true,
Log: test.NilLogger,
}
r := &stream.Reader{Parent: nil}
err = FromStream(strm.Desc, r, pc2)
require.NoError(t, err)
err = pc2.Start()
require.NoError(t, err)
defer pc2.Close()
offer, err := pc1.CreatePartialOffer()
require.NoError(t, err)
answer, err := pc2.CreateFullAnswer(offer)
require.NoError(t, err)
err = pc1.SetAnswer(answer)
require.NoError(t, err)
err = pc1.WaitUntilConnected(10 * time.Second)
require.NoError(t, err)
err = pc2.WaitUntilConnected(10 * time.Second)
require.NoError(t, err)
strm.AddReader(r)
defer strm.RemoveReader(r)
subStream.WriteUnit(strm.Desc.Medias[0], strm.Desc.Medias[0].Formats[0], &unit.Unit{
PTS: 0,
NTP: time.Now(),
RTPPackets: []*rtp.Packet{{
Header: rtp.Header{
Version: 2,
Marker: true,
PayloadType: 111,
SequenceNumber: 1123,
Timestamp: 45343,
SSRC: 563424,
},
Payload: []byte{1},
}},
})
subStream.WriteUnit(strm.Desc.Medias[0], strm.Desc.Medias[0].Formats[0], &unit.Unit{
PTS: 0,
NTP: time.Now(),
RTPPackets: []*rtp.Packet{{
Header: rtp.Header{
Version: 2,
Marker: true,
PayloadType: 111,
SequenceNumber: 1124,
Timestamp: 45343,
SSRC: 563424,
},
Payload: []byte{1},
}},
})
err = pc1.GatherIncomingTracks(2 * time.Second)
require.NoError(t, err)
tracks := pc1.IncomingTracks()
done := make(chan struct{})
n := 0
var ts uint32
tracks[0].OnPacketRTP = func(pkt *rtp.Packet) {
n++
switch n {
case 1:
ts = pkt.Timestamp
case 2:
require.Equal(t, uint32(960), pkt.Timestamp-ts)
close(done)
}
}
pc1.StartReading()
<-done
}
================================================
FILE: internal/protocols/webrtc/incoming_track.go
================================================
package webrtc
import (
"time"
"github.com/bluenviron/gortsplib/v5/pkg/rtpreceiver"
"github.com/pion/rtcp"
"github.com/pion/rtp"
"github.com/pion/webrtc/v4"
"github.com/bluenviron/mediamtx/internal/counterdumper"
"github.com/bluenviron/mediamtx/internal/logger"
)
const (
keyFrameInterval = 2 * time.Second
mimeTypeMultiopus = "audio/multiopus"
mimeTypeL16 = "audio/L16"
)
var incomingVideoCodecs = []webrtc.RTPCodecParameters{
{
RTPCodecCapability: webrtc.RTPCodecCapability{
MimeType: webrtc.MimeTypeAV1,
ClockRate: 90000,
SDPFmtpLine: "profile=1",
},
PayloadType: 96,
},
{
RTPCodecCapability: webrtc.RTPCodecCapability{
MimeType: webrtc.MimeTypeAV1,
ClockRate: 90000,
},
PayloadType: 97,
},
{
RTPCodecCapability: webrtc.RTPCodecCapability{
MimeType: webrtc.MimeTypeVP9,
ClockRate: 90000,
SDPFmtpLine: "profile-id=3",
},
PayloadType: 98,
},
{
RTPCodecCapability: webrtc.RTPCodecCapability{
MimeType: webrtc.MimeTypeVP9,
ClockRate: 90000,
SDPFmtpLine: "profile-id=2",
},
PayloadType: 99,
},
{
RTPCodecCapability: webrtc.RTPCodecCapability{
MimeType: webrtc.MimeTypeVP9,
ClockRate: 90000,
SDPFmtpLine: "profile-id=1",
},
PayloadType: 100,
},
{
RTPCodecCapability: webrtc.RTPCodecCapability{
MimeType: webrtc.MimeTypeVP9,
ClockRate: 90000,
SDPFmtpLine: "profile-id=0",
},
PayloadType: 101,
},
{
RTPCodecCapability: webrtc.RTPCodecCapability{
MimeType: webrtc.MimeTypeVP8,
ClockRate: 90000,
},
PayloadType: 102,
},
{
RTPCodecCapability: webrtc.RTPCodecCapability{
MimeType: webrtc.MimeTypeH265,
ClockRate: 90000,
SDPFmtpLine: "level-id=93;profile-id=2;tier-flag=0;tx-mode=SRST",
},
PayloadType: 103,
},
{
RTPCodecCapability: webrtc.RTPCodecCapability{
MimeType: webrtc.MimeTypeH265,
ClockRate: 90000,
SDPFmtpLine: "level-id=93;profile-id=1;tier-flag=0;tx-mode=SRST",
},
PayloadType: 104,
},
{
RTPCodecCapability: webrtc.RTPCodecCapability{
MimeType: webrtc.MimeTypeH264,
ClockRate: 90000,
SDPFmtpLine: "level-asymmetry-allowed=1;packetization-mode=1;profile-level-id=42001f",
},
PayloadType: 105,
},
{
RTPCodecCapability: webrtc.RTPCodecCapability{
MimeType: webrtc.MimeTypeH264,
ClockRate: 90000,
SDPFmtpLine: "level-asymmetry-allowed=1;packetization-mode=1;profile-level-id=42e01f",
},
PayloadType: 106,
},
}
var incomingAudioCodecs = []webrtc.RTPCodecParameters{
{
RTPCodecCapability: webrtc.RTPCodecCapability{
MimeType: mimeTypeMultiopus,
ClockRate: 48000,
Channels: 3,
SDPFmtpLine: "channel_mapping=0,2,1;num_streams=2;coupled_streams=1",
},
PayloadType: 112,
},
{
RTPCodecCapability: webrtc.RTPCodecCapability{
MimeType: mimeTypeMultiopus,
ClockRate: 48000,
Channels: 4,
SDPFmtpLine: "channel_mapping=0,1,2,3;num_streams=2;coupled_streams=2",
},
PayloadType: 113,
},
{
RTPCodecCapability: webrtc.RTPCodecCapability{
MimeType: mimeTypeMultiopus,
ClockRate: 48000,
Channels: 5,
SDPFmtpLine: "channel_mapping=0,4,1,2,3;num_streams=3;coupled_streams=2",
},
PayloadType: 114,
},
{
RTPCodecCapability: webrtc.RTPCodecCapability{
MimeType: mimeTypeMultiopus,
ClockRate: 48000,
Channels: 6,
SDPFmtpLine: "channel_mapping=0,4,1,2,3,5;num_streams=4;coupled_streams=2",
},
PayloadType: 115,
},
{
RTPCodecCapability: webrtc.RTPCodecCapability{
MimeType: mimeTypeMultiopus,
ClockRate: 48000,
Channels: 7,
SDPFmtpLine: "channel_mapping=0,4,1,2,3,5,6;num_streams=4;coupled_streams=4",
},
PayloadType: 116,
},
{
RTPCodecCapability: webrtc.RTPCodecCapability{
MimeType: mimeTypeMultiopus,
ClockRate: 48000,
Channels: 8,
SDPFmtpLine: "channel_mapping=0,6,1,4,5,2,3,7;num_streams=5;coupled_streams=4",
},
PayloadType: 117,
},
{
RTPCodecCapability: webrtc.RTPCodecCapability{
MimeType: webrtc.MimeTypeOpus,
ClockRate: 48000,
Channels: 2,
SDPFmtpLine: "minptime=10;useinbandfec=1;stereo=1;sprop-stereo=1",
},
PayloadType: 111,
},
{
RTPCodecCapability: webrtc.RTPCodecCapability{
MimeType: webrtc.MimeTypeG722,
ClockRate: 8000,
},
PayloadType: 9,
},
{
RTPCodecCapability: webrtc.RTPCodecCapability{
MimeType: webrtc.MimeTypePCMU,
ClockRate: 8000,
Channels: 2,
},
PayloadType: 118,
},
{
RTPCodecCapability: webrtc.RTPCodecCapability{
MimeType: webrtc.MimeTypePCMA,
ClockRate: 8000,
Channels: 2,
},
PayloadType: 119,
},
{
RTPCodecCapability: webrtc.RTPCodecCapability{
MimeType: webrtc.MimeTypePCMU,
ClockRate: 8000,
},
PayloadType: 0,
},
{
RTPCodecCapability: webrtc.RTPCodecCapability{
MimeType: webrtc.MimeTypePCMA,
ClockRate: 8000,
},
PayloadType: 8,
},
{
RTPCodecCapability: webrtc.RTPCodecCapability{
MimeType: mimeTypeL16,
ClockRate: 8000,
Channels: 2,
},
PayloadType: 120,
},
{
RTPCodecCapability: webrtc.RTPCodecCapability{
MimeType: mimeTypeL16,
ClockRate: 16000,
Channels: 2,
},
PayloadType: 121,
},
{
RTPCodecCapability: webrtc.RTPCodecCapability{
MimeType: mimeTypeL16,
ClockRate: 48000,
Channels: 2,
},
PayloadType: 122,
},
}
// IncomingTrack is an incoming track.
type IncomingTrack struct {
OnPacketRTP func(*rtp.Packet)
track *webrtc.TrackRemote
receiver *webrtc.RTPReceiver
rid string
writeRTCP func([]rtcp.Packet) error
log logger.Writer
inboundRTPPacketsLost *counterdumper.Dumper
rtpReceiver *rtpreceiver.Receiver
}
func (t *IncomingTrack) initialize() {
t.OnPacketRTP = func(*rtp.Packet) {}
}
// Codec returns the track codec.
func (t *IncomingTrack) Codec() webrtc.RTPCodecParameters {
return t.track.Codec()
}
// ClockRate returns the clock rate. Needed by rtptime.GlobalDecoder
func (t *IncomingTrack) ClockRate() int {
return int(t.track.Codec().ClockRate)
}
// PTSEqualsDTS returns whether PTS equals DTS. Needed by rtptime.GlobalDecoder
func (*IncomingTrack) PTSEqualsDTS(*rtp.Packet) bool {
return true
}
func (t *IncomingTrack) start() {
t.inboundRTPPacketsLost = &counterdumper.Dumper{
OnReport: func(val uint64) {
t.log.Log(logger.Warn, "%d RTP %s lost",
val,
func() string {
if val == 1 {
return "packet"
}
return "packets"
}())
},
}
t.inboundRTPPacketsLost.Start()
t.rtpReceiver = &rtpreceiver.Receiver{
ClockRate: int(t.track.Codec().ClockRate),
UnrealiableTransport: true,
Period: 1 * time.Second,
WritePacketRTCP: func(p rtcp.Packet) {
t.writeRTCP([]rtcp.Packet{p}) //nolint:errcheck
},
}
err := t.rtpReceiver.Initialize()
if err != nil {
panic(err)
}
// read incoming RTCP packets.
// incoming RTCP packets must always be read to make interceptors work.
go func() {
buf := make([]byte, 1500)
for {
n, _, err2 := t.receiver.ReadSimulcast(buf, t.rid)
if err2 != nil {
return
}
pkts, err2 := rtcp.Unmarshal(buf[:n])
if err2 != nil {
panic(err2)
}
for _, pkt := range pkts {
if sr, ok := pkt.(*rtcp.SenderReport); ok {
t.rtpReceiver.ProcessSenderReport(sr, time.Now())
}
}
}
}()
// send period key frame requests
if t.track.Kind() == webrtc.RTPCodecTypeVideo {
go func() {
keyframeTicker := time.NewTicker(keyFrameInterval)
defer keyframeTicker.Stop()
for range keyframeTicker.C {
err2 := t.writeRTCP([]rtcp.Packet{
&rtcp.PictureLossIndication{
MediaSSRC: uint32(t.track.SSRC()),
},
})
if err2 != nil {
return
}
}
}()
}
// read incoming RTP packets.
go func() {
for {
pkt, _, err2 := t.track.ReadRTP()
if err2 != nil {
return
}
packets, lost := t.rtpReceiver.ProcessPacket2(pkt, time.Now(), true)
if lost != 0 {
t.inboundRTPPacketsLost.Add(lost)
// do not return
}
for _, pkt := range packets {
// sometimes Chrome sends empty RTP packets. ignore them.
if len(pkt.Payload) == 0 {
continue
}
t.OnPacketRTP(pkt)
}
}
}()
}
// PacketNTP returns the packet NTP.
func (t *IncomingTrack) PacketNTP(pkt *rtp.Packet) (time.Time, bool) {
return t.rtpReceiver.PacketNTP(pkt.Timestamp)
}
func (t *IncomingTrack) close() {
if t.inboundRTPPacketsLost != nil {
t.inboundRTPPacketsLost.Stop()
}
if t.rtpReceiver != nil {
t.rtpReceiver.Close()
}
}
================================================
FILE: internal/protocols/webrtc/net.go
================================================
package webrtc
import (
"net"
"github.com/bluenviron/gortsplib/v5/pkg/readbuffer"
"github.com/pion/transport/v4"
"github.com/pion/transport/v4/stdnet"
)
type webrtcNet struct {
udpReadBufferSize int
*stdnet.Net
}
func (n *webrtcNet) initialize() error {
var err error
n.Net, err = stdnet.NewNet()
if err != nil {
return err
}
return nil
}
func (n *webrtcNet) ListenUDP(network string, laddr *net.UDPAddr) (transport.UDPConn, error) {
conn, err := n.Net.ListenUDP(network, laddr)
if err != nil {
return nil, err
}
if n.udpReadBufferSize != 0 {
err = readbuffer.SetReadBuffer(conn.(*net.UDPConn), n.udpReadBufferSize)
if err != nil {
return nil, err
}
}
return conn, nil
}
================================================
FILE: internal/protocols/webrtc/outgoing_data_channel.go
================================================
package webrtc
import (
"github.com/pion/webrtc/v4"
)
// OutgoingDataChannel is an outgoing data channel.
type OutgoingDataChannel struct {
Label string
dataChan *webrtc.DataChannel
}
func (c *OutgoingDataChannel) setup(p *PeerConnection) error {
var err error
c.dataChan, err = p.wr.CreateDataChannel(c.Label, &webrtc.DataChannelInit{
Ordered: ptrOf(false),
})
if err != nil {
return err
}
return nil
}
// Write writes data to the channel.
func (c *OutgoingDataChannel) Write(data []byte) {
c.dataChan.Send(data) //nolint:errcheck
}
================================================
FILE: internal/protocols/webrtc/outgoing_track.go
================================================
package webrtc
import (
"strings"
"time"
"github.com/bluenviron/gortsplib/v5/pkg/rtpsender"
"github.com/pion/rtcp"
"github.com/pion/rtp"
"github.com/pion/webrtc/v4"
)
// OutgoingTrack is an outgoing track.
type OutgoingTrack struct {
Caps webrtc.RTPCodecCapability
track *webrtc.TrackLocalStaticRTP
ssrc uint32
rtcpSender *rtpsender.Sender
}
func (t *OutgoingTrack) isVideo() bool {
return strings.Split(t.Caps.MimeType, "/")[0] == "video"
}
func (t *OutgoingTrack) setup(p *PeerConnection) error {
var trackID string
if t.isVideo() {
trackID = "video"
} else {
trackID = "audio"
}
var err error
t.track, err = webrtc.NewTrackLocalStaticRTP(
t.Caps,
trackID,
webrtcStreamID,
)
if err != nil {
return err
}
sender, err := p.wr.AddTrack(t.track)
if err != nil {
return err
}
t.ssrc = uint32(sender.GetParameters().Encodings[0].SSRC)
t.rtcpSender = &rtpsender.Sender{
ClockRate: int(t.track.Codec().ClockRate),
Period: 1 * time.Second,
TimeNow: time.Now,
WritePacketRTCP: func(pkt rtcp.Packet) {
p.wr.WriteRTCP([]rtcp.Packet{pkt}) //nolint:errcheck
},
}
t.rtcpSender.Initialize()
// incoming RTCP packets must always be read to make interceptors work
go func() {
buf := make([]byte, 1500)
for {
n, _, err2 := sender.Read(buf)
if err2 != nil {
return
}
_, err2 = rtcp.Unmarshal(buf[:n])
if err2 != nil {
panic(err2)
}
}
}()
return nil
}
func (t *OutgoingTrack) close() {
if t.rtcpSender != nil {
t.rtcpSender.Close()
}
}
// WriteRTP writes a RTP packet.
func (t *OutgoingTrack) WriteRTP(pkt *rtp.Packet) error {
return t.WriteRTPWithNTP(pkt, time.Now())
}
// WriteRTPWithNTP writes a RTP packet.
func (t *OutgoingTrack) WriteRTPWithNTP(pkt *rtp.Packet, ntp time.Time) error {
// use right SSRC in packet to make rtcpSender work
pkt.SSRC = t.ssrc
t.rtcpSender.ProcessPacket(pkt, ntp, true)
return t.track.WriteRTP(pkt)
}
================================================
FILE: internal/protocols/webrtc/peer_connection.go
================================================
// Package webrtc contains WebRTC utilities.
package webrtc
import (
"context"
"errors"
"fmt"
"net"
"slices"
"strconv"
"strings"
"sync"
"sync/atomic"
"time"
"github.com/pion/ice/v4"
"github.com/pion/interceptor"
"github.com/pion/sdp/v3"
"github.com/pion/webrtc/v4"
"github.com/bluenviron/mediamtx/internal/logger"
)
const (
webrtcStreamID = "mediamtx"
)
func interfaceIPs(interfaceList []string) ([]string, error) {
intfs, err := net.Interfaces()
if err != nil {
return nil, err
}
var ips []string
for _, intf := range intfs {
if len(interfaceList) == 0 || slices.Contains(interfaceList, intf.Name) {
var addrs []net.Addr
addrs, err = intf.Addrs()
if err == nil {
for _, addr := range addrs {
var ip net.IP
switch v := addr.(type) {
case *net.IPNet:
ip = v.IP
case *net.IPAddr:
ip = v.IP
}
if ip != nil {
ips = append(ips, ip.String())
}
}
}
}
}
return ips, nil
}
func maxTrackCount(medias []*sdp.MediaDescription) int {
total := 0
for _, media := range medias {
ridCount := 0
for _, attr := range media.Attributes {
if attr.Key == "rid" {
ridCount++
}
}
if ridCount == 0 {
ridCount = 1
}
total += ridCount
}
return total
}
// * skip ConfigureRTCPReports
// * add statsInterceptor
func registerInterceptors(
mediaEngine *webrtc.MediaEngine,
interceptorRegistry *interceptor.Registry,
onStatsInterceptor func(s *statsInterceptor),
) error {
err := webrtc.ConfigureNack(mediaEngine, interceptorRegistry)
if err != nil {
return err
}
err = webrtc.ConfigureSimulcastExtensionHeaders(mediaEngine)
if err != nil {
return err
}
err = webrtc.ConfigureTWCCSender(mediaEngine, interceptorRegistry)
if err != nil {
return err
}
interceptorRegistry.Add(&statsInterceptorFactory{
onCreate: onStatsInterceptor,
})
return nil
}
func candidateLabel(c *webrtc.ICECandidate) string {
return c.Typ.String() + "/" + c.Protocol.String() + "/" +
c.Address + "/" + strconv.FormatInt(int64(c.Port), 10)
}
// TracksAreValid checks whether tracks in the SDP are valid
func TracksAreValid(medias []*sdp.MediaDescription) error {
videoTrack := false
audioTrack := false
for _, media := range medias {
switch media.MediaName.Media {
case "video":
if videoTrack {
return fmt.Errorf("only a single video and a single audio track are supported")
}
videoTrack = true
case "audio":
if audioTrack {
return fmt.Errorf("only a single video and a single audio track are supported")
}
audioTrack = true
default:
return fmt.Errorf("unsupported media '%s'", media.MediaName.Media)
}
}
if !videoTrack && !audioTrack {
return fmt.Errorf("no valid tracks found")
}
return nil
}
type trackRecvPair struct {
track *webrtc.TrackRemote
receiver *webrtc.RTPReceiver
}
// PeerConnection is a wrapper around webrtc.PeerConnection.
type PeerConnection struct {
UDPReadBufferSize uint
LocalRandomUDP bool
ICEUDPMux ice.UDPMux
ICETCPMux *TCPMuxWrapper
ICEServers []webrtc.ICEServer
IPsFromInterfaces bool
IPsFromInterfacesList []string
AdditionalHosts []string
STUNGatherTimeout time.Duration
Publish bool
OutgoingTracks []*OutgoingTrack
OutgoingDataChannels []*OutgoingDataChannel
Log logger.Writer
wr *webrtc.PeerConnection
ctx context.Context
ctxCancel context.CancelFunc
readingStarted *int64
incomingTracks []*IncomingTrack
statsInterceptor *statsInterceptor
newLocalCandidate chan *webrtc.ICECandidateInit
incomingTrack chan trackRecvPair
connected chan struct{}
failed chan struct{}
closed chan struct{}
gatheringDone chan struct{}
done chan struct{}
chStartReading chan struct{}
}
// Start starts the peer connection.
func (co *PeerConnection) Start() error {
if co.STUNGatherTimeout == 0 {
co.STUNGatherTimeout = 5 * time.Second
}
settingsEngine := webrtc.SettingEngine{}
settingsEngine.SetIncludeLoopbackCandidate(true)
// always enable TCP since we might be the client of a remote TCP listener
networkTypes := []webrtc.NetworkType{
webrtc.NetworkTypeTCP4,
webrtc.NetworkTypeTCP6,
}
if co.LocalRandomUDP || co.ICEUDPMux != nil || len(co.ICEServers) != 0 {
networkTypes = append(networkTypes, webrtc.NetworkTypeUDP4, webrtc.NetworkTypeUDP6)
}
settingsEngine.SetNetworkTypes(networkTypes)
if co.ICEUDPMux != nil {
settingsEngine.SetICEUDPMux(co.ICEUDPMux)
}
if co.ICETCPMux != nil {
settingsEngine.SetICETCPMux(co.ICETCPMux.Mux)
}
settingsEngine.SetSTUNGatherTimeout(co.STUNGatherTimeout)
webrtcNet := &webrtcNet{
udpReadBufferSize: int(co.UDPReadBufferSize),
}
err := webrtcNet.initialize()
if err != nil {
return err
}
settingsEngine.SetNet(webrtcNet)
mediaEngine := &webrtc.MediaEngine{}
if co.Publish {
videoSetupped := false
audioSetupped := false
for _, tr := range co.OutgoingTracks {
if tr.isVideo() {
videoSetupped = true
} else {
audioSetupped = true
}
}
// When audio is not used, a track has to be present anyway,
// otherwise video is not displayed on Firefox and Chrome.
if !audioSetupped {
co.OutgoingTracks = append(co.OutgoingTracks, &OutgoingTrack{
Caps: webrtc.RTPCodecCapability{
MimeType: webrtc.MimeTypePCMU,
ClockRate: 8000,
},
})
}
for i, tr := range co.OutgoingTracks {
var codecType webrtc.RTPCodecType
if tr.isVideo() {
codecType = webrtc.RTPCodecTypeVideo
} else {
codecType = webrtc.RTPCodecTypeAudio
}
err = mediaEngine.RegisterCodec(webrtc.RTPCodecParameters{
RTPCodecCapability: tr.Caps,
PayloadType: webrtc.PayloadType(96 + i),
}, codecType)
if err != nil {
return err
}
}
// When video is not used, a track must not be added but a codec has to present.
// Otherwise audio is muted on Firefox and Chrome.
if !videoSetupped {
err = mediaEngine.RegisterCodec(webrtc.RTPCodecParameters{
RTPCodecCapability: webrtc.RTPCodecCapability{
MimeType: webrtc.MimeTypeVP8,
ClockRate: 90000,
},
PayloadType: 96,
}, webrtc.RTPCodecTypeVideo)
if err != nil {
return err
}
}
} else {
for _, codec := range incomingVideoCodecs {
err = mediaEngine.RegisterCodec(codec, webrtc.RTPCodecTypeVideo)
if err != nil {
return err
}
}
for _, codec := range incomingAudioCodecs {
err = mediaEngine.RegisterCodec(codec, webrtc.RTPCodecTypeAudio)
if err != nil {
return err
}
}
}
interceptorRegistry := &interceptor.Registry{}
err = registerInterceptors(
mediaEngine,
interceptorRegistry,
func(s *statsInterceptor) {
co.statsInterceptor = s
},
)
if err != nil {
return err
}
api := webrtc.NewAPI(
webrtc.WithSettingEngine(settingsEngine),
webrtc.WithMediaEngine(mediaEngine),
webrtc.WithInterceptorRegistry(interceptorRegistry))
co.wr, err = api.NewPeerConnection(webrtc.Configuration{
ICEServers: co.ICEServers,
})
if err != nil {
return err
}
co.ctx, co.ctxCancel = context.WithCancel(context.Background())
co.readingStarted = new(int64)
co.newLocalCandidate = make(chan *webrtc.ICECandidateInit)
co.connected = make(chan struct{})
co.failed = make(chan struct{})
co.closed = make(chan struct{})
co.gatheringDone = make(chan struct{})
co.incomingTrack = make(chan trackRecvPair)
co.done = make(chan struct{})
co.chStartReading = make(chan struct{})
if co.Publish {
for _, tr := range co.OutgoingTracks {
err = tr.setup(co)
if err != nil {
co.wr.GracefulClose() //nolint:errcheck
return err
}
}
for _, dc := range co.OutgoingDataChannels {
err = dc.setup(co)
if err != nil {
co.wr.GracefulClose() //nolint:errcheck
return err
}
}
} else {
_, err = co.wr.AddTransceiverFromKind(webrtc.RTPCodecTypeVideo, webrtc.RTPTransceiverInit{
Direction: webrtc.RTPTransceiverDirectionRecvonly,
})
if err != nil {
co.wr.GracefulClose() //nolint:errcheck
return err
}
_, err = co.wr.AddTransceiverFromKind(webrtc.RTPCodecTypeAudio, webrtc.RTPTransceiverInit{
Direction: webrtc.RTPTransceiverDirectionRecvonly,
})
if err != nil {
co.wr.GracefulClose() //nolint:errcheck
return err
}
co.wr.OnTrack(func(track *webrtc.TrackRemote, receiver *webrtc.RTPReceiver) {
select {
case co.incomingTrack <- trackRecvPair{track, receiver}:
case <-co.ctx.Done():
}
})
}
var stateChangeMutex sync.Mutex
co.wr.OnConnectionStateChange(func(state webrtc.PeerConnectionState) {
stateChangeMutex.Lock()
defer stateChangeMutex.Unlock()
select {
case <-co.closed:
return
default:
}
co.Log.Log(logger.Debug, "peer connection state: "+state.String())
switch state {
case webrtc.PeerConnectionStateConnected:
// PeerConnectionStateConnected can arrive twice, since state can
// switch from "disconnected" to "connected".
// contrarily, we're interested into emitting "connected" once.
select {
case <-co.connected:
return
default:
}
co.Log.Log(logger.Info, "peer connection established, local candidate: %v, remote candidate: %v",
co.LocalCandidate(), co.RemoteCandidate())
close(co.connected)
case webrtc.PeerConnectionStateFailed:
close(co.failed)
case webrtc.PeerConnectionStateClosed:
// "closed" can arrive before "failed" and without
// the Close() method being called at all.
// It happens when the other peer sends a termination
// message like a DTLS CloseNotify.
select {
case <-co.failed:
default:
close(co.failed)
}
close(co.closed)
}
})
co.wr.OnICECandidate(func(i *webrtc.ICECandidate) {
if i != nil {
v := i.ToJSON()
select {
case co.newLocalCandidate <- &v:
case <-co.connected:
case <-co.ctx.Done():
}
} else {
close(co.gatheringDone)
}
})
go co.run()
return nil
}
// Close closes the connection.
func (co *PeerConnection) Close() {
co.ctxCancel()
<-co.done
}
func (co *PeerConnection) run() {
defer close(co.done)
defer func() {
for _, track := range co.incomingTracks {
track.close()
}
for _, track := range co.OutgoingTracks {
track.close()
}
co.wr.GracefulClose() //nolint:errcheck
// even if GracefulClose() should wait for any goroutine to return,
// we have to wait for OnConnectionStateChange to return anyway,
// since it is executed in an uncontrolled goroutine.
// https://github.com/pion/webrtc/blob/v4.2.8/peerconnection.go#L529
<-co.closed
}()
for {
select {
case <-co.chStartReading:
for _, track := range co.incomingTracks {
track.start()
}
atomic.StoreInt64(co.readingStarted, 1)
case <-co.ctx.Done():
return
}
}
}
func (co *PeerConnection) removeUnwantedCandidates(firstMedia *sdp.MediaDescription) error {
var allowedIPs []string
if co.IPsFromInterfaces {
var err error
allowedIPs, err = interfaceIPs(co.IPsFromInterfacesList)
if err != nil {
return err
}
}
var newAttributes []sdp.Attribute //nolint:prealloc
for _, attr := range firstMedia.Attributes {
if attr.Key == "candidate" {
parts := strings.Split(attr.Value, " ")
// hide random UDP candidates
if !co.LocalRandomUDP && co.ICEUDPMux == nil && parts[2] == "udp" && parts[7] == "host" {
continue
}
// hide disallowed IPs
if parts[7] == "host" && !slices.Contains(allowedIPs, parts[4]) {
continue
}
}
newAttributes = append(newAttributes, attr)
}
firstMedia.Attributes = newAttributes
return nil
}
func (co *PeerConnection) addAdditionalCandidates(firstMedia *sdp.MediaDescription) error {
i := 0
for _, attr := range firstMedia.Attributes {
if attr.Key == "end-of-candidates" {
break
}
i++
}
for _, host := range co.AdditionalHosts {
var ips []string
if net.ParseIP(host) != nil {
ips = []string{host}
} else {
tmp, err := net.LookupIP(host)
if err != nil {
return err
}
ips = make([]string, len(tmp))
for i, e := range tmp {
ips[i] = e.String()
}
}
for _, ip := range ips {
newAttrs := append([]sdp.Attribute(nil), firstMedia.Attributes[:i]...)
if co.ICEUDPMux != nil {
port := strconv.FormatInt(int64(co.ICEUDPMux.GetListenAddresses()[0].(*net.UDPAddr).Port), 10)
tmp, err := randUint32()
if err != nil {
return err
}
id := strconv.FormatInt(int64(tmp), 10)
newAttrs = append(newAttrs, sdp.Attribute{
Key: "candidate",
Value: id + " 1 udp 2130706431 " + ip + " " + port + " typ host",
})
newAttrs = append(newAttrs, sdp.Attribute{
Key: "candidate",
Value: id + " 2 udp 2130706431 " + ip + " " + port + " typ host",
})
}
if co.ICETCPMux != nil {
port := strconv.FormatInt(int64(co.ICETCPMux.Ln.Addr().(*net.TCPAddr).Port), 10)
tmp, err := randUint32()
if err != nil {
return err
}
id := strconv.FormatInt(int64(tmp), 10)
newAttrs = append(newAttrs, sdp.Attribute{
Key: "candidate",
Value: id + " 1 tcp 1671430143 " + ip + " " + port + " typ host tcptype passive",
})
newAttrs = append(newAttrs, sdp.Attribute{
Key: "candidate",
Value: id + " 2 tcp 1671430143 " + ip + " " + port + " typ host tcptype passive",
})
}
newAttrs = append(newAttrs, firstMedia.Attributes[i:]...)
firstMedia.Attributes = newAttrs
}
}
return nil
}
func (co *PeerConnection) filterLocalDescription(desc *webrtc.SessionDescription) (*webrtc.SessionDescription, error) {
var psdp sdp.SessionDescription
psdp.Unmarshal([]byte(desc.SDP)) //nolint:errcheck
firstMedia := psdp.MediaDescriptions[0]
err := co.removeUnwantedCandidates(firstMedia)
if err != nil {
return nil, err
}
err = co.addAdditionalCandidates(firstMedia)
if err != nil {
return nil, err
}
out, _ := psdp.Marshal()
desc.SDP = string(out)
return desc, nil
}
// CreatePartialOffer creates a partial offer.
func (co *PeerConnection) CreatePartialOffer() (*webrtc.SessionDescription, error) {
tmp, err := co.wr.CreateOffer(nil)
if err != nil {
return nil, err
}
offer := &tmp
err = co.wr.SetLocalDescription(*offer)
if err != nil {
return nil, err
}
offer, err = co.filterLocalDescription(offer)
if err != nil {
return nil, err
}
return offer, nil
}
// SetAnswer sets the answer.
func (co *PeerConnection) SetAnswer(answer *webrtc.SessionDescription) error {
return co.wr.SetRemoteDescription(*answer)
}
// AddRemoteCandidate adds a remote candidate.
func (co *PeerConnection) AddRemoteCandidate(candidate *webrtc.ICECandidateInit) error {
return co.wr.AddICECandidate(*candidate)
}
// CreateFullAnswer creates a full answer.
func (co *PeerConnection) CreateFullAnswer(offer *webrtc.SessionDescription) (*webrtc.SessionDescription, error) {
err := co.wr.SetRemoteDescription(*offer)
if err != nil {
return nil, err
}
tmp, err := co.wr.CreateAnswer(nil)
if err != nil {
if errors.Is(err, webrtc.ErrSenderWithNoCodecs) {
return nil, fmt.Errorf("codecs not supported by client")
}
return nil, err
}
answer := &tmp
err = co.wr.SetLocalDescription(*answer)
if err != nil {
return nil, err
}
err = co.waitGatheringDone()
if err != nil {
return nil, err
}
answer = co.wr.LocalDescription()
answer, err = co.filterLocalDescription(answer)
if err != nil {
return nil, err
}
return answer, nil
}
func (co *PeerConnection) waitGatheringDone() error {
for {
select {
case <-co.NewLocalCandidate():
case <-co.GatheringDone():
return nil
case <-co.ctx.Done():
return fmt.Errorf("terminated")
}
}
}
// WaitUntilConnected waits until connection is established.
func (co *PeerConnection) WaitUntilConnected(timeout time.Duration) error {
t := time.NewTimer(timeout)
defer t.Stop()
outer:
for {
select {
case <-t.C:
return fmt.Errorf("deadline exceeded while waiting connection")
case <-co.connected:
break outer
case <-co.ctx.Done():
return fmt.Errorf("terminated")
}
}
return nil
}
// GatherIncomingTracks gathers incoming tracks.
func (co *PeerConnection) GatherIncomingTracks(timeout time.Duration) error {
var sdp sdp.SessionDescription
sdp.Unmarshal([]byte(co.wr.RemoteDescription().SDP)) //nolint:errcheck
maxTrackCount := maxTrackCount(sdp.MediaDescriptions)
t := time.NewTimer(timeout)
defer t.Stop()
for {
select {
case <-t.C:
if len(co.incomingTracks) != 0 {
return nil
}
return fmt.Errorf("deadline exceeded while waiting tracks")
case pair := <-co.incomingTrack:
t := &IncomingTrack{
track: pair.track,
receiver: pair.receiver,
rid: pair.track.RID(),
writeRTCP: co.wr.WriteRTCP,
log: co.Log,
}
t.initialize()
co.incomingTracks = append(co.incomingTracks, t)
if len(co.incomingTracks) >= maxTrackCount {
return nil
}
case <-co.Failed():
return fmt.Errorf("peer connection closed")
case <-co.ctx.Done():
return fmt.Errorf("terminated")
}
}
}
// Connected returns when connected.
func (co *PeerConnection) Connected() <-chan struct{} {
return co.connected
}
// Failed returns when failed.
func (co *PeerConnection) Failed() <-chan struct{} {
return co.failed
}
// NewLocalCandidate returns when there's a new local candidate.
func (co *PeerConnection) NewLocalCandidate() <-chan *webrtc.ICECandidateInit {
return co.newLocalCandidate
}
// GatheringDone returns when candidate gathering is complete.
func (co *PeerConnection) GatheringDone() <-chan struct{} {
return co.gatheringDone
}
// IncomingTracks returns incoming tracks.
func (co *PeerConnection) IncomingTracks() []*IncomingTrack {
return co.incomingTracks
}
// StartReading starts reading incoming tracks.
func (co *PeerConnection) StartReading() {
select {
case co.chStartReading <- struct{}{}:
case <-co.ctx.Done():
}
}
// LocalCandidate returns the local candidate.
func (co *PeerConnection) LocalCandidate() string {
receivers := co.wr.GetReceivers()
if len(receivers) < 1 {
return ""
}
cp, err := receivers[0].Transport().ICETransport().GetSelectedCandidatePair()
if err != nil || cp == nil {
return ""
}
return candidateLabel(cp.Local)
}
// RemoteCandidate returns the remote candidate.
func (co *PeerConnection) RemoteCandidate() string {
receivers := co.wr.GetReceivers()
if len(receivers) < 1 {
return ""
}
cp, err := receivers[0].Transport().ICETransport().GetSelectedCandidatePair()
if err != nil || cp == nil {
return ""
}
return candidateLabel(cp.Remote)
}
func bytesStats(wr *webrtc.PeerConnection) (uint64, uint64) {
for _, stats := range wr.GetStats() {
if tstats, ok := stats.(webrtc.TransportStats); ok {
if tstats.ID == "iceTransport" {
return tstats.BytesReceived, tstats.BytesSent
}
}
}
return 0, 0
}
// Stats returns statistics.
func (co *PeerConnection) Stats() *Stats {
bytesReceived, bytesSent := bytesStats(co.wr)
v := float64(0)
n := float64(0)
packetsReceived := uint64(0)
packetsSent := uint64(0)
packetsLost := uint64(0)
if atomic.LoadInt64(co.readingStarted) == 1 {
for _, tr := range co.incomingTracks {
if recvStats := tr.rtpReceiver.Stats(); recvStats != nil {
v += recvStats.Jitter
n++
packetsReceived += recvStats.Received
packetsLost += recvStats.Lost
}
}
}
for _, tr := range co.OutgoingTracks {
if sentStats := tr.rtcpSender.Stats(); sentStats != nil {
packetsSent += sentStats.Sent
}
}
var rtpPacketsJitter float64
if n != 0 {
rtpPacketsJitter = v / n
} else {
rtpPacketsJitter = 0
}
return &Stats{
BytesReceived: bytesReceived,
BytesSent: bytesSent,
RTPPacketsReceived: packetsReceived,
RTPPacketsSent: packetsSent,
RTPPacketsLost: packetsLost,
RTPPacketsJitter: rtpPacketsJitter,
RTCPPacketsReceived: atomic.LoadUint64(co.statsInterceptor.rtcpPacketsReceived),
RTCPPacketsSent: atomic.LoadUint64(co.statsInterceptor.rtcpPacketsSent),
}
}
================================================
FILE: internal/protocols/webrtc/peer_connection_test.go
================================================
package webrtc
import (
"net"
"regexp"
"sort"
"strings"
"testing"
"time"
"github.com/bluenviron/mediamtx/internal/test"
"github.com/pion/ice/v4"
"github.com/pion/logging"
"github.com/pion/rtcp"
"github.com/pion/rtp"
"github.com/pion/sdp/v3"
"github.com/pion/webrtc/v4"
"github.com/stretchr/testify/require"
)
type nilWriter struct{}
func (nilWriter) Write(p []byte) (int, error) {
return len(p), nil
}
var webrtcNilLogger = logging.NewDefaultLeveledLoggerForScope("", 0, &nilWriter{})
func gatherCodecs(tracks []*IncomingTrack) []webrtc.RTPCodecParameters {
codecs := make([]webrtc.RTPCodecParameters, len(tracks))
for i, track := range tracks {
codecs[i] = track.Codec()
}
return codecs
}
func TestPeerConnectionCloseImmediately(t *testing.T) {
pc := &PeerConnection{
LocalRandomUDP: true,
IPsFromInterfaces: true,
Publish: false,
Log: test.NilLogger,
}
err := pc.Start()
require.NoError(t, err)
defer pc.Close()
}
func TestPeerConnectionCloseImmediately2(t *testing.T) {
pc := &PeerConnection{
LocalRandomUDP: true,
IPsFromInterfaces: true,
Publish: false,
Log: test.NilLogger,
}
err := pc.Start()
require.NoError(t, err)
defer pc.Close()
_, err = pc.CreatePartialOffer()
require.NoError(t, err)
// wait for ICE candidates to be generated
time.Sleep(500 * time.Millisecond)
}
func TestPeerConnectionCandidates(t *testing.T) {
for _, ca := range []string{
"udp random",
"udp",
"tcp",
"stun",
"udp+stun",
"udp random+stun",
} {
t.Run(ca, func(t *testing.T) {
pc2, err := webrtc.NewPeerConnection(webrtc.Configuration{})
require.NoError(t, err)
defer pc2.Close() //nolint:errcheck
track, err := webrtc.NewTrackLocalStaticRTP(
webrtc.RTPCodecCapability{
MimeType: webrtc.MimeTypeVP8,
ClockRate: 90000,
},
"video",
"publisher",
)
require.NoError(t, err)
_, err = pc2.AddTrack(track)
require.NoError(t, err)
offer, err := pc2.CreateOffer(nil)
require.NoError(t, err)
var udpMux ice.UDPMux
if ca == "udp" || ca == "udp+stun" {
var ln net.PacketConn
ln, err = net.ListenPacket("udp", ":3454")
require.NoError(t, err)
defer ln.Close()
udpMux = webrtc.NewICEUDPMux(webrtcNilLogger, ln)
}
var tcpMux *TCPMuxWrapper
if ca == "tcp" {
var ln net.Listener
ln, err = net.Listen("tcp", ":3454")
require.NoError(t, err)
defer ln.Close()
tcpMux = &TCPMuxWrapper{
Mux: webrtc.NewICETCPMux(webrtcNilLogger, ln, 8),
Ln: ln,
}
}
pc := &PeerConnection{
LocalRandomUDP: (ca == "udp random" || ca == "udp random+stun"),
ICEUDPMux: udpMux,
ICETCPMux: tcpMux,
IPsFromInterfaces: true,
IPsFromInterfacesList: []string{"lo"},
Log: test.NilLogger,
}
if ca == "stun" || ca == "udp+stun" || ca == "udp random+stun" {
pc.ICEServers = []webrtc.ICEServer{{
URLs: []string{"stun:stun.l.google.com:19302"},
}}
}
err = pc.Start()
require.NoError(t, err)
defer pc.Close()
answer, err := pc.CreateFullAnswer(&offer)
require.NoError(t, err)
n := len(regexp.MustCompile("(?m)^a=candidate:.+? udp .+? typ host").FindAllString(answer.SDP, -1))
if ca == "udp" || ca == "udp random" || ca == "udp+stun" || ca == "udp random+stun" {
require.Equal(t, 2, n)
} else {
require.Equal(t, 0, n)
}
n = len(regexp.MustCompile("(?m)^a=candidate:.+? tcp .+? typ host tcptype passive").FindAllString(answer.SDP, -1))
if ca == "tcp" {
require.Equal(t, 2, n)
} else {
require.Equal(t, 0, n)
}
n = len(regexp.MustCompile("(?m)^a=candidate:.+? udp .+? typ srflx").FindAllString(answer.SDP, -1))
if ca == "stun" || ca == "udp+stun" || ca == "udp random+stun" {
require.Equal(t, 2, n)
} else {
require.Equal(t, 0, n)
}
})
}
}
func TestPeerConnectionConnectivity(t *testing.T) {
for _, mode := range []string{
"passive udp",
"passive tcp",
"active udp",
"active udp + stun",
} {
for _, ip := range []string{
"from interfaces",
"additional hosts",
} {
// LocalRandomUDP doesn't work with AdditionalHosts
// we don't care since we are not currently using them together
if mode == "active udp" && ip == "additional hosts" {
continue
}
t.Run(mode+"_"+ip, func(t *testing.T) {
var iceServers []webrtc.ICEServer
if mode == "active udp + stun" {
iceServers = []webrtc.ICEServer{{
URLs: []string{"stun:stun.l.google.com:19302"},
}}
}
clientPC := &PeerConnection{
LocalRandomUDP: (mode == "passive udp" || mode == "active udp"),
IPsFromInterfaces: true,
IPsFromInterfacesList: []string{"lo"},
ICEServers: iceServers,
Log: test.NilLogger,
}
err := clientPC.Start()
require.NoError(t, err)
defer clientPC.Close()
var udpMux ice.UDPMux
var tcpMux *TCPMuxWrapper
switch mode {
case "passive udp":
var ln net.PacketConn
ln, err = net.ListenPacket("udp4", ":4458")
require.NoError(t, err)
defer ln.Close()
udpMux = webrtc.NewICEUDPMux(webrtcNilLogger, ln)
case "passive tcp":
var ln net.Listener
ln, err = net.Listen("tcp4", ":4458")
require.NoError(t, err)
defer ln.Close()
tcpMux = &TCPMuxWrapper{
Mux: webrtc.NewICETCPMux(webrtcNilLogger, ln, 8),
Ln: ln,
}
}
serverPC := &PeerConnection{
LocalRandomUDP: (mode == "active udp"),
ICEUDPMux: udpMux,
ICETCPMux: tcpMux,
ICEServers: iceServers,
Publish: true,
OutgoingTracks: []*OutgoingTrack{{
Caps: webrtc.RTPCodecCapability{
MimeType: webrtc.MimeTypeAV1,
ClockRate: 90000,
},
}},
Log: test.NilLogger,
}
if ip == "from interfaces" {
serverPC.IPsFromInterfaces = true
serverPC.IPsFromInterfacesList = []string{"lo"}
} else {
serverPC.AdditionalHosts = []string{"127.0.0.1"}
}
err = serverPC.Start()
require.NoError(t, err)
defer serverPC.Close()
offer, err := clientPC.CreatePartialOffer()
require.NoError(t, err)
answer, err := serverPC.CreateFullAnswer(offer)
require.NoError(t, err)
require.Equal(t, 2, strings.Count(answer.SDP, "a=candidate:"))
err = clientPC.SetAnswer(answer)
require.NoError(t, err)
go func() {
for {
select {
case cd := <-clientPC.NewLocalCandidate():
err2 := serverPC.AddRemoteCandidate(cd)
require.NoError(t, err2)
case <-clientPC.Failed():
return
}
}
}()
err = serverPC.WaitUntilConnected(10 * time.Second)
require.NoError(t, err)
})
}
}
}
func TestPeerConnectionRead(t *testing.T) {
pub, err := webrtc.NewPeerConnection(webrtc.Configuration{})
require.NoError(t, err)
defer pub.Close() //nolint:errcheck
videoTrack, err := webrtc.NewTrackLocalStaticRTP(
webrtc.RTPCodecCapability{
MimeType: webrtc.MimeTypeVP8,
ClockRate: 90000,
},
"video",
"publisher")
require.NoError(t, err)
videoSender, err := pub.AddTrack(videoTrack)
require.NoError(t, err)
audioTrack, err := webrtc.NewTrackLocalStaticRTP(
webrtc.RTPCodecCapability{
MimeType: webrtc.MimeTypeOpus,
ClockRate: 48000,
},
"audio",
"publisher")
require.NoError(t, err)
audioSender, err := pub.AddTrack(audioTrack)
require.NoError(t, err)
reader := &PeerConnection{
LocalRandomUDP: true,
IPsFromInterfaces: true,
Publish: false,
Log: test.NilLogger,
}
err = reader.Start()
require.NoError(t, err)
defer reader.Close()
offer, err := pub.CreateOffer(nil)
require.NoError(t, err)
err = pub.SetLocalDescription(offer)
require.NoError(t, err)
answer, err := reader.CreateFullAnswer(&offer)
require.NoError(t, err)
err = pub.SetRemoteDescription(*answer)
require.NoError(t, err)
err = reader.WaitUntilConnected(10 * time.Second)
require.NoError(t, err)
go func() {
time.Sleep(100 * time.Millisecond)
err2 := videoTrack.WriteRTP(&rtp.Packet{
Header: rtp.Header{
Version: 2,
Marker: true,
PayloadType: 111,
SequenceNumber: 1123,
Timestamp: 45343,
SSRC: 563424,
},
Payload: []byte{5, 2},
})
require.NoError(t, err2)
err2 = audioTrack.WriteRTP(&rtp.Packet{
Header: rtp.Header{
Version: 2,
Marker: true,
PayloadType: 111,
SequenceNumber: 1123,
Timestamp: 45343,
SSRC: 563424,
},
Payload: []byte{5, 2},
})
require.NoError(t, err2)
}()
err = reader.GatherIncomingTracks(2 * time.Second)
require.NoError(t, err)
codecs := gatherCodecs(reader.IncomingTracks())
sort.Slice(codecs, func(i, j int) bool {
return codecs[i].PayloadType < codecs[j].PayloadType
})
require.Equal(t, []webrtc.RTPCodecParameters{
{
RTPCodecCapability: webrtc.RTPCodecCapability{
MimeType: webrtc.MimeTypeVP8,
ClockRate: 90000,
RTCPFeedback: codecs[0].RTCPFeedback,
},
PayloadType: 96,
},
{
RTPCodecCapability: webrtc.RTPCodecCapability{
MimeType: webrtc.MimeTypeOpus,
ClockRate: 48000,
Channels: 2,
SDPFmtpLine: "minptime=10;useinbandfec=1",
RTCPFeedback: codecs[1].RTCPFeedback,
},
PayloadType: 111,
},
}, codecs)
reader.StartReading()
pkts, _, err := videoSender.ReadRTCP()
require.NoError(t, err)
require.Equal(t, []rtcp.Packet{
&rtcp.ReceiverReport{
SSRC: pkts[0].(*rtcp.ReceiverReport).SSRC,
Reports: []rtcp.ReceptionReport{{
SSRC: uint32(videoSender.GetParameters().Encodings[0].SSRC),
LastSequenceNumber: pkts[0].(*rtcp.ReceiverReport).Reports[0].LastSequenceNumber,
LastSenderReport: pkts[0].(*rtcp.ReceiverReport).Reports[0].LastSenderReport,
Delay: pkts[0].(*rtcp.ReceiverReport).Reports[0].Delay,
}},
ProfileExtensions: []byte{},
},
}, pkts)
pkts, _, err = audioSender.ReadRTCP()
require.NoError(t, err)
require.Equal(t, []rtcp.Packet{
&rtcp.ReceiverReport{
SSRC: pkts[0].(*rtcp.ReceiverReport).SSRC,
Reports: []rtcp.ReceptionReport{{
SSRC: uint32(audioSender.GetParameters().Encodings[0].SSRC),
LastSequenceNumber: pkts[0].(*rtcp.ReceiverReport).Reports[0].LastSequenceNumber,
LastSenderReport: pkts[0].(*rtcp.ReceiverReport).Reports[0].LastSenderReport,
Delay: pkts[0].(*rtcp.ReceiverReport).Reports[0].Delay,
}},
ProfileExtensions: []byte{},
},
}, pkts)
}
func TestPeerConnectionReadSimulcast(t *testing.T) {
pub, err := webrtc.NewPeerConnection(webrtc.Configuration{})
require.NoError(t, err)
defer pub.Close() //nolint:errcheck
videoTrackL, err := webrtc.NewTrackLocalStaticRTP(
webrtc.RTPCodecCapability{
MimeType: webrtc.MimeTypeVP8,
ClockRate: 90000,
},
"video", "publisher",
webrtc.WithRTPStreamID("l"),
)
require.NoError(t, err)
videoTrackM, err := webrtc.NewTrackLocalStaticRTP(
webrtc.RTPCodecCapability{
MimeType: webrtc.MimeTypeVP8,
ClockRate: 90000,
},
"video", "publisher",
webrtc.WithRTPStreamID("m"),
)
require.NoError(t, err)
videoTrackH, err := webrtc.NewTrackLocalStaticRTP(
webrtc.RTPCodecCapability{
MimeType: webrtc.MimeTypeVP8,
ClockRate: 90000,
},
"video", "publisher",
webrtc.WithRTPStreamID("h"),
)
require.NoError(t, err)
transceiver, err := pub.AddTransceiverFromTrack(videoTrackL, webrtc.RTPTransceiverInit{
Direction: webrtc.RTPTransceiverDirectionSendonly,
SendEncodings: []webrtc.RTPEncodingParameters{
{RTPCodingParameters: webrtc.RTPCodingParameters{RID: "l"}},
{RTPCodingParameters: webrtc.RTPCodingParameters{RID: "m"}},
{RTPCodingParameters: webrtc.RTPCodingParameters{RID: "h"}},
},
})
require.NoError(t, err)
err = transceiver.Sender().AddEncoding(videoTrackM)
require.NoError(t, err)
err = transceiver.Sender().AddEncoding(videoTrackH)
require.NoError(t, err)
reader := &PeerConnection{
LocalRandomUDP: true,
IPsFromInterfaces: true,
Publish: false,
Log: test.NilLogger,
}
err = reader.Start()
require.NoError(t, err)
defer reader.Close()
offer, err := pub.CreateOffer(nil)
require.NoError(t, err)
err = pub.SetLocalDescription(offer)
require.NoError(t, err)
answer, err := reader.CreateFullAnswer(&offer)
require.NoError(t, err)
err = pub.SetRemoteDescription(*answer)
require.NoError(t, err)
err = reader.WaitUntilConnected(10 * time.Second)
require.NoError(t, err)
var midExtID, ridExtID uint8
for _, ext := range transceiver.Sender().GetParameters().HeaderExtensions {
switch ext.URI {
case sdp.SDESMidURI:
midExtID = uint8(ext.ID)
case sdp.SDESRTPStreamIDURI:
ridExtID = uint8(ext.ID)
}
}
require.NotZero(t, midExtID)
require.NotZero(t, ridExtID)
mid := transceiver.Mid()
go func() {
time.Sleep(200 * time.Millisecond)
layers := []struct {
track *webrtc.TrackLocalStaticRTP
rid string
ssrc uint32
seqNum uint16
}{
{videoTrackL, "l", 100001, 1000},
{videoTrackM, "m", 100002, 2000},
{videoTrackH, "h", 100003, 3000},
}
for i, layer := range layers {
pkt := &rtp.Packet{
Header: rtp.Header{
Version: 2,
Marker: true,
PayloadType: 96,
SequenceNumber: layer.seqNum,
Timestamp: 45343,
SSRC: layer.ssrc,
},
Payload: []byte{5, 2},
}
pkt.ExtensionProfile = 0xBEDE
require.NoError(t, pkt.SetExtension(midExtID, []byte(mid)))
require.NoError(t, pkt.SetExtension(ridExtID, []byte(layer.rid)))
err2 := layer.track.WriteRTP(pkt)
if err2 != nil {
return
}
layers[i].seqNum++
}
}()
err = reader.GatherIncomingTracks(5 * time.Second)
require.NoError(t, err)
tracks := reader.IncomingTracks()
codecs := gatherCodecs(tracks)
require.Equal(t, 3, len(codecs))
for _, codec := range codecs {
require.Equal(t, webrtc.RTPCodecCapability{
MimeType: webrtc.MimeTypeVP8,
ClockRate: 90000,
RTCPFeedback: codec.RTCPFeedback,
}, codec.RTPCodecCapability)
}
rids := make([]string, len(tracks))
for i, track := range tracks {
rids[i] = track.track.RID()
}
sort.Strings(rids)
require.Equal(t, []string{"h", "l", "m"}, rids)
}
func TestPeerConnectionPublishRead(t *testing.T) {
pc1 := &PeerConnection{
LocalRandomUDP: true,
IPsFromInterfaces: true,
Publish: false,
Log: test.NilLogger,
}
err := pc1.Start()
require.NoError(t, err)
defer pc1.Close()
pc2 := &PeerConnection{
LocalRandomUDP: true,
IPsFromInterfaces: true,
Publish: true,
OutgoingTracks: []*OutgoingTrack{
{
Caps: webrtc.RTPCodecCapability{
MimeType: webrtc.MimeTypeH264,
ClockRate: 90000,
},
},
{
Caps: webrtc.RTPCodecCapability{
MimeType: webrtc.MimeTypeOpus,
ClockRate: 48000,
Channels: 2,
},
},
},
Log: test.NilLogger,
}
err = pc2.Start()
require.NoError(t, err)
defer pc2.Close()
offer, err := pc1.CreatePartialOffer()
require.NoError(t, err)
answer, err := pc2.CreateFullAnswer(offer)
require.NoError(t, err)
err = pc1.SetAnswer(answer)
require.NoError(t, err)
err = pc1.WaitUntilConnected(10 * time.Second)
require.NoError(t, err)
err = pc2.WaitUntilConnected(10 * time.Second)
require.NoError(t, err)
for _, track := range pc2.OutgoingTracks {
err = track.WriteRTP(&rtp.Packet{
Header: rtp.Header{
Version: 2,
Marker: true,
PayloadType: 111,
SequenceNumber: 1123,
Timestamp: 45343,
SSRC: 563424,
},
Payload: []byte{5, 2},
})
require.NoError(t, err)
}
err = pc1.GatherIncomingTracks(2 * time.Second)
require.NoError(t, err)
codecs := gatherCodecs(pc1.IncomingTracks())
sort.Slice(codecs, func(i, j int) bool {
return codecs[i].PayloadType < codecs[j].PayloadType
})
require.Equal(t, []webrtc.RTPCodecParameters{
{
RTPCodecCapability: webrtc.RTPCodecCapability{
MimeType: webrtc.MimeTypeH264,
ClockRate: 90000,
SDPFmtpLine: "level-asymmetry-allowed=1;packetization-mode=1;profile-level-id=42001f",
RTCPFeedback: codecs[0].RTCPFeedback,
},
PayloadType: 105,
},
{
RTPCodecCapability: webrtc.RTPCodecCapability{
MimeType: webrtc.MimeTypeOpus,
ClockRate: 48000,
Channels: 2,
SDPFmtpLine: "minptime=10;useinbandfec=1;stereo=1;sprop-stereo=1",
RTCPFeedback: codecs[1].RTCPFeedback,
},
PayloadType: 111,
},
}, codecs)
}
// test that an audio codec is present regardless of the fact that an audio track is.
func TestPeerConnectionFallbackCodecs(t *testing.T) {
pc1 := &PeerConnection{
LocalRandomUDP: true,
IPsFromInterfaces: true,
Publish: false,
Log: test.NilLogger,
}
err := pc1.Start()
require.NoError(t, err)
defer pc1.Close()
pc2 := &PeerConnection{
LocalRandomUDP: true,
IPsFromInterfaces: true,
Publish: true,
OutgoingTracks: []*OutgoingTrack{{
Caps: webrtc.RTPCodecCapability{
MimeType: webrtc.MimeTypeAV1,
ClockRate: 90000,
},
}},
Log: test.NilLogger,
}
err = pc2.Start()
require.NoError(t, err)
defer pc2.Close()
offer, err := pc1.CreatePartialOffer()
require.NoError(t, err)
answer, err := pc2.CreateFullAnswer(offer)
require.NoError(t, err)
var s sdp.SessionDescription
err = s.Unmarshal([]byte(answer.SDP))
require.NoError(t, err)
require.Equal(t, []*sdp.MediaDescription{
{
MediaName: sdp.MediaName{
Media: "video",
Port: sdp.RangedPort{Value: 9},
Protos: []string{"UDP", "TLS", "RTP", "SAVPF"},
Formats: []string{"97"},
},
ConnectionInformation: s.MediaDescriptions[0].ConnectionInformation,
Attributes: s.MediaDescriptions[0].Attributes,
},
{
MediaName: sdp.MediaName{
Media: "audio",
Port: sdp.RangedPort{Value: 9},
Protos: []string{"UDP", "TLS", "RTP", "SAVPF"},
Formats: []string{"0"},
},
ConnectionInformation: s.MediaDescriptions[1].ConnectionInformation,
Attributes: s.MediaDescriptions[1].Attributes,
},
}, s.MediaDescriptions)
}
func TestPeerConnectionPublishDataChannel(t *testing.T) {
pc1, err := webrtc.NewPeerConnection(webrtc.Configuration{})
require.NoError(t, err)
defer pc1.Close() //nolint:errcheck
_, err = pc1.CreateDataChannel("", nil)
require.NoError(t, err)
dataChanCreated := make(chan struct{})
dataReceived := make(chan struct{})
pc1.OnDataChannel(func(dc *webrtc.DataChannel) {
close(dataChanCreated)
dc.OnMessage(func(msg webrtc.DataChannelMessage) {
require.Equal(t, []byte("test data"), msg.Data)
close(dataReceived)
})
})
offer, err := pc1.CreateOffer(nil)
require.NoError(t, err)
err = pc1.SetLocalDescription(offer)
require.NoError(t, err)
pc2 := &PeerConnection{
LocalRandomUDP: true,
IPsFromInterfaces: true,
Publish: true,
OutgoingDataChannels: []*OutgoingDataChannel{
{
Label: "test-channel",
},
},
Log: test.NilLogger,
}
err = pc2.Start()
require.NoError(t, err)
defer pc2.Close()
answer, err := pc2.CreateFullAnswer(&offer)
require.NoError(t, err)
err = pc1.SetRemoteDescription(*answer)
require.NoError(t, err)
err = pc2.WaitUntilConnected(10 * time.Second)
require.NoError(t, err)
<-dataChanCreated
pc2.OutgoingDataChannels[0].Write([]byte("test data"))
<-dataReceived
}
================================================
FILE: internal/protocols/webrtc/stats.go
================================================
package webrtc
// Stats are WebRTC statistics.
type Stats struct {
BytesReceived uint64
BytesSent uint64
RTPPacketsReceived uint64
RTPPacketsSent uint64
RTPPacketsLost uint64
RTPPacketsJitter float64
RTCPPacketsReceived uint64
RTCPPacketsSent uint64
}
================================================
FILE: internal/protocols/webrtc/stats_interceptor.go
================================================
package webrtc
import (
"sync/atomic"
"github.com/pion/interceptor"
"github.com/pion/rtcp"
)
type statsInterceptor struct {
rtcpPacketsSent *uint64
rtcpPacketsReceived *uint64
}
func (*statsInterceptor) Close() error {
return nil
}
func (s *statsInterceptor) BindRTCPReader(reader interceptor.RTCPReader) interceptor.RTCPReader {
return interceptor.RTCPReaderFunc(func(bytes []byte,
attributes interceptor.Attributes,
) (int, interceptor.Attributes, error) {
n, attrs, err := reader.Read(bytes, attributes)
pkts, err2 := attrs.GetRTCPPackets(bytes)
if err2 == nil {
atomic.AddUint64(s.rtcpPacketsReceived, uint64(len(pkts)))
}
return n, attrs, err
})
}
func (s *statsInterceptor) BindRTCPWriter(writer interceptor.RTCPWriter) interceptor.RTCPWriter {
return interceptor.RTCPWriterFunc(func(pkts []rtcp.Packet, attributes interceptor.Attributes) (int, error) {
atomic.AddUint64(s.rtcpPacketsSent, uint64(len(pkts)))
return writer.Write(pkts, attributes)
})
}
func (s *statsInterceptor) BindLocalStream(_ *interceptor.StreamInfo,
writer interceptor.RTPWriter,
) interceptor.RTPWriter {
return writer
}
func (*statsInterceptor) UnbindLocalStream(_ *interceptor.StreamInfo) {}
func (s *statsInterceptor) BindRemoteStream(_ *interceptor.StreamInfo,
reader interceptor.RTPReader,
) interceptor.RTPReader {
return reader
}
func (*statsInterceptor) UnbindRemoteStream(_ *interceptor.StreamInfo) {}
type statsInterceptorFactory struct {
onCreate func(s *statsInterceptor)
}
func (f *statsInterceptorFactory) NewInterceptor(_ string) (interceptor.Interceptor, error) {
s := &statsInterceptor{
rtcpPacketsSent: new(uint64),
rtcpPacketsReceived: new(uint64),
}
f.onCreate(s)
return s, nil
}
================================================
FILE: internal/protocols/webrtc/tcp_mux_wrapper.go
================================================
package webrtc
import (
"net"
"github.com/pion/ice/v4"
)
// TCPMuxWrapper is a wrapper around ice.TCPMux.
type TCPMuxWrapper struct {
Mux ice.TCPMux
Ln net.Listener
}
================================================
FILE: internal/protocols/webrtc/to_stream.go
================================================
package webrtc
import (
"errors"
"fmt"
"strings"
"time"
"github.com/bluenviron/gortsplib/v5/pkg/description"
"github.com/bluenviron/gortsplib/v5/pkg/format"
"github.com/bluenviron/gortsplib/v5/pkg/rtptime"
"github.com/bluenviron/mediamtx/internal/conf"
"github.com/bluenviron/mediamtx/internal/logger"
"github.com/bluenviron/mediamtx/internal/stream"
"github.com/bluenviron/mediamtx/internal/unit"
"github.com/pion/rtp"
"github.com/pion/webrtc/v4"
)
type ntpState int
const (
ntpStateInitial ntpState = iota
ntpStateReplace
ntpStateAvailable
)
var errNoSupportedCodecsTo = errors.New(
"the stream doesn't contain any supported codec, which are currently " +
"AV1, VP9, VP8, H265, H264, Opus, G722, G711, LPCM")
// ToStream maps a WebRTC connection to a MediaMTX stream.
func ToStream(
pc *PeerConnection,
pathConf *conf.Path,
subStream **stream.SubStream,
log logger.Writer,
) ([]*description.Media, error) {
var medias []*description.Media //nolint:prealloc
timeDecoder := &rtptime.GlobalDecoder{}
timeDecoder.Initialize()
for _, track := range pc.incomingTracks {
var typ description.MediaType
var forma format.Format
switch strings.ToLower(track.track.Codec().MimeType) {
case strings.ToLower(webrtc.MimeTypeAV1):
typ = description.MediaTypeVideo
forma = &format.AV1{
PayloadTyp: 96,
}
case strings.ToLower(webrtc.MimeTypeVP9):
typ = description.MediaTypeVideo
forma = &format.VP9{
PayloadTyp: 96,
}
case strings.ToLower(webrtc.MimeTypeVP8):
typ = description.MediaTypeVideo
forma = &format.VP8{
PayloadTyp: 96,
}
case strings.ToLower(webrtc.MimeTypeH265):
typ = description.MediaTypeVideo
forma = &format.H265{
PayloadTyp: 96,
}
case strings.ToLower(webrtc.MimeTypeH264):
typ = description.MediaTypeVideo
forma = &format.H264{
PayloadTyp: 96,
PacketizationMode: 1,
}
case strings.ToLower(mimeTypeMultiopus):
typ = description.MediaTypeAudio
forma = &format.Opus{
PayloadTyp: 96,
ChannelCount: int(track.track.Codec().Channels),
}
case strings.ToLower(webrtc.MimeTypeOpus):
typ = description.MediaTypeAudio
forma = &format.Opus{
PayloadTyp: 96,
ChannelCount: func() int {
if strings.Contains(track.track.Codec().SDPFmtpLine, "stereo=1") {
return 2
}
return 1
}(),
}
case strings.ToLower(webrtc.MimeTypeG722):
typ = description.MediaTypeAudio
forma = &format.G722{}
case strings.ToLower(webrtc.MimeTypePCMU):
channels := int(track.track.Codec().Channels)
if channels == 0 {
channels = 1
}
typ = description.MediaTypeAudio
forma = &format.G711{
PayloadTyp: func() uint8 {
if channels > 1 {
return 96
}
return 0
}(),
MULaw: true,
SampleRate: 8000,
ChannelCount: channels,
}
case strings.ToLower(webrtc.MimeTypePCMA):
channels := int(track.track.Codec().Channels)
if channels == 0 {
channels = 1
}
typ = description.MediaTypeAudio
forma = &format.G711{
PayloadTyp: func() uint8 {
if channels > 1 {
return 96
}
return 8
}(),
MULaw: false,
SampleRate: 8000,
ChannelCount: channels,
}
case strings.ToLower(mimeTypeL16):
typ = description.MediaTypeAudio
forma = &format.LPCM{
PayloadTyp: 96,
BitDepth: 16,
SampleRate: int(track.track.Codec().ClockRate),
ChannelCount: int(track.track.Codec().Channels),
}
default:
return nil, fmt.Errorf("unsupported codec: %+v", track.track.Codec().RTPCodecCapability)
}
medi := &description.Media{
Type: typ,
Formats: []format.Format{forma},
}
var ntpStat ntpState
if !pathConf.UseAbsoluteTimestamp {
ntpStat = ntpStateReplace
}
handleNTP := func(pkt *rtp.Packet) (time.Time, bool) {
switch ntpStat {
case ntpStateReplace:
return time.Time{}, true
case ntpStateInitial:
ntp, avail := track.PacketNTP(pkt)
if !avail {
log.Log(logger.Warn, "received RTP packet without absolute time, skipping it")
return time.Time{}, false
}
ntpStat = ntpStateAvailable
return ntp, true
default: // ntpStateAvailable
ntp, avail := track.PacketNTP(pkt)
if !avail {
panic("should not happen")
}
return ntp, true
}
}
track.OnPacketRTP = func(pkt *rtp.Packet) {
pkt.PayloadType = forma.PayloadType()
pts, ok := timeDecoder.Decode(track, pkt)
if !ok {
return
}
ntp, ok := handleNTP(pkt)
if !ok {
return
}
(*subStream).WriteUnit(medi, forma, &unit.Unit{
PTS: pts,
NTP: ntp,
RTPPackets: []*rtp.Packet{pkt},
})
}
medias = append(medias, medi)
}
if len(medias) == 0 {
return nil, errNoSupportedCodecsTo
}
return medias, nil
}
================================================
FILE: internal/protocols/webrtc/to_stream_test.go
================================================
package webrtc
import (
"testing"
"time"
"github.com/bluenviron/gortsplib/v5/pkg/format"
"github.com/bluenviron/mediamtx/internal/conf"
"github.com/bluenviron/mediamtx/internal/stream"
"github.com/bluenviron/mediamtx/internal/test"
"github.com/pion/rtp"
"github.com/pion/webrtc/v4"
"github.com/stretchr/testify/require"
)
func TestToStreamNoSupportedCodecs(t *testing.T) {
pc := &PeerConnection{}
_, err := ToStream(pc, &conf.Path{}, nil, nil)
require.Equal(t, errNoSupportedCodecsTo, err)
}
// this is impossible to test since unsupported tracks cause an error
// as they are not included inside incomingVideoCodecs or incomingAudioCodecs
// func TestToStreamSkipUnsupportedTracks(t *testing.T)
var toFromStreamCases = []struct {
name string
in format.Format
webrtcCaps webrtc.RTPCodecCapability
out format.Format
}{
{
"av1",
&format.AV1{
PayloadTyp: 96,
},
webrtc.RTPCodecCapability{
MimeType: "video/AV1",
ClockRate: 90000,
},
&format.AV1{
PayloadTyp: 96,
},
},
{
"vp9",
&format.VP9{
PayloadTyp: 96,
},
webrtc.RTPCodecCapability{
MimeType: "video/VP9",
ClockRate: 90000,
SDPFmtpLine: "profile-id=0",
},
&format.VP9{
PayloadTyp: 96,
},
},
{
"vp8",
&format.VP8{
PayloadTyp: 96,
},
webrtc.RTPCodecCapability{
MimeType: "video/VP8",
ClockRate: 90000,
},
&format.VP8{
PayloadTyp: 96,
},
},
{
"h265",
&format.H265{
PayloadTyp: 96,
},
webrtc.RTPCodecCapability{
MimeType: "video/H265",
ClockRate: 90000,
SDPFmtpLine: "level-id=93;profile-id=1;tier-flag=0;tx-mode=SRST",
},
&format.H265{
PayloadTyp: 96,
},
},
{
"h264",
test.FormatH264,
webrtc.RTPCodecCapability{
MimeType: "video/H264",
ClockRate: 90000,
SDPFmtpLine: "level-asymmetry-allowed=1;packetization-mode=1;profile-level-id=42e01f",
},
&format.H264{
PayloadTyp: 96,
PacketizationMode: 1,
},
},
{
"opus multichannel",
&format.Opus{
PayloadTyp: 96,
ChannelCount: 6,
},
webrtc.RTPCodecCapability{
MimeType: "audio/multiopus",
ClockRate: 48000,
Channels: 6,
SDPFmtpLine: "channel_mapping=0,4,1,2,3,5;num_streams=4;coupled_streams=2",
},
&format.Opus{
PayloadTyp: 96,
ChannelCount: 6,
},
},
{
"opus stereo",
&format.Opus{
PayloadTyp: 96,
ChannelCount: 2,
},
webrtc.RTPCodecCapability{
MimeType: "audio/opus",
ClockRate: 48000,
Channels: 2,
SDPFmtpLine: "minptime=10;useinbandfec=1;stereo=1;sprop-stereo=1",
},
&format.Opus{
PayloadTyp: 96,
ChannelCount: 2,
},
},
{
"opus mono",
&format.Opus{
PayloadTyp: 96,
ChannelCount: 1,
},
webrtc.RTPCodecCapability{
MimeType: "audio/opus",
ClockRate: 48000,
Channels: 2,
SDPFmtpLine: "minptime=10;useinbandfec=1",
},
&format.Opus{
PayloadTyp: 96,
ChannelCount: 1,
},
},
{
"g722",
&format.G722{},
webrtc.RTPCodecCapability{
MimeType: "audio/G722",
ClockRate: 8000,
},
&format.G722{},
},
{
"g711 pcma 8khz mono",
&format.G711{
PayloadTyp: 8,
SampleRate: 8000,
ChannelCount: 1,
},
webrtc.RTPCodecCapability{
MimeType: "audio/PCMA",
ClockRate: 8000,
},
&format.G711{
PayloadTyp: 8,
SampleRate: 8000,
ChannelCount: 1,
},
},
{
"g711 pcmu 8khz mono",
&format.G711{
MULaw: true,
PayloadTyp: 0,
SampleRate: 8000,
ChannelCount: 1,
},
webrtc.RTPCodecCapability{
MimeType: "audio/PCMU",
ClockRate: 8000,
},
&format.G711{
MULaw: true,
PayloadTyp: 0,
SampleRate: 8000,
ChannelCount: 1,
},
},
{
"g711 pcma 8khz stereo",
&format.G711{
PayloadTyp: 96,
SampleRate: 8000,
ChannelCount: 2,
},
webrtc.RTPCodecCapability{
MimeType: "audio/PCMA",
ClockRate: 8000,
Channels: 2,
},
&format.G711{
PayloadTyp: 96,
SampleRate: 8000,
ChannelCount: 2,
},
},
{
"g711 pcmu 8khz stereo",
&format.G711{
MULaw: true,
PayloadTyp: 96,
SampleRate: 8000,
ChannelCount: 2,
},
webrtc.RTPCodecCapability{
MimeType: "audio/PCMU",
ClockRate: 8000,
Channels: 2,
},
&format.G711{
MULaw: true,
PayloadTyp: 96,
SampleRate: 8000,
ChannelCount: 2,
},
},
{
"g711 pcma 16khz stereo",
&format.G711{
PayloadTyp: 96,
SampleRate: 16000,
ChannelCount: 2,
},
webrtc.RTPCodecCapability{
MimeType: "audio/L16",
ClockRate: 16000,
Channels: 2,
},
&format.LPCM{
PayloadTyp: 96,
BitDepth: 16,
SampleRate: 16000,
ChannelCount: 2,
},
},
{
"g711 pcmu 16khz stereo",
&format.G711{
MULaw: true,
PayloadTyp: 96,
SampleRate: 16000,
ChannelCount: 2,
},
webrtc.RTPCodecCapability{
MimeType: "audio/L16",
ClockRate: 16000,
Channels: 2,
},
&format.LPCM{
PayloadTyp: 96,
BitDepth: 16,
SampleRate: 16000,
ChannelCount: 2,
},
},
{
"l16 8khz stereo",
&format.LPCM{
PayloadTyp: 96,
BitDepth: 16,
SampleRate: 8000,
ChannelCount: 2,
},
webrtc.RTPCodecCapability{
MimeType: "audio/L16",
ClockRate: 8000,
Channels: 2,
},
&format.LPCM{
PayloadTyp: 96,
BitDepth: 16,
SampleRate: 8000,
ChannelCount: 2,
},
},
{
"l16 16khz stereo",
&format.LPCM{
PayloadTyp: 96,
BitDepth: 16,
SampleRate: 16000,
ChannelCount: 2,
},
webrtc.RTPCodecCapability{
MimeType: "audio/L16",
ClockRate: 16000,
Channels: 2,
},
&format.LPCM{
PayloadTyp: 96,
BitDepth: 16,
SampleRate: 16000,
ChannelCount: 2,
},
},
{
"l16 48khz stereo",
&format.LPCM{
PayloadTyp: 96,
BitDepth: 16,
SampleRate: 48000,
ChannelCount: 2,
},
webrtc.RTPCodecCapability{
MimeType: "audio/L16",
ClockRate: 48000,
Channels: 2,
},
&format.LPCM{
PayloadTyp: 96,
BitDepth: 16,
SampleRate: 48000,
ChannelCount: 2,
},
},
}
func TestToStream(t *testing.T) {
for _, ca := range toFromStreamCases {
t.Run(ca.name, func(t *testing.T) {
pc1 := &PeerConnection{
LocalRandomUDP: true,
IPsFromInterfaces: true,
Publish: true,
OutgoingTracks: []*OutgoingTrack{{
Caps: ca.webrtcCaps,
}},
Log: test.NilLogger,
}
err := pc1.Start()
require.NoError(t, err)
defer pc1.Close()
pc2 := &PeerConnection{
LocalRandomUDP: true,
IPsFromInterfaces: true,
Publish: false,
Log: test.NilLogger,
}
err = pc2.Start()
require.NoError(t, err)
defer pc2.Close()
offer, err := pc1.CreatePartialOffer()
require.NoError(t, err)
answer, err := pc2.CreateFullAnswer(offer)
require.NoError(t, err)
err = pc1.SetAnswer(answer)
require.NoError(t, err)
go func() {
for {
select {
case cnd := <-pc1.NewLocalCandidate():
err2 := pc2.AddRemoteCandidate(cnd)
require.NoError(t, err2)
case <-pc1.Connected():
return
}
}
}()
err = pc1.WaitUntilConnected(10 * time.Second)
require.NoError(t, err)
err = pc2.WaitUntilConnected(10 * time.Second)
require.NoError(t, err)
err = pc1.OutgoingTracks[0].WriteRTP(&rtp.Packet{
Header: rtp.Header{
Version: 2,
Marker: true,
PayloadType: 111,
SequenceNumber: 1123,
Timestamp: 45343,
SSRC: 563424,
},
Payload: []byte{5, 2},
})
require.NoError(t, err)
err = pc2.GatherIncomingTracks(2 * time.Second)
require.NoError(t, err)
var subStream *stream.SubStream
medias, err := ToStream(pc2, &conf.Path{}, &subStream, nil)
require.NoError(t, err)
require.Equal(t, ca.out, medias[0].Formats[0])
})
}
}
================================================
FILE: internal/protocols/websocket/serverconn.go
================================================
// Package websocket provides WebSocket connectivity.
package websocket
import (
"encoding/json"
"fmt"
"net"
"net/http"
"time"
"github.com/gorilla/websocket"
)
var (
pingInterval = 30 * time.Second
pingTimeout = 5 * time.Second
writeTimeout = 2 * time.Second
)
var upgrader = websocket.Upgrader{
CheckOrigin: func(_ *http.Request) bool {
return true
},
}
// ServerConn is a server-side WebSocket connection with
// automatic, periodic ping-pong
type ServerConn struct {
wc *websocket.Conn
// in
terminate chan struct{}
write chan []byte
// out
writeErr chan error
}
// NewServerConn allocates a ServerConn.
func NewServerConn(w http.ResponseWriter, req *http.Request) (*ServerConn, error) {
wc, err := upgrader.Upgrade(w, req, nil)
if err != nil {
return nil, err
}
c := &ServerConn{
wc: wc,
terminate: make(chan struct{}),
write: make(chan []byte),
writeErr: make(chan error),
}
go c.run()
return c, nil
}
// Close closes a ServerConn.
func (c *ServerConn) Close() {
c.wc.Close() //nolint:errcheck
close(c.terminate)
}
// RemoteAddr returns the remote address.
func (c *ServerConn) RemoteAddr() net.Addr {
return c.wc.RemoteAddr()
}
func (c *ServerConn) run() {
c.wc.SetReadDeadline(time.Now().Add(pingInterval + pingTimeout)) //nolint:errcheck
c.wc.SetPongHandler(func(string) error {
c.wc.SetReadDeadline(time.Now().Add(pingInterval + pingTimeout)) //nolint:errcheck
return nil
})
pingTicker := time.NewTicker(pingInterval)
defer pingTicker.Stop()
for {
select {
case byts := <-c.write:
c.wc.SetWriteDeadline(time.Now().Add(writeTimeout)) //nolint:errcheck
err := c.wc.WriteMessage(websocket.TextMessage, byts)
c.writeErr <- err
case <-pingTicker.C:
c.wc.SetWriteDeadline(time.Now().Add(writeTimeout)) //nolint:errcheck
c.wc.WriteMessage(websocket.PingMessage, nil) //nolint:errcheck
case <-c.terminate:
return
}
}
}
// ReadJSON reads a JSON object.
func (c *ServerConn) ReadJSON(in any) error {
return c.wc.ReadJSON(in)
}
// WriteJSON writes a JSON object.
func (c *ServerConn) WriteJSON(in any) error {
byts, err := json.Marshal(in)
if err != nil {
return err
}
select {
case c.write <- byts:
return <-c.writeErr
case <-c.terminate:
return fmt.Errorf("terminated")
}
}
================================================
FILE: internal/protocols/websocket/serverconn_test.go
================================================
package websocket
import (
"context"
"net"
"net/http"
"testing"
"time"
"github.com/gorilla/websocket"
"github.com/stretchr/testify/require"
)
func TestServerConn(t *testing.T) {
pingReceived := make(chan struct{})
pingInterval = 100 * time.Millisecond
s := &http.Server{
Handler: http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
c, err := NewServerConn(w, r)
require.NoError(t, err)
defer c.Close()
err = c.WriteJSON("testing")
require.NoError(t, err)
<-pingReceived
}),
}
ln, err := net.Listen("tcp", "localhost:6344")
require.NoError(t, err)
go s.Serve(ln)
defer s.Shutdown(context.Background())
c, res, err := websocket.DefaultDialer.Dial("ws://localhost:6344/", nil)
require.NoError(t, err)
defer res.Body.Close()
defer c.Close() //nolint:errcheck
c.SetPingHandler(func(_ string) error {
close(pingReceived)
return nil
})
var msg string
err = c.ReadJSON(&msg)
require.NoError(t, err)
require.Equal(t, "testing", msg)
_, _, err = c.ReadMessage()
require.Error(t, err)
<-pingReceived
}
================================================
FILE: internal/protocols/whip/client.go
================================================
// Package whip contains a WHIP/WHEP client.
package whip
import (
"bytes"
"context"
"fmt"
"io"
"net/http"
"net/url"
"time"
"github.com/pion/sdp/v3"
pwebrtc "github.com/pion/webrtc/v4"
"github.com/bluenviron/mediamtx/internal/logger"
"github.com/bluenviron/mediamtx/internal/protocols/httpp"
"github.com/bluenviron/mediamtx/internal/protocols/webrtc"
)
// Client is a WHIP client.
type Client struct {
URL *url.URL
Publish bool
OutgoingTracks []*webrtc.OutgoingTrack
HTTPClient *http.Client
BearerToken string
UDPReadBufferSize uint
STUNGatherTimeout time.Duration
HandshakeTimeout time.Duration
TrackGatherTimeout time.Duration
Log logger.Writer
pc *webrtc.PeerConnection
patchIsSupported bool
}
// Initialize initializes the Client.
func (c *Client) Initialize(ctx context.Context) error {
if c.STUNGatherTimeout == 0 {
c.STUNGatherTimeout = 5 * time.Second
}
if c.HandshakeTimeout == 0 {
c.HandshakeTimeout = 10 * time.Second
}
if c.TrackGatherTimeout == 0 {
c.TrackGatherTimeout = 2 * time.Second
}
iceServers, err := c.optionsICEServers(ctx)
if err != nil {
return err
}
c.pc = &webrtc.PeerConnection{
UDPReadBufferSize: c.UDPReadBufferSize,
LocalRandomUDP: true,
ICEServers: iceServers,
IPsFromInterfaces: true,
Publish: c.Publish,
STUNGatherTimeout: c.STUNGatherTimeout,
OutgoingTracks: c.OutgoingTracks,
Log: c.Log,
}
err = c.pc.Start()
if err != nil {
return err
}
initializeRes := make(chan error)
go func() {
initializeRes <- c.initializeInner(ctx)
}()
select {
case <-ctx.Done():
c.pc.Close()
<-initializeRes
return fmt.Errorf("terminated")
case err = <-initializeRes:
}
if err != nil {
c.pc.Close()
return err
}
return nil
}
func (c *Client) initializeInner(ctx context.Context) error {
offer, err := c.pc.CreatePartialOffer()
if err != nil {
return err
}
res, err := c.postOffer(ctx, offer)
if err != nil {
return err
}
c.URL, err = c.URL.Parse(res.Location)
if err != nil {
return err
}
if !c.Publish {
var sdp sdp.SessionDescription
err = sdp.Unmarshal([]byte(res.Answer.SDP))
if err != nil {
c.deleteSession(context.Background()) //nolint:errcheck
return err
}
err = webrtc.TracksAreValid(sdp.MediaDescriptions)
if err != nil {
c.deleteSession(context.Background()) //nolint:errcheck
return err
}
}
err = c.pc.SetAnswer(res.Answer)
if err != nil {
c.deleteSession(context.Background()) //nolint:errcheck
return err
}
t := time.NewTimer(c.HandshakeTimeout)
defer t.Stop()
outer:
for {
select {
case ca := <-c.pc.NewLocalCandidate():
err = c.patchCandidate(ctx, offer, res.ETag, ca)
if err != nil {
c.deleteSession(context.Background()) //nolint:errcheck
return err
}
case <-c.pc.GatheringDone():
case <-c.pc.Connected():
break outer
case <-t.C:
c.deleteSession(context.Background()) //nolint:errcheck
return fmt.Errorf("deadline exceeded while waiting connection")
}
}
if !c.Publish {
err = c.pc.GatherIncomingTracks(c.TrackGatherTimeout)
if err != nil {
c.deleteSession(context.Background()) //nolint:errcheck
return err
}
}
return nil
}
// PeerConnection returns the underlying peer connection.
func (c *Client) PeerConnection() *webrtc.PeerConnection {
return c.pc
}
// IncomingTracks returns incoming tracks.
func (c *Client) IncomingTracks() []*webrtc.IncomingTrack {
return c.pc.IncomingTracks()
}
// StartReading starts reading all incoming tracks.
func (c *Client) StartReading() {
c.pc.StartReading()
}
// Close closes the client.
func (c *Client) Close() error {
err := c.deleteSession(context.Background())
c.pc.Close()
return err
}
// Wait waits until a fatal error.
func (c *Client) Wait() error {
<-c.pc.Failed()
return fmt.Errorf("peer connection closed")
}
func (c *Client) optionsICEServers(
ctx context.Context,
) ([]pwebrtc.ICEServer, error) {
req, err := http.NewRequestWithContext(ctx, http.MethodOptions, c.URL.String(), nil)
if err != nil {
return nil, err
}
if c.BearerToken != "" {
req.Header.Set("Authorization", "Bearer "+c.BearerToken)
}
res, err := c.HTTPClient.Do(req)
if err != nil {
return nil, err
}
defer res.Body.Close()
if res.StatusCode != http.StatusOK && res.StatusCode != http.StatusNoContent {
return nil, fmt.Errorf("bad status code: %v", res.StatusCode)
}
return LinkHeaderUnmarshal(res.Header["Link"])
}
type whipPostOfferResponse struct {
Answer *pwebrtc.SessionDescription
Location string
ETag string
}
func (c *Client) postOffer(
ctx context.Context,
offer *pwebrtc.SessionDescription,
) (*whipPostOfferResponse, error) {
req, err := http.NewRequestWithContext(ctx, http.MethodPost, c.URL.String(), bytes.NewReader([]byte(offer.SDP)))
if err != nil {
return nil, err
}
if c.BearerToken != "" {
req.Header.Set("Authorization", "Bearer "+c.BearerToken)
}
req.Header.Set("Content-Type", "application/sdp")
res, err := c.HTTPClient.Do(req)
if err != nil {
return nil, err
}
defer res.Body.Close()
if res.StatusCode != http.StatusCreated {
return nil, fmt.Errorf("bad status code: %v", res.StatusCode)
}
contentType := httpp.ParseContentType(req.Header.Get("Content-Type"))
if contentType != "application/sdp" {
return nil, fmt.Errorf("bad Content-Type: expected 'application/sdp', got '%s'", contentType)
}
c.patchIsSupported = (res.Header.Get("Accept-Patch") == "application/trickle-ice-sdpfrag")
Location := res.Header.Get("Location")
etag := res.Header.Get("ETag")
if etag == "" {
return nil, fmt.Errorf("ETag is missing")
}
sdp, err := io.ReadAll(res.Body)
if err != nil {
return nil, err
}
answer := &pwebrtc.SessionDescription{
Type: pwebrtc.SDPTypeAnswer,
SDP: string(sdp),
}
return &whipPostOfferResponse{
Answer: answer,
Location: Location,
ETag: etag,
}, nil
}
func (c *Client) patchCandidate(
ctx context.Context,
offer *pwebrtc.SessionDescription,
etag string,
candidate *pwebrtc.ICECandidateInit,
) error {
if !c.patchIsSupported {
return nil
}
frag, err := ICEFragmentMarshal(offer.SDP, []*pwebrtc.ICECandidateInit{candidate})
if err != nil {
return err
}
req, err := http.NewRequestWithContext(ctx, http.MethodPatch, c.URL.String(), bytes.NewReader(frag))
if err != nil {
return err
}
if c.BearerToken != "" {
req.Header.Set("Authorization", "Bearer "+c.BearerToken)
}
req.Header.Set("Content-Type", "application/trickle-ice-sdpfrag")
req.Header.Set("If-Match", etag)
res, err := c.HTTPClient.Do(req)
if err != nil {
return err
}
defer res.Body.Close()
if res.StatusCode != http.StatusNoContent {
return fmt.Errorf("bad status code: %v", res.StatusCode)
}
return nil
}
func (c *Client) deleteSession(
ctx context.Context,
) error {
req, err := http.NewRequestWithContext(ctx, http.MethodDelete, c.URL.String(), nil)
if err != nil {
return err
}
if c.BearerToken != "" {
req.Header.Set("Authorization", "Bearer "+c.BearerToken)
}
res, err := c.HTTPClient.Do(req)
if err != nil {
return err
}
defer res.Body.Close()
if res.StatusCode != http.StatusOK {
return fmt.Errorf("bad status code: %v", res.StatusCode)
}
return nil
}
================================================
FILE: internal/protocols/whip/client_test.go
================================================
package whip
import (
"context"
"io"
"net"
"net/http"
"net/url"
"sort"
"testing"
"time"
"github.com/bluenviron/mediamtx/internal/protocols/webrtc"
"github.com/bluenviron/mediamtx/internal/test"
"github.com/pion/rtp"
pwebrtc "github.com/pion/webrtc/v4"
"github.com/stretchr/testify/require"
)
func whipOffer(body []byte) *pwebrtc.SessionDescription {
return &pwebrtc.SessionDescription{
Type: pwebrtc.SDPTypeOffer,
SDP: string(body),
}
}
func gatherCodecs(tracks []*webrtc.IncomingTrack) []pwebrtc.RTPCodecParameters {
codecs := make([]pwebrtc.RTPCodecParameters, len(tracks))
for i, track := range tracks {
codecs[i] = track.Codec()
}
return codecs
}
func TestClientRead(t *testing.T) {
for _, ca := range []string{
"audio",
"video+audio",
} {
t.Run(ca, func(t *testing.T) {
var outgoingTracks []*webrtc.OutgoingTrack
switch ca {
case "audio":
outgoingTracks = []*webrtc.OutgoingTrack{{
Caps: pwebrtc.RTPCodecCapability{
MimeType: "audio/opus",
ClockRate: 48000,
Channels: 2,
},
}}
case "video+audio":
outgoingTracks = []*webrtc.OutgoingTrack{
{
Caps: pwebrtc.RTPCodecCapability{
MimeType: "video/H264",
ClockRate: 90000,
},
},
{
Caps: pwebrtc.RTPCodecCapability{
MimeType: "audio/opus",
ClockRate: 48000,
Channels: 2,
},
},
}
}
pc := &webrtc.PeerConnection{
LocalRandomUDP: true,
IPsFromInterfaces: true,
Publish: true,
OutgoingTracks: outgoingTracks,
Log: test.NilLogger,
}
err := pc.Start()
require.NoError(t, err)
defer pc.Close()
state := 0
httpServ := &http.Server{
Handler: http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
switch state {
case 0:
require.Equal(t, http.MethodOptions, r.Method)
require.Equal(t, "/my/resource", r.URL.Path)
w.Header().Set("Access-Control-Allow-Methods", "OPTIONS, GET, POST, PATCH")
w.Header().Set("Access-Control-Allow-Headers", "Authorization, Content-Type, If-Match")
w.WriteHeader(http.StatusNoContent)
case 1:
require.Equal(t, http.MethodPost, r.Method)
require.Equal(t, "/my/resource", r.URL.Path)
require.Equal(t, "application/sdp", r.Header.Get("Content-Type"))
body, err2 := io.ReadAll(r.Body)
require.NoError(t, err2)
offer := whipOffer(body)
answer, err2 := pc.CreateFullAnswer(offer)
require.NoError(t, err2)
w.Header().Set("Content-Type", "application/sdp")
w.Header().Set("Accept-Patch", "application/trickle-ice-sdpfrag")
w.Header().Set("ETag", "test_etag")
w.Header().Set("Location", "/my/resource/sessionid")
w.WriteHeader(http.StatusCreated)
w.Write([]byte(answer.SDP))
go func() {
err3 := pc.WaitUntilConnected(10 * time.Second)
require.NoError(t, err3)
for _, track := range outgoingTracks {
err3 = track.WriteRTP(&rtp.Packet{
Header: rtp.Header{
Version: 2,
Marker: true,
PayloadType: 111,
SequenceNumber: 1123,
Timestamp: 45343,
SSRC: 563424,
},
Payload: []byte{5, 2},
})
require.NoError(t, err3)
}
}()
default:
require.Equal(t, "/my/resource/sessionid", r.URL.Path)
switch r.Method {
case http.MethodPatch:
w.WriteHeader(http.StatusNoContent)
case http.MethodDelete:
w.WriteHeader(http.StatusOK)
default:
t.Errorf("should not happen")
}
}
state++
}),
}
ln, err := net.Listen("tcp", "localhost:9005")
require.NoError(t, err)
go httpServ.Serve(ln)
defer httpServ.Shutdown(context.Background())
u, err := url.Parse("http://localhost:9005/my/resource")
require.NoError(t, err)
cl := &Client{
URL: u,
HTTPClient: &http.Client{},
Log: test.NilLogger,
}
err = cl.Initialize(context.Background())
require.NoError(t, err)
defer cl.Close() //nolint:errcheck
codecs := gatherCodecs(cl.IncomingTracks())
switch ca {
case "audio":
require.Equal(t, []pwebrtc.RTPCodecParameters{
{
RTPCodecCapability: pwebrtc.RTPCodecCapability{
MimeType: pwebrtc.MimeTypeOpus,
ClockRate: 48000,
Channels: 2,
SDPFmtpLine: "minptime=10;useinbandfec=1;stereo=1;sprop-stereo=1",
RTCPFeedback: []pwebrtc.RTCPFeedback{{
Type: "transport-cc",
}},
},
PayloadType: 111,
},
}, codecs)
case "video+audio":
sort.Slice(codecs, func(i, j int) bool {
return codecs[i].PayloadType < codecs[j].PayloadType
})
require.Equal(t, []pwebrtc.RTPCodecParameters{
{
RTPCodecCapability: pwebrtc.RTPCodecCapability{
MimeType: pwebrtc.MimeTypeH264,
ClockRate: 90000,
SDPFmtpLine: "level-asymmetry-allowed=1;packetization-mode=1;profile-level-id=42001f",
RTCPFeedback: codecs[0].RTCPFeedback,
},
PayloadType: 105,
},
{
RTPCodecCapability: pwebrtc.RTPCodecCapability{
MimeType: pwebrtc.MimeTypeOpus,
ClockRate: 48000,
Channels: 2,
SDPFmtpLine: "minptime=10;useinbandfec=1;stereo=1;sprop-stereo=1",
RTCPFeedback: codecs[1].RTCPFeedback,
},
PayloadType: 111,
},
}, codecs)
}
recv := make([]chan struct{}, len(outgoingTracks))
for i := range outgoingTracks {
recv[i] = make(chan struct{})
}
for i, track := range cl.IncomingTracks() {
ci := i
track.OnPacketRTP = func(_ *rtp.Packet) {
close(recv[ci])
}
}
cl.StartReading()
for _, rv := range recv {
<-rv
}
})
}
}
func TestClientPublish(t *testing.T) {
for _, ca := range []string{"audio", "video+audio"} {
t.Run(ca, func(t *testing.T) {
pc := &webrtc.PeerConnection{
LocalRandomUDP: true,
IPsFromInterfaces: true,
Log: test.NilLogger,
}
err := pc.Start()
require.NoError(t, err)
defer pc.Close()
state := 0
var recv []chan struct{}
httpServ := &http.Server{
Handler: http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
switch state {
case 0:
require.Equal(t, http.MethodOptions, r.Method)
require.Equal(t, "/my/resource", r.URL.Path)
w.Header().Set("Access-Control-Allow-Methods", "OPTIONS, GET, POST, PATCH")
w.Header().Set("Access-Control-Allow-Headers", "Authorization, Content-Type, If-Match")
w.WriteHeader(http.StatusNoContent)
case 1:
require.Equal(t, http.MethodPost, r.Method)
require.Equal(t, "/my/resource", r.URL.Path)
require.Equal(t, "application/sdp", r.Header.Get("Content-Type"))
body, err2 := io.ReadAll(r.Body)
require.NoError(t, err2)
offer := whipOffer(body)
answer, err2 := pc.CreateFullAnswer(offer)
require.NoError(t, err2)
w.Header().Set("Content-Type", "application/sdp")
w.Header().Set("Accept-Patch", "application/trickle-ice-sdpfrag")
w.Header().Set("ETag", "test_etag")
w.Header().Set("Location", "/my/resource/sessionid")
w.WriteHeader(http.StatusCreated)
w.Write([]byte(answer.SDP))
go func() {
err3 := pc.WaitUntilConnected(10 * time.Second)
require.NoError(t, err3)
err3 = pc.GatherIncomingTracks(2 * time.Second)
require.NoError(t, err3)
codecs := gatherCodecs(pc.IncomingTracks())
switch ca {
case "audio":
require.Equal(t, []pwebrtc.RTPCodecParameters{
{
RTPCodecCapability: pwebrtc.RTPCodecCapability{
MimeType: pwebrtc.MimeTypeOpus,
ClockRate: 48000,
Channels: 2,
SDPFmtpLine: "",
RTCPFeedback: codecs[0].RTCPFeedback,
},
PayloadType: 96,
},
}, codecs)
case "video+audio":
sort.Slice(codecs, func(i, j int) bool {
return codecs[i].PayloadType < codecs[j].PayloadType
})
require.Equal(t, []pwebrtc.RTPCodecParameters{
{
RTPCodecCapability: pwebrtc.RTPCodecCapability{
MimeType: pwebrtc.MimeTypeH264,
ClockRate: 90000,
RTCPFeedback: codecs[0].RTCPFeedback,
},
PayloadType: 96,
},
{
RTPCodecCapability: pwebrtc.RTPCodecCapability{
MimeType: pwebrtc.MimeTypeOpus,
ClockRate: 48000,
Channels: 2,
SDPFmtpLine: "",
RTCPFeedback: codecs[1].RTCPFeedback,
},
PayloadType: 97,
},
}, codecs)
}
for i, track := range pc.IncomingTracks() {
ci := i
track.OnPacketRTP = func(_ *rtp.Packet) {
close(recv[ci])
}
}
pc.StartReading()
}()
default:
require.Equal(t, "/my/resource/sessionid", r.URL.Path)
switch r.Method {
case http.MethodPatch:
w.WriteHeader(http.StatusNoContent)
case http.MethodDelete:
w.WriteHeader(http.StatusOK)
default:
t.Errorf("should not happen")
}
}
state++
}),
}
ln, err := net.Listen("tcp", "localhost:9005")
require.NoError(t, err)
go httpServ.Serve(ln)
defer httpServ.Shutdown(context.Background())
u, err := url.Parse("http://localhost:9005/my/resource")
require.NoError(t, err)
var outgoingTracks []*webrtc.OutgoingTrack
switch ca {
case "audio":
outgoingTracks = []*webrtc.OutgoingTrack{{
Caps: pwebrtc.RTPCodecCapability{
MimeType: "audio/opus",
ClockRate: 48000,
Channels: 2,
},
}}
case "video+audio":
outgoingTracks = []*webrtc.OutgoingTrack{
{
Caps: pwebrtc.RTPCodecCapability{
MimeType: "video/H264",
ClockRate: 90000,
},
},
{
Caps: pwebrtc.RTPCodecCapability{
MimeType: "audio/opus",
ClockRate: 48000,
Channels: 2,
},
},
}
}
recv = make([]chan struct{}, len(outgoingTracks))
for i := range outgoingTracks {
recv[i] = make(chan struct{})
}
cl := &Client{
URL: u,
Publish: true,
OutgoingTracks: outgoingTracks,
HTTPClient: &http.Client{},
Log: test.NilLogger,
}
err = cl.Initialize(context.Background())
require.NoError(t, err)
defer cl.Close() //nolint:errcheck
for _, track := range cl.OutgoingTracks {
err = track.WriteRTP(&rtp.Packet{
Header: rtp.Header{
Version: 2,
Marker: true,
PayloadType: 111,
SequenceNumber: 1123,
Timestamp: 45343,
SSRC: 563424,
},
Payload: []byte{5, 2},
})
require.NoError(t, err)
}
for _, rv := range recv {
<-rv
}
})
}
}
func TestClientBearerToken(t *testing.T) {
pc := &webrtc.PeerConnection{
LocalRandomUDP: true,
IPsFromInterfaces: true,
Log: test.NilLogger,
}
err := pc.Start()
require.NoError(t, err)
defer pc.Close()
httpServ := &http.Server{
Handler: http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
require.Equal(t, "Bearer my_secret_token", r.Header.Get("Authorization"))
switch r.Method {
case http.MethodOptions:
w.WriteHeader(http.StatusNoContent)
case http.MethodPost:
body, err2 := io.ReadAll(r.Body)
require.NoError(t, err2)
offer := whipOffer(body)
answer, err2 := pc.CreateFullAnswer(offer)
require.NoError(t, err2)
w.Header().Set("Content-Type", "application/sdp")
w.Header().Set("ETag", "test_etag")
w.WriteHeader(http.StatusCreated)
w.Write([]byte(answer.SDP))
}
}),
}
ln, err := net.Listen("tcp", "localhost:9005")
require.NoError(t, err)
go httpServ.Serve(ln)
defer httpServ.Shutdown(context.Background())
u, err := url.Parse("http://localhost:9005/my/resource")
require.NoError(t, err)
outgoingTracks := []*webrtc.OutgoingTrack{{
Caps: pwebrtc.RTPCodecCapability{
MimeType: "audio/opus",
ClockRate: 48000,
Channels: 2,
},
}}
cl := &Client{
URL: u,
HTTPClient: &http.Client{},
BearerToken: "my_secret_token",
Log: test.NilLogger,
Publish: true,
OutgoingTracks: outgoingTracks,
}
err = cl.Initialize(context.Background())
require.NoError(t, err)
defer cl.Close() //nolint:errcheck
}
================================================
FILE: internal/protocols/whip/ice_fragment.go
================================================
package whip
import (
"fmt"
"strconv"
"github.com/pion/sdp/v3"
"github.com/pion/webrtc/v4"
)
// ICEFragmentUnmarshal decodes an ICE fragment.
func ICEFragmentUnmarshal(buf []byte) ([]*webrtc.ICECandidateInit, error) {
buf = append([]byte("v=0\r\no=- 0 0 IN IP4 0.0.0.0\r\ns=-\r\nt=0 0\r\n"), buf...)
var sdp sdp.SessionDescription
err := sdp.Unmarshal(buf)
if err != nil {
return nil, err
}
var ret []*webrtc.ICECandidateInit
for _, media := range sdp.MediaDescriptions {
mid, ok := media.Attribute("mid")
if !ok {
return nil, fmt.Errorf("mid attribute is missing")
}
var tmp uint64
tmp, err = strconv.ParseUint(mid, 10, 16)
if err != nil {
return nil, fmt.Errorf("invalid mid attribute")
}
midNum := uint16(tmp)
for _, attr := range media.Attributes {
if attr.Key == "candidate" {
ret = append(ret, &webrtc.ICECandidateInit{
Candidate: attr.Value,
SDPMid: &mid,
SDPMLineIndex: &midNum,
})
}
}
}
return ret, nil
}
// ICEFragmentMarshal encodes an ICE fragment.
func ICEFragmentMarshal(offer string, candidates []*webrtc.ICECandidateInit) ([]byte, error) {
var sdp sdp.SessionDescription
err := sdp.Unmarshal([]byte(offer))
if err != nil || len(sdp.MediaDescriptions) == 0 {
return nil, err
}
firstMedia := sdp.MediaDescriptions[0]
iceUfrag, _ := firstMedia.Attribute("ice-ufrag")
icePwd, _ := firstMedia.Attribute("ice-pwd")
candidatesByMedia := make(map[uint16][]*webrtc.ICECandidateInit)
for _, candidate := range candidates {
if candidate.SDPMLineIndex == nil {
return nil, fmt.Errorf("sdpMLineIndex is null")
}
mid := *candidate.SDPMLineIndex
candidatesByMedia[mid] = append(candidatesByMedia[mid], candidate)
}
frag := "a=ice-ufrag:" + iceUfrag + "\r\n" +
"a=ice-pwd:" + icePwd + "\r\n"
for mid, media := range sdp.MediaDescriptions {
cbm, ok := candidatesByMedia[uint16(mid)]
if ok {
frag += "m=" + media.MediaName.String() + "\r\n" +
"a=mid:" + strconv.FormatUint(uint64(mid), 10) + "\r\n"
for _, candidate := range cbm {
frag += "a=candidate:" + candidate.Candidate + "\r\n"
}
}
}
return []byte(frag), nil
}
================================================
FILE: internal/protocols/whip/ice_fragment_test.go
================================================
package whip
import (
"testing"
"github.com/pion/webrtc/v4"
"github.com/stretchr/testify/require"
)
func ptrOf[T any](v T) *T {
p := new(T)
*p = v
return p
}
var iceFragmentCases = []struct {
name string
offer string
candidates []*webrtc.ICECandidateInit
enc string
}{
{
"a",
"v=0\n" +
"o=- 8429658789122714282 1690995382 IN IP4 0.0.0.0\n" +
"s=-\n" +
"t=0 0\n" +
"a=fingerprint:sha-256 EA:05:9D:04:8F:56:41:92:3E:D5:2B:55:03:" +
"1B:5A:2C:3D:D8:B3:FB:1B:D9:F7:1F:DA:77:0E:B9:E0:3D:B6:FF\n" +
"a=extmap-allow-mixed\n" +
"a=group:BUNDLE 0\n" +
"m=video 9 UDP/TLS/RTP/SAVPF 96 97 98 99 100 101 102 121 127 120 125 107 108 109 123 118 45 46 116\n" +
"c=IN IP4 0.0.0.0\n" +
"a=setup:actpass\n" +
"a=mid:0\n" +
"a=ice-ufrag:tUQMzoQAVLzlvBys\n" +
"a=ice-pwd:pimyGfJcjjRwvUjnmGOODSjtIxyDljQj\n" +
"a=rtcp-mux\n" +
"a=rtcp-rsize\n" +
"a=rtpmap:96 VP8/90000\n" +
"a=rtcp-fb:96 goog-remb \n" +
"a=rtcp-fb:96 ccm fir\n" +
"a=rtcp-fb:96 nack \n" +
"a=rtcp-fb:96 nack pli\n" +
"a=rtcp-fb:96 nack \n" +
"a=rtcp-fb:96 nack pli\n" +
"a=rtcp-fb:96 transport-cc \n" +
"a=rtpmap:97 rtx/90000\n" +
"a=fmtp:97 apt=96\n" +
"a=rtcp-fb:97 nack \n" +
"a=rtcp-fb:97 nack pli\n" +
"a=rtcp-fb:97 transport-cc \n" +
"a=rtpmap:98 VP9/90000\n" +
"a=fmtp:98 profile-id=0\n" +
"a=rtcp-fb:98 goog-remb \n" +
"a=rtcp-fb:98 ccm fir\n" +
"a=rtcp-fb:98 nack \n" +
"a=rtcp-fb:98 nack pli\n" +
"a=rtcp-fb:98 nack \n" +
"a=rtcp-fb:98 nack pli\n" +
"a=rtcp-fb:98 transport-cc \n" +
"a=rtpmap:99 rtx/90000\n" +
"a=fmtp:99 apt=98\n" +
"a=rtcp-fb:99 nack \n" +
"a=rtcp-fb:99 nack pli\n" +
"a=rtcp-fb:99 transport-cc \n" +
"a=rtpmap:100 VP9/90000\n" +
"a=fmtp:100 profile-id=1\n" +
"a=rtcp-fb:100 goog-remb \n" +
"a=rtcp-fb:100 ccm fir\n" +
"a=rtcp-fb:100 nack \n" +
"a=rtcp-fb:100 nack pli\n" +
"a=rtcp-fb:100 nack \n" +
"a=rtcp-fb:100 nack pli\n" +
"a=rtcp-fb:100 transport-cc \n" +
"a=rtpmap:101 rtx/90000\n" +
"a=fmtp:101 apt=100\n" +
"a=rtcp-fb:101 nack \n" +
"a=rtcp-fb:101 nack pli\n" +
"a=rtcp-fb:101 transport-cc \n" +
"a=rtpmap:102 H264/90000\n" +
"a=fmtp:102 level-asymmetry-allowed=1;packetization-mode=1;profile-level-id=42001f\n" +
"a=rtcp-fb:102 goog-remb \n" +
"a=rtcp-fb:102 ccm fir\n" +
"a=rtcp-fb:102 nack \n" +
"a=rtcp-fb:102 nack pli\n" +
"a=rtcp-fb:102 nack \n" +
"a=rtcp-fb:102 nack pli\n" +
"a=rtcp-fb:102 transport-cc \n" +
"a=rtpmap:121 rtx/90000\n" +
"a=fmtp:121 apt=102\n" +
"a=rtcp-fb:121 nack \n" +
"a=rtcp-fb:121 nack pli\n" +
"a=rtcp-fb:121 transport-cc \n" +
"a=rtpmap:127 H264/90000\n" +
"a=fmtp:127 level-asymmetry-allowed=1;packetization-mode=0;profile-level-id=42001f\n" +
"a=rtcp-fb:127 goog-remb \n" +
"a=rtcp-fb:127 ccm fir\n" +
"a=rtcp-fb:127 nack \n" +
"a=rtcp-fb:127 nack pli\n" +
"a=rtcp-fb:127 nack \n" +
"a=rtcp-fb:127 nack pli\n" +
"a=rtcp-fb:127 transport-cc \n" +
"a=rtpmap:120 rtx/90000\n" +
"a=fmtp:120 apt=127\n" +
"a=rtcp-fb:120 nack \n" +
"a=rtcp-fb:120 nack pli\n" +
"a=rtcp-fb:120 transport-cc \n" +
"a=rtpmap:125 H264/90000\n" +
"a=fmtp:125 level-asymmetry-allowed=1;packetization-mode=1;profile-level-id=42e01f\n" +
"a=rtcp-fb:125 goog-remb \n" +
"a=rtcp-fb:125 ccm fir\n" +
"a=rtcp-fb:125 nack \n" +
"a=rtcp-fb:125 nack pli\n" +
"a=rtcp-fb:125 nack \n" +
"a=rtcp-fb:125 nack pli\n" +
"a=rtcp-fb:125 transport-cc \n" +
"a=rtpmap:107 rtx/90000\n" +
"a=fmtp:107 apt=125\n" +
"a=rtcp-fb:107 nack \n" +
"a=rtcp-fb:107 nack pli\n" +
"a=rtcp-fb:107 transport-cc \n" +
"a=rtpmap:108 H264/90000\n" +
"a=fmtp:108 level-asymmetry-allowed=1;packetization-mode=0;profile-level-id=42e01f\n" +
"a=rtcp-fb:108 goog-remb \n" +
"a=rtcp-fb:108 ccm fir\n" +
"a=rtcp-fb:108 nack \n" +
"a=rtcp-fb:108 nack pli\n" +
"a=rtcp-fb:108 nack \n" +
"a=rtcp-fb:108 nack pli\n" +
"a=rtcp-fb:108 transport-cc \n" +
"a=rtpmap:109 rtx/90000\n" +
"a=fmtp:109 apt=108\n" +
"a=rtcp-fb:109 nack \n" +
"a=rtcp-fb:109 nack pli\n" +
"a=rtcp-fb:109 transport-cc \n" +
"a=rtpmap:123 H264/90000\n" +
"a=fmtp:123 level-asymmetry-allowed=1;packetization-mode=1;profile-level-id=640032\n" +
"a=rtcp-fb:123 goog-remb \n" +
"a=rtcp-fb:123 ccm fir\n" +
"a=rtcp-fb:123 nack \n" +
"a=rtcp-fb:123 nack pli\n" +
"a=rtcp-fb:123 nack \n" +
"a=rtcp-fb:123 nack pli\n" +
"a=rtcp-fb:123 transport-cc \n" +
"a=rtpmap:118 rtx/90000\n" +
"a=fmtp:118 apt=123\n" +
"a=rtcp-fb:118 nack \n" +
"a=rtcp-fb:118 nack pli\n" +
"a=rtcp-fb:118 transport-cc \n" +
"a=rtpmap:45 AV1/90000\n" +
"a=rtcp-fb:45 goog-remb \n" +
"a=rtcp-fb:45 ccm fir\n" +
"a=rtcp-fb:45 nack \n" +
"a=rtcp-fb:45 nack pli\n" +
"a=rtcp-fb:45 nack \n" +
"a=rtcp-fb:45 nack pli\n" +
"a=rtcp-fb:45 transport-cc \n" +
"a=rtpmap:46 rtx/90000\n" +
"a=fmtp:46 apt=45\n" +
"a=rtcp-fb:46 nack \n" +
"a=rtcp-fb:46 nack pli\n" +
"a=rtcp-fb:46 transport-cc \n" +
"a=rtpmap:116 ulpfec/90000\n" +
"a=rtcp-fb:116 nack \n" +
"a=rtcp-fb:116 nack pli\n" +
"a=rtcp-fb:116 transport-cc \n" +
"a=extmap:1 http://www.ietf.org/id/draft-holmer-rmcat-transport-wide-cc-extensions-01\n" +
"a=ssrc:3421396091 cname:BmFVQDtOlcBwXZCl\n" +
"a=ssrc:3421396091 msid:BmFVQDtOlcBwXZCl CLgunVCazXXKLyEx\n" +
"a=ssrc:3421396091 mslabel:BmFVQDtOlcBwXZCl\n" +
"a=ssrc:3421396091 label:CLgunVCazXXKLyEx\n" +
"a=msid:BmFVQDtOlcBwXZCl CLgunVCazXXKLyEx\n" +
"a=sendrecv\n",
[]*webrtc.ICECandidateInit{{
Candidate: "3628911098 1 udp 2130706431 192.168.3.218 49462 typ host",
SDPMid: ptrOf("0"),
SDPMLineIndex: ptrOf(uint16(0)),
}},
"a=ice-ufrag:tUQMzoQAVLzlvBys\r\n" +
"a=ice-pwd:pimyGfJcjjRwvUjnmGOODSjtIxyDljQj\r\n" +
"m=video 9 UDP/TLS/RTP/SAVPF 96 97 98 99 100 101 102 121 127 120 125 107 108 109 123 118 45 46 116\r\n" +
"a=mid:0\r\n" +
"a=candidate:3628911098 1 udp 2130706431 192.168.3.218 49462 typ host\r\n",
},
}
func TestICEFragmentUnmarshal(t *testing.T) {
for _, ca := range iceFragmentCases {
t.Run(ca.name, func(t *testing.T) {
candidates, err := ICEFragmentUnmarshal([]byte(ca.enc))
require.NoError(t, err)
require.Equal(t, ca.candidates, candidates)
})
}
}
func TestICEFragmentMarshal(t *testing.T) {
for _, ca := range iceFragmentCases {
t.Run(ca.name, func(t *testing.T) {
byts, err := ICEFragmentMarshal(ca.offer, ca.candidates)
require.NoError(t, err)
require.Equal(t, ca.enc, string(byts))
})
}
}
================================================
FILE: internal/protocols/whip/link_header.go
================================================
package whip
import (
"encoding/json"
"fmt"
"regexp"
"github.com/pion/webrtc/v4"
)
func quoteCredential(v string) string {
b, _ := json.Marshal(v)
s := string(b)
return s[1 : len(s)-1]
}
func unquoteCredential(v string) string {
var s string
json.Unmarshal([]byte("\""+v+"\""), &s) //nolint:errcheck
return s
}
// LinkHeaderMarshal encodes a link header.
func LinkHeaderMarshal(iceServers []webrtc.ICEServer) []string {
ret := make([]string, len(iceServers))
for i, server := range iceServers {
link := "<" + server.URLs[0] + ">; rel=\"ice-server\""
if server.Username != "" {
link += "; username=\"" + quoteCredential(server.Username) + "\"" +
"; credential=\"" + quoteCredential(server.Credential.(string)) + "\"; credential-type=\"password\""
}
ret[i] = link
}
return ret
}
var reLink = regexp.MustCompile(`^<(.+?)>; rel="ice-server"(; username="(.+?)"` +
`; credential="(.+?)"; credential-type="password")?`)
// LinkHeaderUnmarshal decodes a link header.
func LinkHeaderUnmarshal(link []string) ([]webrtc.ICEServer, error) {
ret := make([]webrtc.ICEServer, len(link))
for i, li := range link {
m := reLink.FindStringSubmatch(li)
if m == nil {
return nil, fmt.Errorf("invalid link header: '%s'", li)
}
s := webrtc.ICEServer{
URLs: []string{m[1]},
}
if m[3] != "" {
s.Username = unquoteCredential(m[3])
s.Credential = unquoteCredential(m[4])
s.CredentialType = webrtc.ICECredentialTypePassword
}
ret[i] = s
}
return ret, nil
}
================================================
FILE: internal/protocols/whip/link_header_test.go
================================================
package whip
import (
"testing"
"github.com/pion/webrtc/v4"
"github.com/stretchr/testify/require"
)
var linkHeaderCases = []struct {
name string
enc []string
dec []webrtc.ICEServer
}{
{
"a",
[]string{
`; rel="ice-server"`,
`; rel="ice-server"; username="myuser\"a?2;B"; ` +
`credential="mypwd"; credential-type="password"`,
},
[]webrtc.ICEServer{
{
URLs: []string{"stun:stun.l.google.com:19302"},
},
{
URLs: []string{"turns:turn.example.com"},
Username: "myuser\"a?2;B",
Credential: "mypwd",
},
},
},
}
func TestLinkHeaderUnmarshal(t *testing.T) {
for _, ca := range linkHeaderCases {
t.Run(ca.name, func(t *testing.T) {
dec, err := LinkHeaderUnmarshal(ca.enc)
require.NoError(t, err)
require.Equal(t, ca.dec, dec)
})
}
}
func TestLinkHeaderMarshal(t *testing.T) {
for _, ca := range linkHeaderCases {
t.Run(ca.name, func(t *testing.T) {
enc := LinkHeaderMarshal(ca.dec)
require.Equal(t, ca.enc, enc)
})
}
}
================================================
FILE: internal/recordcleaner/cleaner.go
================================================
// Package recordcleaner contains the recording cleaner.
package recordcleaner
import (
"context"
"io/fs"
"os"
"path/filepath"
"strings"
"time"
"github.com/bluenviron/mediamtx/internal/conf"
"github.com/bluenviron/mediamtx/internal/logger"
"github.com/bluenviron/mediamtx/internal/recordstore"
)
var timeNow = time.Now
// Cleaner removes expired recording segments from disk.
type Cleaner struct {
PathConfs map[string]*conf.Path
Parent logger.Writer
ctx context.Context
ctxCancel func()
chReloadConf chan map[string]*conf.Path
done chan struct{}
}
// Initialize initializes a Cleaner.
func (c *Cleaner) Initialize() {
c.ctx, c.ctxCancel = context.WithCancel(context.Background())
c.chReloadConf = make(chan map[string]*conf.Path)
c.done = make(chan struct{})
go c.run()
}
// Close closes the Cleaner.
func (c *Cleaner) Close() {
c.ctxCancel()
<-c.done
}
// Log implements logger.Writer.
func (c *Cleaner) Log(level logger.Level, format string, args ...any) {
c.Parent.Log(level, "[record cleaner]"+format, args...)
}
// ReloadPathConfs is called by core.Core.
func (c *Cleaner) ReloadPathConfs(pathConfs map[string]*conf.Path) {
select {
case c.chReloadConf <- pathConfs:
case <-c.ctx.Done():
}
}
func (c *Cleaner) run() {
defer close(c.done)
c.doRun() //nolint:errcheck
for {
select {
case <-time.After(c.cleanInterval()):
c.doRun()
case cnf := <-c.chReloadConf:
c.PathConfs = cnf
case <-c.ctx.Done():
return
}
}
}
func (c *Cleaner) cleanInterval() time.Duration {
interval := 30 * 60 * time.Second
for _, e := range c.PathConfs {
if e.RecordDeleteAfter != 0 &&
interval > (time.Duration(e.RecordDeleteAfter)/2) {
interval = time.Duration(e.RecordDeleteAfter) / 2
}
}
return interval
}
func (c *Cleaner) doRun() {
now := timeNow()
pathNames := recordstore.FindAllPathsWithSegments(c.PathConfs)
for _, pathName := range pathNames {
c.processPath(now, pathName) //nolint:errcheck
}
}
func (c *Cleaner) processPath(now time.Time, pathName string) error {
pathConf, _, err := conf.FindPathConf(c.PathConfs, pathName)
if err != nil {
return err
}
if pathConf.RecordDeleteAfter == 0 {
return nil
}
err = c.deleteExpiredSegments(now, pathName, pathConf)
if err != nil {
return err
}
c.deleteEmptyDirs(pathConf)
return nil
}
func (c *Cleaner) deleteExpiredSegments(now time.Time, pathName string, pathConf *conf.Path) error {
end := now.Add(-time.Duration(pathConf.RecordDeleteAfter))
segments, err := recordstore.FindSegments(pathConf, pathName, nil, &end)
if err != nil {
return err
}
for _, seg := range segments {
c.Log(logger.Debug, "removing %s", seg.Fpath)
os.Remove(seg.Fpath)
}
return nil
}
func (c *Cleaner) deleteEmptyDirs(pathConf *conf.Path) {
recordPath := strings.ReplaceAll(pathConf.RecordPath, "%path", pathConf.Name)
commonPath := recordstore.CommonPath(recordPath)
filepath.WalkDir(commonPath, func(fpath string, info fs.DirEntry, err error) error { //nolint:errcheck
if err != nil {
return err
}
if info.IsDir() {
os.Remove(fpath)
}
return nil
})
}
================================================
FILE: internal/recordcleaner/cleaner_test.go
================================================
package recordcleaner
import (
"os"
"path/filepath"
"regexp"
"testing"
"time"
"github.com/bluenviron/mediamtx/internal/conf"
"github.com/bluenviron/mediamtx/internal/test"
"github.com/stretchr/testify/require"
)
func TestCleaner(t *testing.T) {
timeNow = func() time.Time {
return time.Date(2009, 5, 20, 22, 15, 25, 427000, time.Local)
}
dir, err := os.MkdirTemp("", "mediamtx-cleaner")
require.NoError(t, err)
defer os.RemoveAll(dir)
const specialChars = "_-+*?^$()[]{}|"
err = os.Mkdir(filepath.Join(dir, specialChars+"_mypath"), 0o755)
require.NoError(t, err)
err = os.WriteFile(filepath.Join(dir, specialChars+"_mypath", "2008-05-20_22-15-25-000125.mp4"), []byte{1}, 0o644)
require.NoError(t, err)
err = os.WriteFile(filepath.Join(dir, specialChars+"_mypath", "2009-05-20_22-15-25-000427.mp4"), []byte{1}, 0o644)
require.NoError(t, err)
c := &Cleaner{
PathConfs: map[string]*conf.Path{
"~^.*$": {
Name: "~^.*$",
Regexp: regexp.MustCompile("^.*$"),
RecordPath: filepath.Join(dir, specialChars+"_%path/%Y-%m-%d_%H-%M-%S-%f"),
RecordFormat: conf.RecordFormatFMP4,
RecordDeleteAfter: conf.Duration(10 * time.Second),
},
},
Parent: test.NilLogger,
}
c.Initialize()
defer c.Close()
time.Sleep(500 * time.Millisecond)
_, err = os.Stat(filepath.Join(dir, specialChars+"_mypath", "2008-05-20_22-15-25-000125.mp4"))
require.Error(t, err)
_, err = os.Stat(filepath.Join(dir, specialChars+"_mypath", "2009-05-20_22-15-25-000427.mp4"))
require.NoError(t, err)
}
func TestCleanerMultipleEntriesSamePath(t *testing.T) {
timeNow = func() time.Time {
return time.Date(2009, 5, 20, 22, 15, 25, 427000, time.Local)
}
dir, err := os.MkdirTemp("", "mediamtx-cleaner")
require.NoError(t, err)
defer os.RemoveAll(dir)
err = os.Mkdir(filepath.Join(dir, "path1"), 0o755)
require.NoError(t, err)
err = os.Mkdir(filepath.Join(dir, "path2"), 0o755)
require.NoError(t, err)
err = os.WriteFile(filepath.Join(dir, "path1", "2009-05-19_22-15-25-000427.mp4"), []byte{1}, 0o644)
require.NoError(t, err)
err = os.WriteFile(filepath.Join(dir, "path2", "2009-05-19_22-15-25-000427.mp4"), []byte{1}, 0o644)
require.NoError(t, err)
c := &Cleaner{
PathConfs: map[string]*conf.Path{
"path1": {
Name: "path1",
RecordPath: filepath.Join(dir, "%path/%Y-%m-%d_%H-%M-%S-%f"),
RecordFormat: conf.RecordFormatFMP4,
RecordDeleteAfter: conf.Duration(10 * time.Second),
},
"path2": {
Name: "path2",
RecordPath: filepath.Join(dir, "%path/%Y-%m-%d_%H-%M-%S-%f"),
RecordFormat: conf.RecordFormatFMP4,
RecordDeleteAfter: conf.Duration(10 * 24 * time.Hour),
},
},
Parent: test.NilLogger,
}
c.Initialize()
defer c.Close()
time.Sleep(500 * time.Millisecond)
_, err = os.Stat(filepath.Join(dir, "path1", "2009-05-19_22-15-25-000427.mp4"))
require.Error(t, err)
_, err = os.Stat(filepath.Join(dir, "path1"))
require.Error(t, err, "testing")
_, err = os.Stat(filepath.Join(dir, "path2", "2009-05-19_22-15-25-000427.mp4"))
require.NoError(t, err)
}
================================================
FILE: internal/recorder/format.go
================================================
package recorder
type format interface {
initialize() bool
close()
}
================================================
FILE: internal/recorder/format_fmp4.go
================================================
package recorder
import (
"bytes"
"fmt"
"slices"
"time"
rtspformat "github.com/bluenviron/gortsplib/v5/pkg/format"
"github.com/bluenviron/mediacommon/v2/pkg/codecs/ac3"
"github.com/bluenviron/mediacommon/v2/pkg/codecs/av1"
"github.com/bluenviron/mediacommon/v2/pkg/codecs/g711"
"github.com/bluenviron/mediacommon/v2/pkg/codecs/h264"
"github.com/bluenviron/mediacommon/v2/pkg/codecs/h265"
"github.com/bluenviron/mediacommon/v2/pkg/codecs/jpeg"
"github.com/bluenviron/mediacommon/v2/pkg/codecs/mpeg1audio"
"github.com/bluenviron/mediacommon/v2/pkg/codecs/mpeg4audio"
"github.com/bluenviron/mediacommon/v2/pkg/codecs/mpeg4video"
"github.com/bluenviron/mediacommon/v2/pkg/codecs/opus"
"github.com/bluenviron/mediacommon/v2/pkg/codecs/vp9"
"github.com/bluenviron/mediacommon/v2/pkg/formats/fmp4"
mcodecs "github.com/bluenviron/mediacommon/v2/pkg/formats/mp4/codecs"
"github.com/bluenviron/mediamtx/internal/defs"
"github.com/bluenviron/mediamtx/internal/logger"
"github.com/bluenviron/mediamtx/internal/unit"
)
var (
av1DefaultSequenceHeader = []byte{
8, 0, 0, 0, 66, 167, 191, 228, 96, 13, 0, 64,
}
h265DefaultVPS = []byte{
0x40, 0x01, 0x0c, 0x01, 0xff, 0xff, 0x02, 0x20,
0x00, 0x00, 0x03, 0x00, 0xb0, 0x00, 0x00, 0x03,
0x00, 0x00, 0x03, 0x00, 0x7b, 0x18, 0xb0, 0x24,
}
h265DefaultSPS = []byte{
0x42, 0x01, 0x01, 0x02, 0x20, 0x00, 0x00, 0x03,
0x00, 0xb0, 0x00, 0x00, 0x03, 0x00, 0x00, 0x03,
0x00, 0x7b, 0xa0, 0x07, 0x82, 0x00, 0x88, 0x7d,
0xb6, 0x71, 0x8b, 0x92, 0x44, 0x80, 0x53, 0x88,
0x88, 0x92, 0xcf, 0x24, 0xa6, 0x92, 0x72, 0xc9,
0x12, 0x49, 0x22, 0xdc, 0x91, 0xaa, 0x48, 0xfc,
0xa2, 0x23, 0xff, 0x00, 0x01, 0x00, 0x01, 0x6a,
0x02, 0x02, 0x02, 0x01,
}
h265DefaultPPS = []byte{
0x44, 0x01, 0xc0, 0x25, 0x2f, 0x05, 0x32, 0x40,
}
h264DefaultSPS = []byte{ // 1920x1080 baseline
0x67, 0x42, 0xc0, 0x28, 0xd9, 0x00, 0x78, 0x02,
0x27, 0xe5, 0x84, 0x00, 0x00, 0x03, 0x00, 0x04,
0x00, 0x00, 0x03, 0x00, 0xf0, 0x3c, 0x60, 0xc9, 0x20,
}
h264DefaultPPS = []byte{0x08, 0x06, 0x07, 0x08}
mpeg4VideoDefaultConfig = []byte{
0x00, 0x00, 0x01, 0xb0, 0x01, 0x00, 0x00, 0x01,
0xb5, 0x89, 0x13, 0x00, 0x00, 0x01, 0x00, 0x00,
0x00, 0x01, 0x20, 0x00, 0xc4, 0x8d, 0x88, 0x00,
0xf5, 0x3c, 0x04, 0x87, 0x14, 0x63, 0x00, 0x00,
0x01, 0xb2, 0x4c, 0x61, 0x76, 0x63, 0x35, 0x38,
0x2e, 0x31, 0x33, 0x34, 0x2e, 0x31, 0x30, 0x30,
}
mpeg1VideoDefaultConfig = []byte{
0x00, 0x00, 0x01, 0xb3, 0x78, 0x04, 0x38, 0x35,
0xff, 0xff, 0xe0, 0x18, 0x00, 0x00, 0x01, 0xb5,
0x14, 0x4a, 0x00, 0x01, 0x00, 0x00,
}
)
func mpeg1audioChannelCount(cm mpeg1audio.ChannelMode) int {
switch cm {
case mpeg1audio.ChannelModeStereo,
mpeg1audio.ChannelModeJointStereo,
mpeg1audio.ChannelModeDualChannel:
return 2
default:
return 1
}
}
func jpegExtractSize(image []byte) (int, int, error) {
l := len(image)
if l < 2 || image[0] != 0xFF || image[1] != jpeg.MarkerStartOfImage {
return 0, 0, fmt.Errorf("invalid header")
}
image = image[2:]
for {
if len(image) < 2 {
return 0, 0, fmt.Errorf("not enough bits")
}
h0, h1 := image[0], image[1]
image = image[2:]
if h0 != 0xFF {
return 0, 0, fmt.Errorf("invalid image")
}
switch h1 {
case 0xE0, 0xE1, 0xE2, // JFIF
jpeg.MarkerDefineHuffmanTable,
jpeg.MarkerComment,
jpeg.MarkerDefineQuantizationTable,
jpeg.MarkerDefineRestartInterval:
mlen := int(image[0])<<8 | int(image[1])
if len(image) < mlen {
return 0, 0, fmt.Errorf("not enough bits")
}
image = image[mlen:]
case jpeg.MarkerStartOfFrame1:
mlen := int(image[0])<<8 | int(image[1])
if len(image) < mlen {
return 0, 0, fmt.Errorf("not enough bits")
}
var sof jpeg.StartOfFrame1
err := sof.Unmarshal(image[2:mlen])
if err != nil {
return 0, 0, err
}
return sof.Width, sof.Height, nil
case jpeg.MarkerStartOfScan:
return 0, 0, fmt.Errorf("SOF not found")
default:
return 0, 0, fmt.Errorf("unknown marker: 0x%.2x", h1)
}
}
}
type formatFMP4Sample struct {
*fmp4.Sample
dts int64
ntp time.Time
}
type formatFMP4 struct {
ri *recorderInstance
tracks []*formatFMP4Track
hasVideo bool
currentSegment *formatFMP4Segment
nextSegmentNumber uint64
}
func (f *formatFMP4) initialize() bool {
nextID := 1
addTrack := func(format rtspformat.Format, codec mcodecs.Codec) *formatFMP4Track {
track := &formatFMP4Track{
f: f,
id: nextID,
clockRate: uint32(format.ClockRate()),
codec: codec,
}
track.initialize()
nextID++
f.tracks = append(f.tracks, track)
return track
}
for _, media := range f.ri.stream.Desc.Medias {
for _, forma := range media.Formats {
clockRate := forma.ClockRate()
switch forma := forma.(type) {
case *rtspformat.AV1:
codec := &mcodecs.AV1{
SequenceHeader: av1DefaultSequenceHeader,
}
track := addTrack(forma, codec)
firstReceived := false
f.ri.reader.OnData(
media,
forma,
func(u *unit.Unit) error {
if u.NilPayload() {
return nil
}
randomAccess := false
paramsChanged := false
for _, obu := range u.Payload.(unit.PayloadAV1) {
typ := av1.OBUType((obu[0] >> 3) & 0b1111)
if typ == av1.OBUTypeSequenceHeader {
if !bytes.Equal(codec.SequenceHeader, obu) {
codec.SequenceHeader = obu
paramsChanged = true
}
randomAccess = true
}
}
if paramsChanged {
f.updateCodecParams()
}
if !firstReceived {
if !randomAccess {
return nil
}
firstReceived = true
}
var sampl fmp4.Sample
err := sampl.FillAV1(u.Payload.(unit.PayloadAV1))
if err != nil {
return err
}
return track.write(&formatFMP4Sample{
Sample: &sampl,
dts: u.PTS,
ntp: u.NTP,
})
})
case *rtspformat.VP9:
codec := &mcodecs.VP9{
Width: 1280,
Height: 720,
Profile: 1,
BitDepth: 8,
ChromaSubsampling: 1,
ColorRange: false,
}
track := addTrack(forma, codec)
firstReceived := false
f.ri.reader.OnData(
media,
forma,
func(u *unit.Unit) error {
if u.NilPayload() {
return nil
}
var h vp9.Header
err := h.Unmarshal(u.Payload.(unit.PayloadVP9))
if err != nil {
return err
}
randomAccess := false
paramsChanged := false
if !h.NonKeyFrame {
randomAccess = true
if w := h.Width(); codec.Width != w {
codec.Width = w
paramsChanged = true
}
if h := h.Width(); codec.Height != h {
codec.Height = h
paramsChanged = true
}
if codec.Profile != h.Profile {
codec.Profile = h.Profile
paramsChanged = true
}
if codec.BitDepth != h.ColorConfig.BitDepth {
codec.BitDepth = h.ColorConfig.BitDepth
paramsChanged = true
}
if c := h.ChromaSubsampling(); codec.ChromaSubsampling != c {
codec.ChromaSubsampling = c
paramsChanged = true
}
if codec.ColorRange != h.ColorConfig.ColorRange {
codec.ColorRange = h.ColorConfig.ColorRange
paramsChanged = true
}
}
if paramsChanged {
f.updateCodecParams()
}
if !firstReceived {
if !randomAccess {
return nil
}
firstReceived = true
}
return track.write(&formatFMP4Sample{
Sample: &fmp4.Sample{
IsNonSyncSample: !randomAccess,
Payload: u.Payload.(unit.PayloadVP9),
},
dts: u.PTS,
ntp: u.NTP,
})
})
case *rtspformat.VP8:
// TODO
case *rtspformat.H265:
vps, sps, pps := forma.SafeParams()
if vps == nil || sps == nil || pps == nil {
vps = h265DefaultVPS
sps = h265DefaultSPS
pps = h265DefaultPPS
}
codec := &mcodecs.H265{
VPS: vps,
SPS: sps,
PPS: pps,
}
track := addTrack(forma, codec)
var dtsExtractor *h265.DTSExtractor
f.ri.reader.OnData(
media,
forma,
func(u *unit.Unit) error {
if u.NilPayload() {
return nil
}
randomAccess := false
paramsChanged := false
for _, nalu := range u.Payload.(unit.PayloadH265) {
typ := h265.NALUType((nalu[0] >> 1) & 0b111111)
switch typ {
case h265.NALUType_VPS_NUT:
if !bytes.Equal(codec.VPS, nalu) {
codec.VPS = nalu
paramsChanged = true
}
case h265.NALUType_SPS_NUT:
if !bytes.Equal(codec.SPS, nalu) {
codec.SPS = nalu
paramsChanged = true
}
case h265.NALUType_PPS_NUT:
if !bytes.Equal(codec.PPS, nalu) {
codec.PPS = nalu
paramsChanged = true
}
case h265.NALUType_IDR_W_RADL, h265.NALUType_IDR_N_LP, h265.NALUType_CRA_NUT:
randomAccess = true
}
}
if paramsChanged {
f.updateCodecParams()
}
if dtsExtractor == nil {
if !randomAccess {
return nil
}
dtsExtractor = &h265.DTSExtractor{}
dtsExtractor.Initialize()
}
dts, err := dtsExtractor.Extract(u.Payload.(unit.PayloadH265), u.PTS)
if err != nil {
return err
}
var sampl fmp4.Sample
err = sampl.FillH265(int32(u.PTS-dts), u.Payload.(unit.PayloadH265))
if err != nil {
return err
}
return track.write(&formatFMP4Sample{
Sample: &sampl,
dts: dts,
ntp: u.NTP,
})
})
case *rtspformat.H264:
sps, pps := forma.SafeParams()
if sps == nil || pps == nil {
sps = h264DefaultSPS
pps = h264DefaultPPS
}
codec := &mcodecs.H264{
SPS: sps,
PPS: pps,
}
track := addTrack(forma, codec)
var dtsExtractor *h264.DTSExtractor
f.ri.reader.OnData(
media,
forma,
func(u *unit.Unit) error {
if u.NilPayload() {
return nil
}
randomAccess := false
paramsChanged := false
for _, nalu := range u.Payload.(unit.PayloadH264) {
typ := h264.NALUType(nalu[0] & 0x1F)
switch typ {
case h264.NALUTypeSPS:
if !bytes.Equal(codec.SPS, nalu) {
codec.SPS = nalu
paramsChanged = true
}
case h264.NALUTypePPS:
if !bytes.Equal(codec.PPS, nalu) {
codec.PPS = nalu
paramsChanged = true
}
case h264.NALUTypeIDR:
randomAccess = true
}
}
if paramsChanged {
f.updateCodecParams()
}
if dtsExtractor == nil {
if !randomAccess {
return nil
}
dtsExtractor = &h264.DTSExtractor{}
dtsExtractor.Initialize()
}
dts, err := dtsExtractor.Extract(u.Payload.(unit.PayloadH264), u.PTS)
if err != nil {
return err
}
var sampl fmp4.Sample
err = sampl.FillH264(int32(u.PTS-dts), u.Payload.(unit.PayloadH264))
if err != nil {
return err
}
return track.write(&formatFMP4Sample{
Sample: &sampl,
dts: dts,
ntp: u.NTP,
})
})
case *rtspformat.MPEG4Video:
config := forma.SafeParams()
if config == nil {
config = mpeg4VideoDefaultConfig
}
codec := &mcodecs.MPEG4Video{
Config: config,
}
track := addTrack(forma, codec)
firstReceived := false
var lastPTS int64
f.ri.reader.OnData(
media,
forma,
func(u *unit.Unit) error {
if u.NilPayload() {
return nil
}
randomAccess := bytes.Contains(u.Payload.(unit.PayloadMPEG4Video),
[]byte{0, 0, 1, byte(mpeg4video.GroupOfVOPStartCode)})
if bytes.HasPrefix(u.Payload.(unit.PayloadMPEG4Video),
[]byte{0, 0, 1, byte(mpeg4video.VisualObjectSequenceStartCode)}) {
end := bytes.Index(u.Payload.(unit.PayloadMPEG4Video)[4:],
[]byte{0, 0, 1, byte(mpeg4video.GroupOfVOPStartCode)})
if end >= 0 {
config2 := u.Payload.(unit.PayloadMPEG4Video)[:end+4]
if !bytes.Equal(codec.Config, config2) {
codec.Config = config2
f.updateCodecParams()
}
}
}
if !firstReceived {
if !randomAccess {
return nil
}
firstReceived = true
} else if u.PTS < lastPTS {
return fmt.Errorf("MPEG-4 Video streams with B-frames are not supported (yet)")
}
lastPTS = u.PTS
return track.write(&formatFMP4Sample{
Sample: &fmp4.Sample{
Payload: u.Payload.(unit.PayloadMPEG4Video),
IsNonSyncSample: !randomAccess,
},
dts: u.PTS,
ntp: u.NTP,
})
})
case *rtspformat.MPEG1Video:
codec := &mcodecs.MPEG1Video{
Config: mpeg1VideoDefaultConfig,
}
track := addTrack(forma, codec)
firstReceived := false
var lastPTS int64
f.ri.reader.OnData(
media,
forma,
func(u *unit.Unit) error {
if u.NilPayload() {
return nil
}
randomAccess := bytes.Contains(u.Payload.(unit.PayloadMPEG1Video), []byte{0, 0, 1, 0xB8})
if bytes.HasPrefix(u.Payload.(unit.PayloadMPEG1Video), []byte{0, 0, 1, 0xB3}) {
end := bytes.Index(u.Payload.(unit.PayloadMPEG1Video)[4:], []byte{0, 0, 1, 0xB8})
if end >= 0 {
config := u.Payload.(unit.PayloadMPEG1Video)[:end+4]
if !bytes.Equal(codec.Config, config) {
codec.Config = config
f.updateCodecParams()
}
}
}
if !firstReceived {
if !randomAccess {
return nil
}
firstReceived = true
} else if u.PTS < lastPTS {
return fmt.Errorf("MPEG-1 Video streams with B-frames are not supported (yet)")
}
lastPTS = u.PTS
return track.write(&formatFMP4Sample{
Sample: &fmp4.Sample{
Payload: u.Payload.(unit.PayloadMPEG1Video),
IsNonSyncSample: !randomAccess,
},
dts: u.PTS,
ntp: u.NTP,
})
})
case *rtspformat.MJPEG:
codec := &mcodecs.MJPEG{
Width: 800,
Height: 600,
}
track := addTrack(forma, codec)
parsed := false
f.ri.reader.OnData(
media,
forma,
func(u *unit.Unit) error {
if u.NilPayload() {
return nil
}
if !parsed {
parsed = true
width, height, err := jpegExtractSize(u.Payload.(unit.PayloadMJPEG))
if err != nil {
return err
}
codec.Width = width
codec.Height = height
f.updateCodecParams()
}
return track.write(&formatFMP4Sample{
Sample: &fmp4.Sample{
Payload: u.Payload.(unit.PayloadMJPEG),
},
dts: u.PTS,
ntp: u.NTP,
})
})
case *rtspformat.Opus:
codec := &mcodecs.Opus{
ChannelCount: forma.ChannelCount,
}
track := addTrack(forma, codec)
f.ri.reader.OnData(
media,
forma,
func(u *unit.Unit) error {
if u.NilPayload() {
return nil
}
pts := u.PTS
for _, packet := range u.Payload.(unit.PayloadOpus) {
err := track.write(&formatFMP4Sample{
Sample: &fmp4.Sample{
Payload: packet,
},
dts: pts,
ntp: u.NTP.Add(timestampToDuration(pts-u.PTS, clockRate)),
})
if err != nil {
return err
}
pts += opus.PacketDuration2(packet)
}
return nil
})
case *rtspformat.MPEG4Audio:
codec := &mcodecs.MPEG4Audio{
Config: *forma.Config,
}
track := addTrack(forma, codec)
f.ri.reader.OnData(
media,
forma,
func(u *unit.Unit) error {
if u.NilPayload() {
return nil
}
for i, au := range u.Payload.(unit.PayloadMPEG4Audio) {
pts := u.PTS + int64(i)*mpeg4audio.SamplesPerAccessUnit
err := track.write(&formatFMP4Sample{
Sample: &fmp4.Sample{
Payload: au,
},
dts: pts,
ntp: u.NTP.Add(timestampToDuration(pts-u.PTS, clockRate)),
})
if err != nil {
return err
}
}
return nil
})
case *rtspformat.MPEG4AudioLATM:
if !forma.CPresent {
codec := &mcodecs.MPEG4Audio{
Config: *forma.StreamMuxConfig.Programs[0].Layers[0].AudioSpecificConfig,
}
track := addTrack(forma, codec)
f.ri.reader.OnData(
media,
forma,
func(u *unit.Unit) error {
if u.NilPayload() {
return nil
}
var ame mpeg4audio.AudioMuxElement
ame.StreamMuxConfig = forma.StreamMuxConfig
err := ame.Unmarshal(u.Payload.(unit.PayloadMPEG4AudioLATM))
if err != nil {
return err
}
return track.write(&formatFMP4Sample{
Sample: &fmp4.Sample{
Payload: ame.Payloads[0][0][0],
},
dts: u.PTS,
ntp: u.NTP,
})
})
}
case *rtspformat.MPEG1Audio:
codec := &mcodecs.MPEG1Audio{
SampleRate: 32000,
ChannelCount: 2,
}
track := addTrack(forma, codec)
parsed := false
f.ri.reader.OnData(
media,
forma,
func(u *unit.Unit) error {
if u.NilPayload() {
return nil
}
var dt time.Duration
for _, frame := range u.Payload.(unit.PayloadMPEG1Audio) {
var h mpeg1audio.FrameHeader
err := h.Unmarshal(frame)
if err != nil {
return err
}
if !parsed {
parsed = true
codec.SampleRate = h.SampleRate
codec.ChannelCount = mpeg1audioChannelCount(h.ChannelMode)
f.updateCodecParams()
}
err = track.write(&formatFMP4Sample{
Sample: &fmp4.Sample{
Payload: frame,
},
dts: u.PTS + u.PTS,
ntp: u.NTP,
})
if err != nil {
return err
}
dt += time.Duration(h.SampleCount()) *
time.Second / time.Duration(h.SampleRate)
}
return nil
})
case *rtspformat.AC3:
codec := &mcodecs.AC3{
SampleRate: forma.SampleRate,
ChannelCount: forma.ChannelCount,
Fscod: 0,
Bsid: 8,
Bsmod: 0,
Acmod: 7,
LfeOn: true,
BitRateCode: 7,
}
track := addTrack(forma, codec)
parsed := false
f.ri.reader.OnData(
media,
forma,
func(u *unit.Unit) error {
if u.NilPayload() {
return nil
}
for i, frame := range u.Payload.(unit.PayloadAC3) {
var syncInfo ac3.SyncInfo
err := syncInfo.Unmarshal(frame)
if err != nil {
return fmt.Errorf("invalid AC-3 frame: %w", err)
}
var bsi ac3.BSI
err = bsi.Unmarshal(frame[5:])
if err != nil {
return fmt.Errorf("invalid AC-3 frame: %w", err)
}
if !parsed {
parsed = true
codec.SampleRate = syncInfo.SampleRate()
codec.ChannelCount = bsi.ChannelCount()
codec.Bsid = bsi.Bsid
codec.Bsmod = bsi.Bsmod
codec.Acmod = bsi.Acmod
codec.LfeOn = bsi.LfeOn
codec.BitRateCode = syncInfo.Frmsizecod >> 1
f.updateCodecParams()
}
pts := u.PTS + int64(i)*ac3.SamplesPerFrame
err = track.write(&formatFMP4Sample{
Sample: &fmp4.Sample{
Payload: frame,
},
dts: pts,
ntp: u.NTP.Add(timestampToDuration(pts-u.PTS, clockRate)),
})
if err != nil {
return err
}
}
return nil
})
case *rtspformat.G722:
// TODO
case *rtspformat.G711:
codec := &mcodecs.LPCM{
LittleEndian: false,
BitDepth: 16,
SampleRate: forma.SampleRate,
ChannelCount: forma.ChannelCount,
}
track := addTrack(forma, codec)
f.ri.reader.OnData(
media,
forma,
func(u *unit.Unit) error {
if u.NilPayload() {
return nil
}
var lpcm []byte
if forma.MULaw {
var mu g711.Mulaw
mu.Unmarshal(u.Payload.(unit.PayloadG711))
lpcm = mu
} else {
var al g711.Alaw
al.Unmarshal(u.Payload.(unit.PayloadG711))
lpcm = al
}
return track.write(&formatFMP4Sample{
Sample: &fmp4.Sample{
Payload: lpcm,
},
dts: u.PTS,
ntp: u.NTP,
})
})
case *rtspformat.LPCM:
codec := &mcodecs.LPCM{
LittleEndian: false,
BitDepth: forma.BitDepth,
SampleRate: forma.SampleRate,
ChannelCount: forma.ChannelCount,
}
track := addTrack(forma, codec)
f.ri.reader.OnData(
media,
forma,
func(u *unit.Unit) error {
if u.NilPayload() {
return nil
}
return track.write(&formatFMP4Sample{
Sample: &fmp4.Sample{
Payload: u.Payload.(unit.PayloadLPCM),
},
dts: u.PTS,
ntp: u.NTP,
})
})
}
}
}
if len(f.tracks) == 0 {
f.ri.Log(logger.Warn, "no supported tracks found, skipping recording")
return false
}
setuppedFormats := f.ri.reader.Formats()
n := 1
for _, medi := range f.ri.stream.Desc.Medias {
for _, forma := range medi.Formats {
if !slices.Contains(setuppedFormats, forma) {
f.ri.Log(logger.Warn, "skipping track %d (%s)", n, forma.Codec())
}
n++
}
}
f.ri.Log(logger.Info, "recording %s",
defs.FormatsInfo(setuppedFormats))
return true
}
func (f *formatFMP4) updateCodecParams() {
f.ri.Log(logger.Debug, "codec parameters have changed")
}
func (f *formatFMP4) close() {
if f.currentSegment != nil {
f.currentSegment.close() //nolint:errcheck
}
}
================================================
FILE: internal/recorder/format_fmp4_part.go
================================================
package recorder
import (
"fmt"
"io"
"time"
"github.com/bluenviron/mediacommon/v2/pkg/formats/fmp4"
"github.com/bluenviron/mediacommon/v2/pkg/formats/fmp4/seekablebuffer"
"github.com/bluenviron/mediamtx/internal/conf"
)
func writePart(
f io.Writer,
sequenceNumber uint32,
partTracks map[*formatFMP4Track]*fmp4.PartTrack,
) error {
fmp4PartTracks := make([]*fmp4.PartTrack, len(partTracks))
i := 0
for _, partTrack := range partTracks {
fmp4PartTracks[i] = partTrack
i++
}
part := &fmp4.Part{
SequenceNumber: sequenceNumber,
Tracks: fmp4PartTracks,
}
var buf seekablebuffer.Buffer
err := part.Marshal(&buf)
if err != nil {
return err
}
_, err = f.Write(buf.Bytes())
return err
}
type formatFMP4Part struct {
maxPartSize conf.StringSize
segmentStartDTS time.Duration
number uint32
startDTS time.Duration
partTracks map[*formatFMP4Track]*fmp4.PartTrack
size uint64
endDTS time.Duration
}
func (p *formatFMP4Part) initialize() {
p.partTracks = make(map[*formatFMP4Track]*fmp4.PartTrack)
}
func (p *formatFMP4Part) close(w io.Writer) error {
return writePart(w, p.number, p.partTracks)
}
func (p *formatFMP4Part) write(track *formatFMP4Track, sample *formatFMP4Sample, dts time.Duration) error {
size := uint64(len(sample.Payload))
if (p.size + size) > uint64(p.maxPartSize) {
return fmt.Errorf("reached maximum part size")
}
p.size += size
partTrack, ok := p.partTracks[track]
if !ok {
partTrack = &fmp4.PartTrack{
ID: track.initTrack.ID,
BaseTime: uint64(multiplyAndDivide(int64(dts-p.segmentStartDTS),
int64(track.initTrack.TimeScale), int64(time.Second))),
}
p.partTracks[track] = partTrack
}
partTrack.Samples = append(partTrack.Samples, sample.Sample)
endDTS := dts + timestampToDuration(int64(sample.Duration), int(track.initTrack.TimeScale))
if endDTS > p.endDTS {
p.endDTS = endDTS
}
return nil
}
func (p *formatFMP4Part) duration() time.Duration {
return p.endDTS - p.startDTS
}
================================================
FILE: internal/recorder/format_fmp4_segment.go
================================================
package recorder
import (
"bytes"
"fmt"
"io"
"os"
"path/filepath"
"time"
amp4 "github.com/abema/go-mp4"
"github.com/bluenviron/mediacommon/v2/pkg/formats/fmp4"
"github.com/bluenviron/mediacommon/v2/pkg/formats/fmp4/seekablebuffer"
"github.com/bluenviron/mediamtx/internal/logger"
"github.com/bluenviron/mediamtx/internal/recordstore"
"github.com/google/uuid"
)
func writeInit(
f io.Writer,
streamID uuid.UUID,
segmentNumber uint64,
dts time.Duration,
ntp time.Time,
tracks []*formatFMP4Track,
) error {
fmp4Tracks := make([]*fmp4.InitTrack, len(tracks))
for i, track := range tracks {
fmp4Tracks[i] = track.initTrack
}
init := fmp4.Init{
Tracks: fmp4Tracks,
UserData: []amp4.IBox{
&recordstore.Mtxi{
FullBox: amp4.FullBox{
Version: 0,
},
StreamID: streamID,
SegmentNumber: segmentNumber,
DTS: int64(dts),
NTP: ntp.UnixNano(),
},
},
}
var buf seekablebuffer.Buffer
err := init.Marshal(&buf)
if err != nil {
return err
}
_, err = f.Write(buf.Bytes())
return err
}
func writeDuration(f io.ReadWriteSeeker, d time.Duration) error {
_, err := f.Seek(0, io.SeekStart)
if err != nil {
return err
}
// check and skip ftyp header and content
buf := make([]byte, 8)
_, err = io.ReadFull(f, buf)
if err != nil {
return err
}
if !bytes.Equal(buf[4:], []byte{'f', 't', 'y', 'p'}) {
return fmt.Errorf("ftyp box not found")
}
ftypSize := uint32(buf[0])<<24 | uint32(buf[1])<<16 | uint32(buf[2])<<8 | uint32(buf[3])
_, err = f.Seek(int64(ftypSize), io.SeekStart)
if err != nil {
return err
}
// check and skip moov header
_, err = io.ReadFull(f, buf)
if err != nil {
return err
}
if !bytes.Equal(buf[4:], []byte{'m', 'o', 'o', 'v'}) {
return fmt.Errorf("moov box not found")
}
moovSize := uint32(buf[0])<<24 | uint32(buf[1])<<16 | uint32(buf[2])<<8 | uint32(buf[3])
moovPos, err := f.Seek(8, io.SeekCurrent)
if err != nil {
return err
}
var mvhd amp4.Mvhd
_, err = amp4.Unmarshal(f, uint64(moovSize-8), &mvhd, amp4.Context{})
if err != nil {
return err
}
mvhd.DurationV0 = uint32(d / time.Millisecond)
_, err = f.Seek(moovPos, io.SeekStart)
if err != nil {
return err
}
_, err = amp4.Marshal(f, &mvhd, amp4.Context{})
if err != nil {
return err
}
return nil
}
type formatFMP4Segment struct {
f *formatFMP4
startDTS time.Duration
startNTP time.Time
number uint64
path string
fi *os.File
curPart *formatFMP4Part
endDTS time.Duration
nextPartNumber uint32
}
func (s *formatFMP4Segment) initialize() {
s.endDTS = s.startDTS
}
func (s *formatFMP4Segment) close() error {
var err error
if s.curPart != nil {
err = s.closeCurPart()
}
if s.fi != nil {
s.f.ri.Log(logger.Debug, "closing segment %s", s.path)
// write overall duration in the header to speed up the playback server
duration := s.endDTS - s.startDTS
err2 := writeDuration(s.fi, duration)
if err == nil {
err = err2
}
err2 = s.fi.Close()
if err == nil {
err = err2
}
if err2 == nil {
s.f.ri.onSegmentComplete(s.path, duration)
}
}
return err
}
func (s *formatFMP4Segment) closeCurPart() error {
if s.fi == nil {
s.path = recordstore.Path{Start: s.startNTP}.Encode(s.f.ri.pathFormat2)
s.f.ri.Log(logger.Debug, "creating segment %s", s.path)
err := os.MkdirAll(filepath.Dir(s.path), 0o755)
if err != nil {
return err
}
fi, err := os.Create(s.path)
if err != nil {
return err
}
s.f.ri.onSegmentCreate(s.path)
err = writeInit(
fi,
s.f.ri.streamID,
s.number,
s.startDTS,
s.startNTP,
s.f.tracks)
if err != nil {
fi.Close()
return err
}
s.fi = fi
}
return s.curPart.close(s.fi)
}
func (s *formatFMP4Segment) write(track *formatFMP4Track, sample *formatFMP4Sample, dts time.Duration) error {
endDTS := dts + timestampToDuration(int64(sample.Duration), int(track.initTrack.TimeScale))
if endDTS > s.endDTS {
s.endDTS = endDTS
}
if s.curPart == nil {
s.curPart = &formatFMP4Part{
maxPartSize: s.f.ri.maxPartSize,
segmentStartDTS: s.startDTS,
number: s.nextPartNumber,
startDTS: dts,
}
s.curPart.initialize()
s.nextPartNumber++
} else if s.curPart.duration() >= s.f.ri.partDuration {
err := s.closeCurPart()
s.curPart = nil
if err != nil {
return err
}
s.curPart = &formatFMP4Part{
maxPartSize: s.f.ri.maxPartSize,
segmentStartDTS: s.startDTS,
number: s.nextPartNumber,
startDTS: dts,
}
s.curPart.initialize()
s.nextPartNumber++
}
return s.curPart.write(track, sample, dts)
}
================================================
FILE: internal/recorder/format_fmp4_track.go
================================================
package recorder
import (
"fmt"
"time"
"github.com/bluenviron/mediacommon/v2/pkg/formats/fmp4"
mcodecs "github.com/bluenviron/mediacommon/v2/pkg/formats/mp4/codecs"
"github.com/bluenviron/mediamtx/internal/logger"
)
const (
// this corresponds to concatenationTolerance
maxBasetime = 1 * time.Second
)
// start next segment from the oldest next sample, in order to avoid negative basetimes (impossible) in fMP4.
// keep starting position within a certain distance from the newest next sample to avoid big basetimes.
func nextSegmentStartingPos(tracks []*formatFMP4Track) (time.Time, time.Duration) {
var maxDTS time.Duration
for _, track := range tracks {
if track.nextSample != nil {
dts := timestampToDuration(track.nextSample.dts, int(track.initTrack.TimeScale))
if dts > maxDTS {
maxDTS = dts
}
}
}
var oldestNTP time.Time
oldestDTS := maxDTS
for _, track := range tracks {
if track.nextSample != nil {
dts := timestampToDuration(track.nextSample.dts, int(track.initTrack.TimeScale))
if (maxDTS-dts) <= maxBasetime && (dts <= oldestDTS) {
oldestNTP = track.nextSample.ntp
oldestDTS = dts
}
}
}
return oldestNTP, oldestDTS
}
type formatFMP4Track struct {
f *formatFMP4
id int
clockRate uint32
codec mcodecs.Codec
initTrack *fmp4.InitTrack
nextSample *formatFMP4Sample
startInitialized bool
startDTS time.Duration
startNTP time.Time
}
func (t *formatFMP4Track) initialize() {
t.initTrack = &fmp4.InitTrack{
ID: t.id,
TimeScale: t.clockRate,
Codec: t.codec,
}
}
func (t *formatFMP4Track) write(sample *formatFMP4Sample) error {
// wait the first video sample before setting hasVideo
if t.initTrack.Codec.IsVideo() {
t.f.hasVideo = true
}
sample, t.nextSample = t.nextSample, sample
if sample == nil {
return nil
}
duration := t.nextSample.dts - sample.dts
if duration < 0 {
t.nextSample.dts = sample.dts
duration = 0
}
sample.Duration = uint32(duration)
dts := timestampToDuration(sample.dts, int(t.initTrack.TimeScale))
if !t.startInitialized {
t.startDTS = dts
t.startNTP = sample.ntp
t.startInitialized = true
} else {
drift := sample.ntp.Sub(t.startNTP) - (dts - t.startDTS)
if drift < -ntpDriftTolerance || drift > ntpDriftTolerance {
return fmt.Errorf("detected drift between recording duration and absolute time, resetting")
}
}
if t.f.currentSegment == nil {
t.f.currentSegment = &formatFMP4Segment{
f: t.f,
startDTS: dts,
startNTP: sample.ntp,
number: t.f.nextSegmentNumber,
}
t.f.currentSegment.initialize()
t.f.nextSegmentNumber++
} else if (dts - t.f.currentSegment.startDTS) < 0 { // BaseTime is negative, this is not supported by fMP4
t.f.ri.Log(logger.Warn, "sample of track %d received too late, discarding", t.initTrack.ID)
return nil
}
err := t.f.currentSegment.write(t, sample, dts)
if err != nil {
return err
}
nextDTS := timestampToDuration(t.nextSample.dts, int(t.initTrack.TimeScale))
if (!t.f.hasVideo || t.initTrack.Codec.IsVideo()) &&
!t.nextSample.IsNonSyncSample &&
(nextDTS-t.f.currentSegment.startDTS) >= t.f.ri.segmentDuration {
err = t.f.currentSegment.close()
if err != nil {
return err
}
oldestNTP, oldestDTS := nextSegmentStartingPos(t.f.tracks)
t.f.currentSegment = &formatFMP4Segment{
f: t.f,
startDTS: oldestDTS,
startNTP: oldestNTP,
number: t.f.nextSegmentNumber,
}
t.f.currentSegment.initialize()
t.f.nextSegmentNumber++
}
return nil
}
================================================
FILE: internal/recorder/format_mpegts.go
================================================
package recorder
import (
"bufio"
"bytes"
"fmt"
"io"
"slices"
"time"
rtspformat "github.com/bluenviron/gortsplib/v5/pkg/format"
"github.com/bluenviron/mediacommon/v2/pkg/codecs/ac3"
"github.com/bluenviron/mediacommon/v2/pkg/codecs/h264"
"github.com/bluenviron/mediacommon/v2/pkg/codecs/h265"
"github.com/bluenviron/mediacommon/v2/pkg/codecs/mpeg4audio"
"github.com/bluenviron/mediacommon/v2/pkg/codecs/mpeg4video"
"github.com/bluenviron/mediacommon/v2/pkg/formats/mpegts"
tscodecs "github.com/bluenviron/mediacommon/v2/pkg/formats/mpegts/codecs"
"github.com/bluenviron/mediamtx/internal/defs"
"github.com/bluenviron/mediamtx/internal/logger"
"github.com/bluenviron/mediamtx/internal/unit"
)
const (
mpegtsBufferSize = 64 * 1024
)
func multiplyAndDivide(v, m, d int64) int64 {
secs := v / d
dec := v % d
return (secs*m + dec*m/d)
}
func multiplyAndDivide2(v, m, d time.Duration) time.Duration {
secs := v / d
dec := v % d
return (secs*m + dec*m/d)
}
func timestampToDuration(t int64, clockRate int) time.Duration {
return multiplyAndDivide2(time.Duration(t), time.Second, time.Duration(clockRate))
}
type dynamicWriter struct {
w io.Writer
}
func (d *dynamicWriter) Write(p []byte) (int, error) {
return d.w.Write(p)
}
func (d *dynamicWriter) setTarget(w io.Writer) {
d.w = w
}
type formatMPEGTS struct {
ri *recorderInstance
dw *dynamicWriter
bw *bufio.Writer
mw *mpegts.Writer
hasVideo bool
currentSegment *formatMPEGTSSegment
}
func (f *formatMPEGTS) initialize() bool {
var tracks []*mpegts.Track
addTrack := func(codec tscodecs.Codec) *formatMPEGTSTrack {
track := &formatMPEGTSTrack{
f: f,
codec: codec,
}
track.initialize()
tracks = append(tracks, track.track)
return track
}
for _, media := range f.ri.stream.Desc.Medias {
for _, forma := range media.Formats {
clockRate := forma.ClockRate()
switch forma := forma.(type) {
case *rtspformat.H265: //nolint:dupl
track := addTrack(&tscodecs.H265{})
var dtsExtractor *h265.DTSExtractor
f.ri.reader.OnData(
media,
forma,
func(u *unit.Unit) error {
if u.NilPayload() {
return nil
}
randomAccess := h265.IsRandomAccess(u.Payload.(unit.PayloadH265))
if dtsExtractor == nil {
if !randomAccess {
return nil
}
dtsExtractor = &h265.DTSExtractor{}
dtsExtractor.Initialize()
}
dts, err := dtsExtractor.Extract(u.Payload.(unit.PayloadH265), u.PTS)
if err != nil {
return err
}
return track.write(
timestampToDuration(dts, clockRate),
u.NTP,
randomAccess,
func(mtrack *mpegts.Track) error {
return f.mw.WriteH265(
mtrack,
u.PTS, // no conversion is needed since clock rate is 90khz in both MPEG-TS and RTSP
dts,
u.Payload.(unit.PayloadH265))
},
)
})
case *rtspformat.H264: //nolint:dupl
track := addTrack(&tscodecs.H264{})
var dtsExtractor *h264.DTSExtractor
f.ri.reader.OnData(
media,
forma,
func(u *unit.Unit) error {
if u.NilPayload() {
return nil
}
randomAccess := h264.IsRandomAccess(u.Payload.(unit.PayloadH264))
if dtsExtractor == nil {
if !randomAccess {
return nil
}
dtsExtractor = &h264.DTSExtractor{}
dtsExtractor.Initialize()
}
dts, err := dtsExtractor.Extract(u.Payload.(unit.PayloadH264), u.PTS)
if err != nil {
return err
}
return track.write(
timestampToDuration(dts, clockRate),
u.NTP,
randomAccess,
func(mtrack *mpegts.Track) error {
return f.mw.WriteH264(
mtrack,
u.PTS, // no conversion is needed since clock rate is 90khz in both MPEG-TS and RTSP
dts,
u.Payload.(unit.PayloadH264))
},
)
})
case *rtspformat.MPEG4Video:
track := addTrack(&tscodecs.MPEG4Video{})
firstReceived := false
var lastPTS int64
f.ri.reader.OnData(
media,
forma,
func(u *unit.Unit) error {
if u.NilPayload() {
return nil
}
if !firstReceived {
firstReceived = true
} else if u.PTS < lastPTS {
return fmt.Errorf("MPEG-4 Video streams with B-frames are not supported (yet)")
}
lastPTS = u.PTS
randomAccess := bytes.Contains(u.Payload.(unit.PayloadMPEG4Video),
[]byte{0, 0, 1, byte(mpeg4video.GroupOfVOPStartCode)})
return track.write(
timestampToDuration(u.PTS, clockRate),
u.NTP,
randomAccess,
func(mtrack *mpegts.Track) error {
return f.mw.WriteMPEG4Video(
mtrack,
u.PTS, // no conversion is needed since clock rate is 90khz in both MPEG-TS and RTSP
u.Payload.(unit.PayloadMPEG4Video))
},
)
})
case *rtspformat.MPEG1Video:
track := addTrack(&tscodecs.MPEG1Video{})
firstReceived := false
var lastPTS int64
f.ri.reader.OnData(
media,
forma,
func(u *unit.Unit) error {
if u.NilPayload() {
return nil
}
if !firstReceived {
firstReceived = true
} else if u.PTS < lastPTS {
return fmt.Errorf("MPEG-1 Video streams with B-frames are not supported (yet)")
}
lastPTS = u.PTS
randomAccess := bytes.Contains(u.Payload.(unit.PayloadMPEG1Video), []byte{0, 0, 1, 0xB8})
return track.write(
timestampToDuration(u.PTS, clockRate),
u.NTP,
randomAccess,
func(mtrack *mpegts.Track) error {
return f.mw.WriteMPEG1Video(
mtrack,
u.PTS, // no conversion is needed since clock rate is 90khz in both MPEG-TS and RTSP
u.Payload.(unit.PayloadMPEG1Video))
},
)
})
case *rtspformat.Opus:
track := addTrack(&tscodecs.Opus{
ChannelCount: forma.ChannelCount,
})
f.ri.reader.OnData(
media,
forma,
func(u *unit.Unit) error {
if u.NilPayload() {
return nil
}
return track.write(
timestampToDuration(u.PTS, clockRate),
u.NTP,
true,
func(mtrack *mpegts.Track) error {
return f.mw.WriteOpus(
mtrack,
multiplyAndDivide(u.PTS, 90000, int64(clockRate)),
u.Payload.(unit.PayloadOpus))
},
)
})
case *rtspformat.KLV:
track := addTrack(&tscodecs.KLV{
Synchronous: true,
})
f.ri.reader.OnData(
media,
forma,
func(u *unit.Unit) error {
if u.NilPayload() {
return nil
}
return track.write(
timestampToDuration(u.PTS, 90000),
u.NTP,
true,
func(mtrack *mpegts.Track) error {
return f.mw.WriteKLV(
mtrack,
multiplyAndDivide(u.PTS, 90000, 90000),
u.Payload.(unit.PayloadKLV))
},
)
})
case *rtspformat.MPEG4Audio:
track := addTrack(&tscodecs.MPEG4Audio{
Config: *forma.Config,
})
f.ri.reader.OnData(
media,
forma,
func(u *unit.Unit) error {
if u.NilPayload() {
return nil
}
return track.write(
timestampToDuration(u.PTS, clockRate),
u.NTP,
true,
func(mtrack *mpegts.Track) error {
return f.mw.WriteMPEG4Audio(
mtrack,
multiplyAndDivide(u.PTS, 90000, int64(clockRate)),
u.Payload.(unit.PayloadMPEG4Audio))
},
)
})
case *rtspformat.MPEG4AudioLATM:
if !forma.CPresent {
track := addTrack(&tscodecs.MPEG4Audio{
Config: *forma.StreamMuxConfig.Programs[0].Layers[0].AudioSpecificConfig,
})
f.ri.reader.OnData(
media,
forma,
func(u *unit.Unit) error {
if u.NilPayload() {
return nil
}
var ame mpeg4audio.AudioMuxElement
ame.StreamMuxConfig = forma.StreamMuxConfig
err := ame.Unmarshal(u.Payload.(unit.PayloadMPEG4AudioLATM))
if err != nil {
return err
}
return track.write(
timestampToDuration(u.PTS, clockRate),
u.NTP,
true,
func(mtrack *mpegts.Track) error {
return f.mw.WriteMPEG4Audio(
mtrack,
multiplyAndDivide(u.PTS, 90000, int64(clockRate)),
[][]byte{ame.Payloads[0][0][0]})
},
)
})
}
case *rtspformat.MPEG1Audio:
track := addTrack(&tscodecs.MPEG1Audio{})
f.ri.reader.OnData(
media,
forma,
func(u *unit.Unit) error {
if u.NilPayload() {
return nil
}
return track.write(
timestampToDuration(u.PTS, clockRate),
u.NTP,
true,
func(mtrack *mpegts.Track) error {
return f.mw.WriteMPEG1Audio(
mtrack,
u.PTS, // no conversion is needed since clock rate is 90khz in both MPEG-TS and RTSP
u.Payload.(unit.PayloadMPEG1Audio))
},
)
})
case *rtspformat.AC3:
track := addTrack(&tscodecs.AC3{})
f.ri.reader.OnData(
media,
forma,
func(u *unit.Unit) error {
if u.NilPayload() {
return nil
}
return track.write(
timestampToDuration(u.PTS, clockRate),
u.NTP,
true,
func(mtrack *mpegts.Track) error {
for i, frame := range u.Payload.(unit.PayloadAC3) {
framePTS := u.PTS + int64(i)*ac3.SamplesPerFrame
err := f.mw.WriteAC3(
mtrack,
multiplyAndDivide(framePTS, 90000, int64(clockRate)),
frame)
if err != nil {
return err
}
}
return nil
},
)
})
}
}
}
if len(tracks) == 0 {
f.ri.Log(logger.Warn, "no supported tracks found, skipping recording")
return false
}
setuppedFormats := f.ri.reader.Formats()
n := 1
for _, medi := range f.ri.stream.Desc.Medias {
for _, forma := range medi.Formats {
if !slices.Contains(setuppedFormats, forma) {
f.ri.Log(logger.Warn, "skipping track %d (%s)", n, forma.Codec())
}
n++
}
}
f.dw = &dynamicWriter{}
f.bw = bufio.NewWriterSize(f.dw, mpegtsBufferSize)
f.mw = &mpegts.Writer{W: f.bw, Tracks: tracks}
err := f.mw.Initialize()
if err != nil {
panic(err)
}
f.ri.Log(logger.Info, "recording %s",
defs.FormatsInfo(setuppedFormats))
return true
}
func (f *formatMPEGTS) close() {
if f.currentSegment != nil {
f.currentSegment.close() //nolint:errcheck
}
}
================================================
FILE: internal/recorder/format_mpegts_segment.go
================================================
package recorder
import (
"os"
"path/filepath"
"time"
"github.com/bluenviron/mediamtx/internal/logger"
"github.com/bluenviron/mediamtx/internal/recordstore"
)
type formatMPEGTSSegment struct {
pathFormat2 string
flush func() error
onSegmentCreate OnSegmentCreateFunc
onSegmentComplete OnSegmentCompleteFunc
startDTS time.Duration
startNTP time.Time
log logger.Writer
path string
fi *os.File
lastFlush time.Duration
lastDTS time.Duration
}
func (s *formatMPEGTSSegment) initialize() {
s.lastFlush = s.startDTS
s.lastDTS = s.startDTS
}
func (s *formatMPEGTSSegment) close() error {
err := s.flush()
if s.fi != nil {
s.log.Log(logger.Debug, "closing segment %s", s.path)
err2 := s.fi.Close()
if err == nil {
err = err2
}
if err2 == nil {
duration := s.lastDTS - s.startDTS
s.onSegmentComplete(s.path, duration)
}
}
return err
}
func (s *formatMPEGTSSegment) Write(p []byte) (int, error) {
if s.fi == nil {
s.path = recordstore.Path{Start: s.startNTP}.Encode(s.pathFormat2)
s.log.Log(logger.Debug, "creating segment %s", s.path)
err := os.MkdirAll(filepath.Dir(s.path), 0o755)
if err != nil {
return 0, err
}
fi, err := os.Create(s.path)
if err != nil {
return 0, err
}
s.onSegmentCreate(s.path)
s.fi = fi
}
return s.fi.Write(p)
}
================================================
FILE: internal/recorder/format_mpegts_track.go
================================================
package recorder
import (
"fmt"
"time"
"github.com/bluenviron/mediacommon/v2/pkg/formats/mpegts"
tscodecs "github.com/bluenviron/mediacommon/v2/pkg/formats/mpegts/codecs"
)
type formatMPEGTSTrack struct {
f *formatMPEGTS
codec tscodecs.Codec
track *mpegts.Track
startInitialized bool
startDTS time.Duration
startNTP time.Time
}
func (t *formatMPEGTSTrack) initialize() {
t.track = &mpegts.Track{
Codec: t.codec,
}
}
func (t *formatMPEGTSTrack) write(
dts time.Duration,
ntp time.Time,
randomAccess bool,
cb func(track *mpegts.Track) error,
) error {
isVideo := t.track.Codec.IsVideo()
if isVideo {
t.f.hasVideo = true
}
if !t.startInitialized {
t.startDTS = dts
t.startNTP = ntp
t.startInitialized = true
} else {
drift := ntp.Sub(t.startNTP) - (dts - t.startDTS)
if drift < -ntpDriftTolerance || drift > ntpDriftTolerance {
return fmt.Errorf("detected drift between recording duration and absolute time, resetting")
}
}
switch {
case t.f.currentSegment == nil:
t.f.currentSegment = &formatMPEGTSSegment{
pathFormat2: t.f.ri.pathFormat2,
flush: t.f.bw.Flush,
onSegmentCreate: t.f.ri.onSegmentCreate,
onSegmentComplete: t.f.ri.onSegmentComplete,
startDTS: dts,
startNTP: ntp,
log: t.f.ri,
}
t.f.currentSegment.initialize()
t.f.dw.setTarget(t.f.currentSegment)
case (!t.f.hasVideo || isVideo) &&
randomAccess &&
(dts-t.f.currentSegment.startDTS) >= t.f.ri.segmentDuration:
t.f.currentSegment.lastDTS = dts
err := t.f.currentSegment.close()
if err != nil {
return err
}
t.f.currentSegment = &formatMPEGTSSegment{
pathFormat2: t.f.ri.pathFormat2,
flush: t.f.bw.Flush,
onSegmentCreate: t.f.ri.onSegmentCreate,
onSegmentComplete: t.f.ri.onSegmentComplete,
startDTS: dts,
startNTP: ntp,
log: t.f.ri,
}
t.f.currentSegment.initialize()
t.f.dw.setTarget(t.f.currentSegment)
case (dts - t.f.currentSegment.lastFlush) >= t.f.ri.partDuration:
err := t.f.bw.Flush()
if err != nil {
return err
}
t.f.currentSegment.lastFlush = dts
}
t.f.currentSegment.lastDTS = dts
return cb(t.track)
}
================================================
FILE: internal/recorder/recorder.go
================================================
// Package recorder contains the recorder.
package recorder
import (
"time"
"github.com/bluenviron/mediamtx/internal/conf"
"github.com/bluenviron/mediamtx/internal/logger"
"github.com/bluenviron/mediamtx/internal/stream"
)
const (
ntpDriftTolerance = 5 * time.Second
)
// OnSegmentCreateFunc is the prototype of the function passed as OnSegmentCreate
type OnSegmentCreateFunc = func(path string)
// OnSegmentCompleteFunc is the prototype of the function passed as OnSegmentComplete
type OnSegmentCompleteFunc = func(path string, duration time.Duration)
// Recorder writes recordings to disk.
type Recorder struct {
PathFormat string
Format conf.RecordFormat
PartDuration time.Duration
MaxPartSize conf.StringSize
SegmentDuration time.Duration
PathName string
Stream *stream.Stream
OnSegmentCreate OnSegmentCreateFunc
OnSegmentComplete OnSegmentCompleteFunc
Parent logger.Writer
restartPause time.Duration
currentInstance *recorderInstance
terminate chan struct{}
done chan struct{}
}
// Initialize initializes Recorder.
func (r *Recorder) Initialize() {
if r.OnSegmentCreate == nil {
r.OnSegmentCreate = func(string) {
}
}
if r.OnSegmentComplete == nil {
r.OnSegmentComplete = func(string, time.Duration) {
}
}
if r.restartPause == 0 {
r.restartPause = 2 * time.Second
}
r.terminate = make(chan struct{})
r.done = make(chan struct{})
r.currentInstance = &recorderInstance{
pathFormat: r.PathFormat,
format: r.Format,
partDuration: r.PartDuration,
maxPartSize: r.MaxPartSize,
segmentDuration: r.SegmentDuration,
pathName: r.PathName,
stream: r.Stream,
onSegmentCreate: r.OnSegmentCreate,
onSegmentComplete: r.OnSegmentComplete,
parent: r,
}
r.currentInstance.initialize()
go r.run()
}
// Log implements logger.Writer.
func (r *Recorder) Log(level logger.Level, format string, args ...any) {
r.Parent.Log(level, "[recorder] "+format, args...)
}
// Close closes the agent.
func (r *Recorder) Close() {
r.Log(logger.Info, "recording stopped")
close(r.terminate)
<-r.done
}
func (r *Recorder) run() {
defer close(r.done)
for {
select {
case <-r.currentInstance.done:
r.currentInstance.close()
case <-r.terminate:
r.currentInstance.close()
return
}
select {
case <-time.After(r.restartPause):
case <-r.terminate:
return
}
r.currentInstance = &recorderInstance{
pathFormat: r.PathFormat,
format: r.Format,
partDuration: r.PartDuration,
maxPartSize: r.MaxPartSize,
segmentDuration: r.SegmentDuration,
pathName: r.PathName,
stream: r.Stream,
onSegmentCreate: r.OnSegmentCreate,
onSegmentComplete: r.OnSegmentComplete,
parent: r,
}
r.currentInstance.initialize()
}
}
================================================
FILE: internal/recorder/recorder_instance.go
================================================
package recorder
import (
"strings"
"time"
"github.com/google/uuid"
"github.com/bluenviron/mediamtx/internal/conf"
"github.com/bluenviron/mediamtx/internal/logger"
"github.com/bluenviron/mediamtx/internal/recordstore"
"github.com/bluenviron/mediamtx/internal/stream"
)
type recorderInstance struct {
pathFormat string
format conf.RecordFormat
partDuration time.Duration
maxPartSize conf.StringSize
segmentDuration time.Duration
pathName string
stream *stream.Stream
onSegmentCreate OnSegmentCreateFunc
onSegmentComplete OnSegmentCompleteFunc
parent logger.Writer
streamID uuid.UUID
pathFormat2 string
format2 format
skip bool
reader *stream.Reader
terminate chan struct{}
done chan struct{}
}
// Log implements logger.Writer.
func (ri *recorderInstance) Log(level logger.Level, format string, args ...any) {
ri.parent.Log(level, format, args...)
}
func (ri *recorderInstance) initialize() {
ri.streamID = uuid.New()
ri.pathFormat2 = ri.pathFormat
ri.pathFormat2 = recordstore.PathAddExtension(
strings.ReplaceAll(ri.pathFormat2, "%path", ri.pathName),
ri.format,
)
ri.reader = &stream.Reader{
SkipBytesSent: true,
Parent: ri,
}
ri.terminate = make(chan struct{})
ri.done = make(chan struct{})
switch ri.format {
case conf.RecordFormatMPEGTS:
ri.format2 = &formatMPEGTS{
ri: ri,
}
ok := ri.format2.initialize()
ri.skip = !ok
default:
ri.format2 = &formatFMP4{
ri: ri,
}
ok := ri.format2.initialize()
ri.skip = !ok
}
if !ri.skip {
ri.stream.AddReader(ri.reader)
}
go ri.run()
}
func (ri *recorderInstance) close() {
close(ri.terminate)
<-ri.done
}
func (ri *recorderInstance) run() {
defer close(ri.done)
if !ri.skip {
select {
case err := <-ri.reader.Error():
ri.Log(logger.Error, err.Error())
case <-ri.terminate:
}
ri.stream.RemoveReader(ri.reader)
} else {
<-ri.terminate
}
ri.format2.close()
}
================================================
FILE: internal/recorder/recorder_test.go
================================================
package recorder
import (
"fmt"
"os"
"path/filepath"
"testing"
"time"
amp4 "github.com/abema/go-mp4"
"github.com/bluenviron/gortsplib/v5/pkg/description"
rtspformat "github.com/bluenviron/gortsplib/v5/pkg/format"
"github.com/bluenviron/mediacommon/v2/pkg/codecs/mpeg4audio"
"github.com/bluenviron/mediacommon/v2/pkg/formats/fmp4"
mcodecs "github.com/bluenviron/mediacommon/v2/pkg/formats/mp4/codecs"
"github.com/stretchr/testify/require"
"github.com/bluenviron/mediamtx/internal/conf"
"github.com/bluenviron/mediamtx/internal/logger"
"github.com/bluenviron/mediamtx/internal/recordstore"
"github.com/bluenviron/mediamtx/internal/stream"
"github.com/bluenviron/mediamtx/internal/test"
"github.com/bluenviron/mediamtx/internal/unit"
)
func TestRecorder(t *testing.T) {
desc := &description.Session{Medias: []*description.Media{
{
Type: description.MediaTypeVideo,
Formats: []rtspformat.Format{&rtspformat.H264{
PayloadTyp: 96,
PacketizationMode: 1,
}},
},
{
Type: description.MediaTypeVideo,
Formats: []rtspformat.Format{&rtspformat.H265{
PayloadTyp: 96,
}},
},
{
Type: description.MediaTypeAudio,
Formats: []rtspformat.Format{&rtspformat.MPEG4Audio{
PayloadTyp: 96,
Config: &mpeg4audio.AudioSpecificConfig{
Type: 2,
SampleRate: 44100,
ChannelCount: 2,
},
SizeLength: 13,
IndexLength: 3,
IndexDeltaLength: 3,
}},
},
{
Type: description.MediaTypeAudio,
Formats: []rtspformat.Format{&rtspformat.G711{
PayloadTyp: 8,
MULaw: false,
SampleRate: 8000,
ChannelCount: 1,
}},
},
{
Type: description.MediaTypeAudio,
Formats: []rtspformat.Format{&rtspformat.LPCM{
PayloadTyp: 96,
BitDepth: 16,
SampleRate: 44100,
ChannelCount: 2,
}},
},
}}
writeToStream := func(subStream *stream.SubStream, startDTS int64, startNTP time.Time) {
for i := range 2 {
pts := startDTS + int64(i)*100*90000/1000
ntp := startNTP.Add(time.Duration(i*100) * time.Millisecond)
subStream.WriteUnit(desc.Medias[0], desc.Medias[0].Formats[0], &unit.Unit{
PTS: pts,
NTP: ntp,
Payload: unit.PayloadH264{
test.FormatH264.SPS,
test.FormatH264.PPS,
{5}, // IDR
},
})
subStream.WriteUnit(desc.Medias[1], desc.Medias[1].Formats[0], &unit.Unit{
PTS: pts,
Payload: unit.PayloadH265{
{
0x40, 0x01, 0x0c, 0x01, 0xff, 0xff, 0x01, 0x60,
0x00, 0x00, 0x03, 0x00, 0x90, 0x00, 0x00, 0x03,
0x00, 0x00, 0x03, 0x00, 0x78, 0xba, 0x02, 0x40,
},
{
0x42, 0x01, 0x01, 0x01, 0x60, 0x00, 0x00, 0x03,
0x00, 0x90, 0x00, 0x00, 0x03, 0x00, 0x00, 0x03,
0x00, 0x78, 0xa0, 0x03, 0xc0, 0x80, 0x11, 0x07,
0xcb, 0x96, 0xe9, 0x29, 0x30, 0xbc, 0x05, 0xa0,
0x20, 0x00, 0x00, 0x03, 0x00, 0x20, 0x00, 0x00,
0x03, 0x03, 0xc1,
},
{
0x44, 0x01, 0xc0, 0x73, 0xc1, 0x89,
},
{0x26, 0x1, 0xaf, 0x8, 0x42, 0x23, 0x48, 0x8a, 0x43, 0xe2},
},
})
subStream.WriteUnit(desc.Medias[2], desc.Medias[2].Formats[0], &unit.Unit{
PTS: pts * int64(desc.Medias[2].Formats[0].ClockRate()) / 90000,
Payload: unit.PayloadMPEG4Audio{{1, 2, 3, 4}},
})
subStream.WriteUnit(desc.Medias[3], desc.Medias[3].Formats[0], &unit.Unit{
PTS: pts * int64(desc.Medias[3].Formats[0].ClockRate()) / 90000,
Payload: unit.PayloadG711{1, 2, 3, 4},
})
subStream.WriteUnit(desc.Medias[4], desc.Medias[4].Formats[0], &unit.Unit{
PTS: pts * int64(desc.Medias[4].Formats[0].ClockRate()) / 90000,
Payload: unit.PayloadLPCM{1, 2, 3, 4},
})
}
}
for _, ca := range []string{"fmp4", "mpegts"} {
t.Run(ca, func(t *testing.T) {
strm := &stream.Stream{
Desc: desc,
WriteQueueSize: 512,
RTPMaxPayloadSize: 1450,
Parent: test.NilLogger,
}
err := strm.Initialize()
require.NoError(t, err)
defer strm.Close()
subStream := &stream.SubStream{
Stream: strm,
UseRTPPackets: false,
}
err = subStream.Initialize()
require.NoError(t, err)
dir, err := os.MkdirTemp("", "mediamtx-agent")
require.NoError(t, err)
defer os.RemoveAll(dir)
recordPath := filepath.Join(dir, "%path/%Y-%m-%d_%H-%M-%S-%f")
segCreated := make(chan struct{}, 4)
segDone := make(chan struct{}, 4)
var f conf.RecordFormat
if ca == "fmp4" {
f = conf.RecordFormatFMP4
} else {
f = conf.RecordFormatMPEGTS
}
var ext string
if ca == "fmp4" {
ext = "mp4"
} else {
ext = "ts"
}
n := 0
w := &Recorder{
PathFormat: recordPath,
Format: f,
PartDuration: 100 * time.Millisecond,
MaxPartSize: 50 * 1024 * 1024,
SegmentDuration: 1 * time.Second,
PathName: "mypath",
Stream: strm,
OnSegmentCreate: func(segPath string) {
switch n {
case 0:
require.Equal(t, filepath.Join(dir, "mypath", "2008-05-20_22-15-25-000000."+ext), segPath)
case 1:
require.Equal(t, filepath.Join(dir, "mypath", "2008-05-20_22-15-27-000000."+ext), segPath)
default:
require.Equal(t, filepath.Join(dir, "mypath", "2010-05-20_22-15-25-000000."+ext), segPath)
}
segCreated <- struct{}{}
},
OnSegmentComplete: func(segPath string, du time.Duration) {
switch n {
case 0:
require.Equal(t, filepath.Join(dir, "mypath", "2008-05-20_22-15-25-000000."+ext), segPath)
require.Equal(t, 2*time.Second, du)
case 1:
require.Equal(t, filepath.Join(dir, "mypath", "2008-05-20_22-15-27-000000."+ext), segPath)
require.Equal(t, 100*time.Millisecond, du)
default:
require.Equal(t, filepath.Join(dir, "mypath", "2010-05-20_22-15-25-000000."+ext), segPath)
require.Equal(t, 100*time.Millisecond, du)
}
n++
segDone <- struct{}{}
},
Parent: test.NilLogger,
restartPause: 1 * time.Millisecond,
}
w.Initialize()
writeToStream(subStream,
50*90000,
time.Date(2008, 5, 20, 22, 15, 25, 0, time.UTC))
writeToStream(subStream,
52*90000,
time.Date(2008, 5, 20, 22, 15, 27, 0, time.UTC))
// simulate a write error
subStream.WriteUnit(desc.Medias[0], desc.Medias[0].Formats[0], &unit.Unit{
PTS: 0,
Payload: unit.PayloadH264{
{5}, // IDR
},
})
for range 2 {
<-segCreated
<-segDone
}
if ca == "fmp4" {
var init fmp4.Init
func() {
f, err2 := os.Open(filepath.Join(dir, "mypath", "2008-05-20_22-15-25-000000."+ext))
require.NoError(t, err2)
defer f.Close()
err2 = init.Unmarshal(f)
require.NoError(t, err2)
}()
require.Equal(t, fmp4.Init{
Tracks: []*fmp4.InitTrack{
{
ID: 1,
TimeScale: 90000,
Codec: &mcodecs.H264{
SPS: test.FormatH264.SPS,
PPS: test.FormatH264.PPS,
},
},
{
ID: 2,
TimeScale: 90000,
Codec: &mcodecs.H265{
VPS: []byte{
0x40, 0x01, 0x0c, 0x01, 0xff, 0xff, 0x01, 0x60,
0x00, 0x00, 0x03, 0x00, 0x90, 0x00, 0x00, 0x03,
0x00, 0x00, 0x03, 0x00, 0x78, 0xba, 0x02, 0x40,
},
SPS: []byte{
0x42, 0x01, 0x01, 0x01, 0x60, 0x00, 0x00, 0x03,
0x00, 0x90, 0x00, 0x00, 0x03, 0x00, 0x00, 0x03,
0x00, 0x78, 0xa0, 0x03, 0xc0, 0x80, 0x11, 0x07,
0xcb, 0x96, 0xe9, 0x29, 0x30, 0xbc, 0x05, 0xa0,
0x20, 0x00, 0x00, 0x03, 0x00, 0x20, 0x00, 0x00,
0x03, 0x03, 0xc1,
},
PPS: []byte{
0x44, 0x01, 0xc0, 0x73, 0xc1, 0x89,
},
},
},
{
ID: 3,
TimeScale: 44100,
Codec: &mcodecs.MPEG4Audio{
Config: mpeg4audio.AudioSpecificConfig{
Type: 2,
SampleRate: 44100,
ChannelCount: 2,
ChannelConfig: 2,
},
},
},
{
ID: 4,
TimeScale: 8000,
Codec: &mcodecs.LPCM{
BitDepth: 16,
SampleRate: 8000,
ChannelCount: 1,
},
},
{
ID: 5,
TimeScale: 44100,
Codec: &mcodecs.LPCM{
BitDepth: 16,
SampleRate: 44100,
ChannelCount: 2,
},
},
},
UserData: []amp4.IBox{
&recordstore.Mtxi{
StreamID: init.UserData[0].(*recordstore.Mtxi).StreamID,
DTS: 50000000000,
NTP: 1211321725000000000,
},
},
}, init)
_, err = os.Stat(filepath.Join(dir, "mypath", "2008-05-20_22-15-27-000000."+ext))
require.NoError(t, err)
} else {
_, err = os.Stat(filepath.Join(dir, "mypath", "2008-05-20_22-15-25-000000."+ext))
require.NoError(t, err)
_, err = os.Stat(filepath.Join(dir, "mypath", "2008-05-20_22-15-27-000000."+ext))
require.NoError(t, err)
}
time.Sleep(50 * time.Millisecond)
writeToStream(subStream,
300*90000,
time.Date(2010, 5, 20, 22, 15, 25, 0, time.UTC))
time.Sleep(50 * time.Millisecond)
w.Close()
<-segCreated
<-segDone
_, err = os.Stat(filepath.Join(dir, "mypath", "2010-05-20_22-15-25-000000."+ext))
require.NoError(t, err)
if ca == "fmp4" {
var byts []byte
byts, err = os.ReadFile(filepath.Join(dir, "mypath", "2008-05-20_22-15-25-000000.mp4"))
require.NoError(t, err)
var parts fmp4.Parts
err = parts.Unmarshal(byts)
require.NoError(t, err)
for _, part := range parts {
for _, track := range part.Tracks {
track.Samples = nil
}
}
require.Equal(t, fmp4.Parts{
{
Tracks: []*fmp4.PartTrack{{
ID: 1,
}},
},
{
SequenceNumber: 1,
Tracks: []*fmp4.PartTrack{{
ID: 2,
}},
},
{
SequenceNumber: 2,
Tracks: []*fmp4.PartTrack{{
ID: 3,
}},
},
{
SequenceNumber: 3,
Tracks: []*fmp4.PartTrack{{
ID: 4,
}},
},
{
SequenceNumber: 4,
Tracks: []*fmp4.PartTrack{{
ID: 5,
}},
},
{
SequenceNumber: 5,
Tracks: []*fmp4.PartTrack{{
ID: 1,
BaseTime: 9000,
}},
},
}, parts)
}
})
}
}
func TestRecorderFMP4NegativeInitialDTS(t *testing.T) {
desc := &description.Session{Medias: []*description.Media{
{
Type: description.MediaTypeVideo,
Formats: []rtspformat.Format{&rtspformat.H264{
PayloadTyp: 96,
PacketizationMode: 1,
}},
},
{
Type: description.MediaTypeAudio,
Formats: []rtspformat.Format{&rtspformat.MPEG4Audio{
PayloadTyp: 96,
Config: &mpeg4audio.AudioSpecificConfig{
Type: 2,
SampleRate: 44100,
ChannelCount: 2,
},
SizeLength: 13,
IndexLength: 3,
IndexDeltaLength: 3,
}},
},
}}
strm := &stream.Stream{
Desc: desc,
WriteQueueSize: 512,
RTPMaxPayloadSize: 1450,
Parent: test.NilLogger,
}
err := strm.Initialize()
require.NoError(t, err)
defer strm.Close()
subStream := &stream.SubStream{
Stream: strm,
UseRTPPackets: false,
}
err = subStream.Initialize()
require.NoError(t, err)
dir, err := os.MkdirTemp("", "mediamtx-agent")
require.NoError(t, err)
defer os.RemoveAll(dir)
recordPath := filepath.Join(dir, "%path/%Y-%m-%d_%H-%M-%S-%f")
w := &Recorder{
PathFormat: recordPath,
Format: conf.RecordFormatFMP4,
PartDuration: 100 * time.Millisecond,
MaxPartSize: 50 * 1024 * 1024,
SegmentDuration: 1 * time.Second,
PathName: "mypath",
Stream: strm,
Parent: test.NilLogger,
}
w.Initialize()
for i := range 3 {
subStream.WriteUnit(desc.Medias[0], desc.Medias[0].Formats[0], &unit.Unit{
PTS: -50*90000/1000 + (int64(i) * 200 * 90000 / 1000),
NTP: time.Date(2008, 5, 20, 22, 15, 25, 0, time.UTC),
Payload: unit.PayloadH264{
test.FormatH264.SPS,
test.FormatH264.PPS,
{5}, // IDR
},
})
subStream.WriteUnit(desc.Medias[1], desc.Medias[1].Formats[0], &unit.Unit{
PTS: -100*44100/1000 + (int64(i) * 200 * 44100 / 1000),
Payload: unit.PayloadMPEG4Audio{{1, 2, 3, 4}},
})
}
time.Sleep(50 * time.Millisecond)
w.Close()
byts, err := os.ReadFile(filepath.Join(dir, "mypath", "2008-05-20_22-15-25-000000.mp4"))
require.NoError(t, err)
var parts fmp4.Parts
err = parts.Unmarshal(byts)
require.NoError(t, err)
found := false
for _, part := range parts {
for _, track := range part.Tracks {
if track.ID == 2 {
require.Equal(t, uint64(6615), track.BaseTime)
found = true
}
}
}
require.True(t, found)
}
func TestRecorderFMP4NegativeDTSDiff(t *testing.T) {
desc := &description.Session{Medias: []*description.Media{
{
Type: description.MediaTypeVideo,
Formats: []rtspformat.Format{&rtspformat.MPEG4Audio{
PayloadTyp: 96,
Config: &mpeg4audio.AudioSpecificConfig{
Type: 2,
SampleRate: 44100,
ChannelCount: 2,
},
SizeLength: 13,
IndexLength: 3,
IndexDeltaLength: 3,
}},
},
}}
strm := &stream.Stream{
Desc: desc,
WriteQueueSize: 512,
RTPMaxPayloadSize: 1450,
Parent: test.NilLogger,
}
err := strm.Initialize()
require.NoError(t, err)
defer strm.Close()
subStream := &stream.SubStream{
Stream: strm,
UseRTPPackets: false,
}
err = subStream.Initialize()
require.NoError(t, err)
dir, err := os.MkdirTemp("", "mediamtx-agent")
require.NoError(t, err)
defer os.RemoveAll(dir)
recordPath := filepath.Join(dir, "%path/%Y-%m-%d_%H-%M-%S-%f")
w := &Recorder{
PathFormat: recordPath,
Format: conf.RecordFormatFMP4,
PartDuration: 100 * time.Millisecond,
MaxPartSize: 50 * 1024 * 1024,
SegmentDuration: 2 * time.Second,
PathName: "mypath",
Stream: strm,
Parent: test.NilLogger,
}
w.Initialize()
subStream.WriteUnit(desc.Medias[0], desc.Medias[0].Formats[0], &unit.Unit{
PTS: 44100,
NTP: time.Date(2008, 5, 20, 22, 15, 25, 0, time.UTC),
Payload: unit.PayloadMPEG4Audio{{1, 2}},
})
subStream.WriteUnit(desc.Medias[0], desc.Medias[0].Formats[0], &unit.Unit{
PTS: 3 * 44100,
NTP: time.Date(2008, 5, 20, 22, 15, 25, 0, time.UTC),
Payload: unit.PayloadMPEG4Audio{{1, 2}},
})
subStream.WriteUnit(desc.Medias[0], desc.Medias[0].Formats[0], &unit.Unit{
PTS: 2 * 44100,
NTP: time.Date(2008, 5, 20, 22, 15, 25, 0, time.UTC),
Payload: unit.PayloadMPEG4Audio{{1, 2}},
})
subStream.WriteUnit(desc.Medias[0], desc.Medias[0].Formats[0], &unit.Unit{
PTS: 4 * 44100,
NTP: time.Date(2008, 5, 20, 22, 15, 25, 0, time.UTC),
Payload: unit.PayloadMPEG4Audio{{1, 2}},
})
time.Sleep(50 * time.Millisecond)
w.Close()
byts, err := os.ReadFile(filepath.Join(dir, "mypath", "2008-05-20_22-15-25-000000.mp4"))
require.NoError(t, err)
var parts fmp4.Parts
err = parts.Unmarshal(byts)
require.NoError(t, err)
require.Equal(t, fmp4.Parts{{
Tracks: []*fmp4.PartTrack{{
ID: 1,
Samples: []*fmp4.Sample{
{
Payload: []byte{1, 2},
},
{
Duration: 44100,
Payload: []byte{1, 2},
},
},
}},
}}, parts)
}
func TestRecorderSkipTracksPartial(t *testing.T) {
for _, ca := range []string{"fmp4", "mpegts"} {
t.Run(ca, func(t *testing.T) {
desc := &description.Session{Medias: []*description.Media{
{
Type: description.MediaTypeVideo,
Formats: []rtspformat.Format{&rtspformat.H264{}},
},
{
Type: description.MediaTypeVideo,
Formats: []rtspformat.Format{&rtspformat.VP8{}},
},
}}
strm := &stream.Stream{
Desc: desc,
WriteQueueSize: 512,
RTPMaxPayloadSize: 1450,
Parent: test.NilLogger,
}
err := strm.Initialize()
require.NoError(t, err)
defer strm.Close()
subStream := &stream.SubStream{
Stream: strm,
UseRTPPackets: false,
}
err = subStream.Initialize()
require.NoError(t, err)
dir, err := os.MkdirTemp("", "mediamtx-agent")
require.NoError(t, err)
defer os.RemoveAll(dir)
recordPath := filepath.Join(dir, "%path/%Y-%m-%d_%H-%M-%S-%f")
n := 0
l := test.Logger(func(l logger.Level, format string, args ...any) {
if n == 0 {
require.Equal(t, logger.Warn, l)
require.Equal(t, "[recorder] skipping track 2 (VP8)", fmt.Sprintf(format, args...))
}
n++
})
var fo conf.RecordFormat
if ca == "fmp4" {
fo = conf.RecordFormatFMP4
} else {
fo = conf.RecordFormatMPEGTS
}
w := &Recorder{
PathFormat: recordPath,
Format: fo,
PartDuration: 100 * time.Millisecond,
MaxPartSize: 50 * 1024 * 1024,
SegmentDuration: 1 * time.Second,
PathName: "mypath",
Stream: strm,
Parent: l,
}
w.Initialize()
defer w.Close()
require.Equal(t, 2, n)
})
}
}
func TestRecorderSkipTracksFull(t *testing.T) {
for _, ca := range []string{"fmp4", "mpegts"} {
t.Run(ca, func(t *testing.T) {
desc := &description.Session{Medias: []*description.Media{
{
Type: description.MediaTypeVideo,
Formats: []rtspformat.Format{&rtspformat.VP8{}},
},
}}
strm := &stream.Stream{
Desc: desc,
WriteQueueSize: 512,
RTPMaxPayloadSize: 1450,
Parent: test.NilLogger,
}
err := strm.Initialize()
require.NoError(t, err)
defer strm.Close()
subStream := &stream.SubStream{
Stream: strm,
UseRTPPackets: false,
}
err = subStream.Initialize()
require.NoError(t, err)
dir, err := os.MkdirTemp("", "mediamtx-agent")
require.NoError(t, err)
defer os.RemoveAll(dir)
recordPath := filepath.Join(dir, "%path/%Y-%m-%d_%H-%M-%S-%f")
n := 0
l := test.Logger(func(l logger.Level, format string, args ...any) {
if n == 0 {
require.Equal(t, logger.Warn, l)
require.Equal(t, "[recorder] no supported tracks found, skipping recording", fmt.Sprintf(format, args...))
}
n++
})
var fo conf.RecordFormat
if ca == "fmp4" {
fo = conf.RecordFormatFMP4
} else {
fo = conf.RecordFormatMPEGTS
}
w := &Recorder{
PathFormat: recordPath,
Format: fo,
PartDuration: 100 * time.Millisecond,
MaxPartSize: 50 * 1024 * 1024,
SegmentDuration: 1 * time.Second,
PathName: "mypath",
Stream: strm,
Parent: l,
}
w.Initialize()
defer w.Close()
require.Equal(t, 1, n)
})
}
}
func TestRecorderFMP4SegmentSwitch(t *testing.T) {
desc := &description.Session{Medias: []*description.Media{
{
Type: description.MediaTypeVideo,
Formats: []rtspformat.Format{test.FormatH264},
},
{
Type: description.MediaTypeAudio,
Formats: []rtspformat.Format{test.FormatMPEG4Audio},
},
}}
strm := &stream.Stream{
Desc: desc,
WriteQueueSize: 512,
RTPMaxPayloadSize: 1450,
Parent: test.NilLogger,
}
err := strm.Initialize()
require.NoError(t, err)
defer strm.Close()
subStream := &stream.SubStream{
Stream: strm,
UseRTPPackets: false,
}
err = subStream.Initialize()
require.NoError(t, err)
dir, err := os.MkdirTemp("", "mediamtx-agent")
require.NoError(t, err)
defer os.RemoveAll(dir)
n := 0
w := &Recorder{
PathFormat: filepath.Join(dir, "%path/%Y-%m-%d_%H-%M-%S-%f"),
Format: conf.RecordFormatFMP4,
PartDuration: 100 * time.Millisecond,
MaxPartSize: 50 * 1024 * 1024,
SegmentDuration: 1 * time.Second,
PathName: "mypath",
Stream: strm,
Parent: test.NilLogger,
OnSegmentCreate: func(segPath string) {
switch n {
case 0:
require.Equal(t, filepath.Join(dir, "mypath", "2008-05-20_22-15-25-000000.mp4"), segPath)
case 1:
require.Equal(t, filepath.Join(dir, "mypath", "2008-05-20_22-15-25-700000.mp4"), segPath) // +0.7s
}
n++
},
}
w.Initialize()
pts := 50 * time.Second
ntp := time.Date(2008, 5, 20, 22, 15, 25, 0, time.UTC)
subStream.WriteUnit(desc.Medias[0], desc.Medias[0].Formats[0], &unit.Unit{
PTS: int64(pts) * 90000 / int64(time.Second),
NTP: ntp,
Payload: unit.PayloadH264{
{5}, // IDR
},
})
pts += 700 * time.Millisecond
ntp = ntp.Add(700 * time.Millisecond)
subStream.WriteUnit(desc.Medias[1], desc.Medias[1].Formats[0], &unit.Unit{ // segment switch should happen here
PTS: int64(pts) * 44100 / int64(time.Second),
NTP: ntp,
Payload: unit.PayloadMPEG4Audio{{1, 2}},
})
pts += 400 * time.Millisecond
ntp = ntp.Add(400 * time.Millisecond)
subStream.WriteUnit(desc.Medias[0], desc.Medias[0].Formats[0], &unit.Unit{
PTS: int64(pts) * 90000 / int64(time.Second),
NTP: ntp,
Payload: unit.PayloadH264{
{5}, // IDR
},
})
pts += 100 * time.Millisecond
ntp = ntp.Add(100 * time.Millisecond)
subStream.WriteUnit(desc.Medias[1], desc.Medias[1].Formats[0], &unit.Unit{
PTS: int64(pts) * 44100 / int64(time.Second),
NTP: ntp,
Payload: unit.PayloadMPEG4Audio{{3, 4}},
})
pts += 400 * time.Millisecond
ntp = ntp.Add(400 * time.Millisecond)
subStream.WriteUnit(desc.Medias[0], desc.Medias[0].Formats[0], &unit.Unit{
PTS: int64(pts) * 90000 / int64(time.Second),
NTP: ntp,
Payload: unit.PayloadH264{
{5}, // IDR
},
})
time.Sleep(100 * time.Millisecond)
w.Close()
require.Equal(t, 2, n)
}
func TestRecorderTimeDriftDetector(t *testing.T) {
for _, ca := range []string{"fmp4", "mpegts"} {
t.Run(ca, func(t *testing.T) {
desc := &description.Session{Medias: []*description.Media{
{
Type: description.MediaTypeVideo,
Formats: []rtspformat.Format{&rtspformat.H264{
PayloadTyp: 96,
PacketizationMode: 1,
}},
},
{
Type: description.MediaTypeAudio,
Formats: []rtspformat.Format{&rtspformat.MPEG4Audio{
PayloadTyp: 96,
Config: &mpeg4audio.AudioSpecificConfig{
Type: 2,
SampleRate: 44100,
ChannelCount: 2,
},
SizeLength: 13,
IndexLength: 3,
IndexDeltaLength: 3,
}},
},
}}
strm := &stream.Stream{
Desc: desc,
WriteQueueSize: 512,
RTPMaxPayloadSize: 1450,
Parent: test.NilLogger,
}
err := strm.Initialize()
require.NoError(t, err)
defer strm.Close()
subStream := &stream.SubStream{
Stream: strm,
UseRTPPackets: false,
}
err = subStream.Initialize()
require.NoError(t, err)
dir, err := os.MkdirTemp("", "mediamtx-agent")
require.NoError(t, err)
defer os.RemoveAll(dir)
recordPath := filepath.Join(dir, "%path/%Y-%m-%d_%H-%M-%S-%f")
var ext string
if ca == "fmp4" {
ext = "mp4"
} else {
ext = "ts"
}
segCreated := make(chan struct{}, 10)
segDone := make(chan struct{}, 10)
var f conf.RecordFormat
if ca == "fmp4" {
f = conf.RecordFormatFMP4
} else {
f = conf.RecordFormatMPEGTS
}
w := &Recorder{
PathFormat: recordPath,
Format: f,
PartDuration: 100 * time.Millisecond,
MaxPartSize: 50 * 1024 * 1024,
SegmentDuration: 1 * time.Second,
PathName: "mypath",
Stream: strm,
OnSegmentCreate: func(_ string) {
select {
case segCreated <- struct{}{}:
default:
}
},
OnSegmentComplete: func(_ string, _ time.Duration) {
select {
case segDone <- struct{}{}:
default:
}
},
Parent: test.NilLogger,
restartPause: 10 * time.Millisecond,
}
w.Initialize()
// Write initial samples with correct timing
startDTS := int64(50 * 90000)
startNTP := time.Date(2008, 5, 20, 22, 15, 25, 0, time.UTC)
for i := range 3 {
pts := startDTS + int64(i)*100*90000/1000
ntp := startNTP.Add(time.Duration(i*100) * time.Millisecond)
subStream.WriteUnit(desc.Medias[0], desc.Medias[0].Formats[0], &unit.Unit{
PTS: pts,
NTP: ntp,
Payload: unit.PayloadH264{
test.FormatH264.SPS,
test.FormatH264.PPS,
{5}, // IDR
},
})
subStream.WriteUnit(desc.Medias[1], desc.Medias[1].Formats[0], &unit.Unit{
PTS: pts * int64(desc.Medias[1].Formats[0].ClockRate()) / 90000,
NTP: ntp,
Payload: unit.PayloadMPEG4Audio{{1, 2, 3, 4}},
})
}
// Wait for first segment to be created
select {
case <-segCreated:
case <-time.After(2 * time.Second):
t.Fatal("timeout waiting for first segment")
}
// Write more samples to ensure segment has data
for i := 3; i < 15; i++ {
pts := startDTS + int64(i)*100*90000/1000
ntp := startNTP.Add(time.Duration(i*100) * time.Millisecond)
subStream.WriteUnit(desc.Medias[0], desc.Medias[0].Formats[0], &unit.Unit{
PTS: pts,
NTP: ntp,
Payload: unit.PayloadH264{
test.FormatH264.SPS,
test.FormatH264.PPS,
{5}, // IDR
},
})
subStream.WriteUnit(desc.Medias[1], desc.Medias[1].Formats[0], &unit.Unit{
PTS: pts * int64(desc.Medias[1].Formats[0].ClockRate()) / 90000,
NTP: ntp,
Payload: unit.PayloadMPEG4Audio{{1, 2, 3, 4}},
})
}
// Simulate a time drift by advancing NTP time by more than 5 seconds
// while keeping DTS progression normal (only 100ms forward)
driftedPTS := startDTS + 15*100*90000/1000
driftedNTP := startNTP.Add(15*100*time.Millisecond + 6*time.Second) // 6 second drift
subStream.WriteUnit(desc.Medias[0], desc.Medias[0].Formats[0], &unit.Unit{
PTS: driftedPTS,
NTP: driftedNTP,
Payload: unit.PayloadH264{
test.FormatH264.SPS,
test.FormatH264.PPS,
{5}, // IDR
},
})
// Wait for the recorder to detect the drift, complete the segment, and restart
select {
case <-segDone:
case <-time.After(2 * time.Second):
t.Fatal("timeout waiting for segment completion after drift")
}
// Give the recorder time to restart
time.Sleep(100 * time.Millisecond)
// Write samples after restart with corrected timing
restartDTS := int64(60 * 90000)
restartNTP := time.Date(2008, 5, 20, 22, 15, 35, 0, time.UTC)
for i := range 3 {
pts := restartDTS + int64(i)*100*90000/1000
ntp := restartNTP.Add(time.Duration(i*100) * time.Millisecond)
subStream.WriteUnit(desc.Medias[0], desc.Medias[0].Formats[0], &unit.Unit{
PTS: pts,
NTP: ntp,
Payload: unit.PayloadH264{
test.FormatH264.SPS,
test.FormatH264.PPS,
{5}, // IDR
},
})
subStream.WriteUnit(desc.Medias[1], desc.Medias[1].Formats[0], &unit.Unit{
PTS: pts * int64(desc.Medias[1].Formats[0].ClockRate()) / 90000,
NTP: ntp,
Payload: unit.PayloadMPEG4Audio{{1, 2, 3, 4}},
})
}
// Wait for second segment to be created after restart
select {
case <-segCreated:
case <-time.After(2 * time.Second):
t.Fatal("timeout waiting for segment after restart")
}
time.Sleep(50 * time.Millisecond)
w.Close()
// Wait for final segment to complete
select {
case <-segDone:
case <-time.After(2 * time.Second):
// This is not fatal as the final segment may complete during Close()
}
// Verify that files were created
entries, err := os.ReadDir(filepath.Join(dir, "mypath"))
require.NoError(t, err)
require.GreaterOrEqual(t, len(entries), 2, "expected at least 2 segments (before and after drift)")
// Verify files have the expected extension
for _, entry := range entries {
require.Equal(t, "."+ext, filepath.Ext(entry.Name()))
}
})
}
}
================================================
FILE: internal/recordstore/mp4_boxes.go
================================================
package recordstore
import (
amp4 "github.com/abema/go-mp4"
)
func boxTypeMtxi() amp4.BoxType { return amp4.StrToBoxType("mtxi") }
func init() { //nolint:gochecknoinits
amp4.AddBoxDef(&Mtxi{}, 0)
}
// Mtxi is a MediaMTX segment info.
type Mtxi struct {
amp4.FullBox `mp4:"0,extend"`
StreamID [16]byte `mp4:"1,size=8"`
SegmentNumber uint64 `mp4:"2,size=64"`
DTS int64 `mp4:"3,size=64"`
NTP int64 `mp4:"4,size=64"`
}
// GetType implements amp4.IBox.
func (*Mtxi) GetType() amp4.BoxType {
return boxTypeMtxi()
}
================================================
FILE: internal/recordstore/path.go
================================================
package recordstore
import (
"regexp"
"strconv"
"strings"
"time"
"github.com/bluenviron/mediamtx/internal/conf"
)
func leadingZeros(v int, size int) string {
out := strconv.FormatInt(int64(v), 10)
if len(out) >= size {
return out
}
out2 := ""
for i := 0; i < (size - len(out)); i++ {
out2 += "0"
}
return out2 + out
}
func timeLocationEncode(t time.Time) string {
_, off := t.Zone()
if off == 0 {
return "Z"
}
var ret string
if off > 0 {
ret = "+"
} else {
ret = "-"
off = -off
}
ret += leadingZeros(off/60/60, 2)
ret += leadingZeros((off/60)%60, 2)
return ret
}
func timeLocationDecode(s string) *time.Location {
if s == "Z" {
return time.UTC
}
var sign int
if s[0] == '+' {
sign = 1
} else {
sign = -1
}
v1, _ := strconv.ParseInt(s[1:3], 10, 64)
v2, _ := strconv.ParseInt(s[3:5], 10, 64)
off := sign*int(v1)*3600 + int(v2)*3600
return time.FixedZone("myzone", off)
}
// PathAddExtension adds the file extension to the path.
func PathAddExtension(path string, format conf.RecordFormat) string {
switch format {
case conf.RecordFormatMPEGTS:
return path + ".ts"
default:
return path + ".mp4"
}
}
// CommonPath returns the common path between all segments with given recording path.
func CommonPath(v string) string {
common := ""
remaining := v
for {
i := strings.IndexAny(remaining, "\\/")
if i < 0 {
break
}
var part string
part, remaining = remaining[:i+1], remaining[i+1:]
if strings.Contains(part, "%") {
break
}
common += part
}
if len(common) > 0 {
common = common[:len(common)-1]
}
return common
}
// Path is a path of a recording segment.
type Path struct {
Start time.Time
Path string
}
// Decode decodes a Path.
func (p *Path) Decode(format string, v string) bool {
re := format
for _, ch := range []uint8{
'\\',
'.',
'+',
'*',
'?',
'^',
'$',
'(',
')',
'[',
']',
'{',
'}',
'|',
} {
re = strings.ReplaceAll(re, string(ch), "\\"+string(ch))
}
re = strings.ReplaceAll(re, "%path", "(.*?)")
re = strings.ReplaceAll(re, "%Y", "([0-9]{4})")
re = strings.ReplaceAll(re, "%m", "([0-9]{2})")
re = strings.ReplaceAll(re, "%d", "([0-9]{2})")
re = strings.ReplaceAll(re, "%H", "([0-9]{2})")
re = strings.ReplaceAll(re, "%M", "([0-9]{2})")
re = strings.ReplaceAll(re, "%S", "([0-9]{2})")
re = strings.ReplaceAll(re, "%f", "([0-9]{6})")
re = strings.ReplaceAll(re, "%z", "(Z|\\+[0-9]{4}|-[0-9]{4})")
re = strings.ReplaceAll(re, "%s", "([0-9]{10})")
r := regexp.MustCompile(re)
var groupMapping []string
cur := format
for {
i := strings.Index(cur, "%")
if i < 0 {
break
}
cur = cur[i:]
for _, va := range []string{
"%path",
"%Y",
"%m",
"%d",
"%H",
"%M",
"%S",
"%f",
"%z",
"%s",
} {
if strings.HasPrefix(cur, va) {
groupMapping = append(groupMapping, va)
}
}
cur = cur[1:]
}
matches := r.FindStringSubmatch(v)
if matches == nil {
return false
}
values := make(map[string]string)
for i, match := range matches[1:] {
values[groupMapping[i]] = match
}
var year int
var month time.Month = 1
day := 1
var hour int
var minute int
var second int
var micros int
var unixSec int64 = -1
loc := time.Local
for k, v := range values {
switch k {
case "%path":
p.Path = v
case "%Y":
tmp, _ := strconv.ParseInt(v, 10, 64)
year = int(tmp)
case "%m":
tmp, _ := strconv.ParseInt(v, 10, 64)
month = time.Month(int(tmp))
case "%d":
tmp, _ := strconv.ParseInt(v, 10, 64)
day = int(tmp)
case "%H":
tmp, _ := strconv.ParseInt(v, 10, 64)
hour = int(tmp)
case "%M":
tmp, _ := strconv.ParseInt(v, 10, 64)
minute = int(tmp)
case "%S":
tmp, _ := strconv.ParseInt(v, 10, 64)
second = int(tmp)
case "%f":
tmp, _ := strconv.ParseInt(v, 10, 64)
micros = int(tmp)
case "%z":
loc = timeLocationDecode(v)
case "%s":
unixSec, _ = strconv.ParseInt(v, 10, 64)
}
}
if unixSec > 0 {
p.Start = time.Unix(unixSec, int64(micros)*1000)
} else {
p.Start = time.Date(year, month, day, hour, minute, second, micros*1000, loc)
}
return true
}
// Encode encodes a path.
func (p Path) Encode(format string) string {
format = strings.ReplaceAll(format, "%path", p.Path)
format = strings.ReplaceAll(format, "%Y", strconv.FormatInt(int64(p.Start.Year()), 10))
format = strings.ReplaceAll(format, "%m", leadingZeros(int(p.Start.Month()), 2))
format = strings.ReplaceAll(format, "%d", leadingZeros(p.Start.Day(), 2))
format = strings.ReplaceAll(format, "%H", leadingZeros(p.Start.Hour(), 2))
format = strings.ReplaceAll(format, "%M", leadingZeros(p.Start.Minute(), 2))
format = strings.ReplaceAll(format, "%S", leadingZeros(p.Start.Second(), 2))
format = strings.ReplaceAll(format, "%f", leadingZeros(p.Start.Nanosecond()/1000, 6))
format = strings.ReplaceAll(format, "%z", timeLocationEncode(p.Start))
format = strings.ReplaceAll(format, "%s", strconv.FormatInt(p.Start.Unix(), 10))
return format
}
================================================
FILE: internal/recordstore/path_test.go
================================================
package recordstore
import (
"testing"
"time"
"github.com/stretchr/testify/require"
)
var pathCases = []struct {
name string
format string
dec Path
enc string
}{
{
"standard",
"%path/%Y-%m-%d_%H-%M-%S-%f.mp4",
Path{
Start: time.Date(2008, 11, 7, 11, 22, 4, 123456000, time.Local),
Path: "mypath",
},
"mypath/2008-11-07_11-22-04-123456.mp4",
},
{
"unix seconds",
"%path/%s.mp4",
Path{
Start: time.Date(2021, 12, 2, 12, 15, 23, 0, time.UTC).Local(),
Path: "mypath",
},
"mypath/1638447323.mp4",
},
{
"unix microseconds",
"%path/%s.%f.mp4",
Path{
Start: time.Date(2021, 12, 2, 12, 15, 23, 567324000, time.UTC).Local(),
Path: "mypath",
},
"mypath/1638447323.567324.mp4",
},
{
"timezone utc",
"%path/%Y-%m-%d_%H-%M-%S-%f_%z.mp4",
Path{
Start: time.Date(2021, 12, 2, 12, 15, 23, 567324000, time.UTC),
Path: "mypath",
},
"mypath/2021-12-02_12-15-23-567324_Z.mp4",
},
{
"timezone plus",
"%path/%Y-%m-%d_%H-%M-%S-%f_%z.mp4",
Path{
Start: time.Date(2021, 12, 2, 12, 15, 23, 567324000, time.FixedZone("myzone", 7200)),
Path: "mypath",
},
"mypath/2021-12-02_12-15-23-567324_+0200.mp4",
},
{
"timezone minus",
"%path/%Y-%m-%d_%H-%M-%S-%f_%z.mp4",
Path{
Start: time.Date(2021, 12, 2, 12, 15, 23, 567324000, time.FixedZone("myzone", -7200)),
Path: "mypath",
},
"mypath/2021-12-02_12-15-23-567324_-0200.mp4",
},
}
func TestPathDecode(t *testing.T) {
for _, ca := range pathCases {
t.Run(ca.name, func(t *testing.T) {
var dec Path
ok := dec.Decode(ca.format, ca.enc)
require.Equal(t, true, ok)
require.Equal(t, ca.dec, dec)
})
}
}
func TestPathEncode(t *testing.T) {
for _, ca := range pathCases {
t.Run(ca.name, func(t *testing.T) {
require.Equal(t, ca.enc, ca.dec.Encode(ca.format))
})
}
}
================================================
FILE: internal/recordstore/recordstore.go
================================================
// Package recordstore contains utilities to store/retrieve recordings to/from disk.
package recordstore
================================================
FILE: internal/recordstore/segment.go
================================================
package recordstore
import (
"errors"
"io/fs"
"path/filepath"
"sort"
"strings"
"time"
"github.com/bluenviron/mediamtx/internal/conf"
)
// ErrNoSegmentsFound is returned when no recording segments have been found.
var ErrNoSegmentsFound = errors.New("no recording segments found")
var errFound = errors.New("found")
// Segment is a recording segment.
type Segment struct {
Fpath string
Start time.Time
}
func fixedPathHasSegments(pathConf *conf.Path) bool {
recordPath := PathAddExtension(
strings.ReplaceAll(pathConf.RecordPath, "%path", pathConf.Name),
pathConf.RecordFormat,
)
// we have to convert to absolute paths
// otherwise, recordPath and fpath inside Walk() won't have common elements
recordPath, _ = filepath.Abs(recordPath)
commonPath := CommonPath(recordPath)
err := filepath.WalkDir(commonPath, func(fpath string, info fs.DirEntry, err error) error {
if err != nil {
return err
}
if !info.IsDir() {
var pa Path
ok := pa.Decode(recordPath, fpath)
if ok {
return errFound
}
}
return nil
})
if err != nil && !errors.Is(err, errFound) {
return false
}
return errors.Is(err, errFound)
}
func regexpPathFindPathsWithSegments(pathConf *conf.Path) map[string]struct{} {
recordPath := PathAddExtension(
pathConf.RecordPath,
pathConf.RecordFormat,
)
// we have to convert to absolute paths
// otherwise, recordPath and fpath inside Walk() won't have common elements
recordPath, _ = filepath.Abs(recordPath)
commonPath := CommonPath(recordPath)
ret := make(map[string]struct{})
filepath.WalkDir(commonPath, func(fpath string, info fs.DirEntry, err error) error { //nolint:errcheck
if err != nil {
return err
}
if !info.IsDir() {
var pa Path
if ok := pa.Decode(recordPath, fpath); ok {
if err = conf.IsValidPathName(pa.Path); err == nil {
if pathConf.Regexp.FindStringSubmatch(pa.Path) != nil {
ret[pa.Path] = struct{}{}
}
}
}
}
return nil
})
return ret
}
// FindAllPathsWithSegments returns all paths that have at least one segment.
func FindAllPathsWithSegments(pathConfs map[string]*conf.Path) []string {
pathNames := make(map[string]struct{})
for _, pathConf := range pathConfs {
if pathConf.Regexp == nil {
if fixedPathHasSegments(pathConf) {
pathNames[pathConf.Name] = struct{}{}
}
} else {
for name := range regexpPathFindPathsWithSegments(pathConf) {
pathNames[name] = struct{}{}
}
}
}
out := make([]string, len(pathNames))
n := 0
for k := range pathNames {
out[n] = k
n++
}
sort.Strings(out)
return out
}
// FindSegments returns all segments of a path.
// Segments can be filtered by start date and end date.
func FindSegments(
pathConf *conf.Path,
pathName string,
start *time.Time,
end *time.Time,
) ([]*Segment, error) {
recordPath := PathAddExtension(
strings.ReplaceAll(pathConf.RecordPath, "%path", pathName),
pathConf.RecordFormat,
)
// we have to convert to absolute paths
// otherwise, recordPath and fpath inside Walk() won't have common elements
recordPath, _ = filepath.Abs(recordPath)
commonPath := CommonPath(recordPath)
var segments []*Segment
err := filepath.WalkDir(commonPath, func(fpath string, info fs.DirEntry, err error) error {
if err != nil {
return err
}
if !info.IsDir() {
var pa Path
ok := pa.Decode(recordPath, fpath)
// gather all segments that start before the end of the playback
if ok && (end == nil || !end.Before(pa.Start)) {
segments = append(segments, &Segment{
Fpath: fpath,
Start: pa.Start,
})
}
}
return nil
})
if err != nil {
return nil, err
}
if segments == nil {
return nil, ErrNoSegmentsFound
}
sort.Slice(segments, func(i, j int) bool {
return segments[i].Start.Before(segments[j].Start)
})
if start != nil {
if start.Before(segments[0].Start) {
return segments, nil
}
// find the segment that may contain the start of the playback and remove all previous ones
found := false
for i := 0; i < len(segments)-1; i++ {
if !start.Before(segments[i].Start) && start.Before(segments[i+1].Start) {
segments = segments[i:]
found = true
break
}
}
// otherwise, keep the last segment only and check if it may contain the start of the playback
if !found {
segments = segments[len(segments)-1:]
if segments[len(segments)-1].Start.After(*start) {
return nil, ErrNoSegmentsFound
}
}
}
return segments, nil
}
================================================
FILE: internal/recordstore/segment_test.go
================================================
package recordstore
import (
"os"
"path/filepath"
"regexp"
"testing"
"time"
"github.com/bluenviron/mediamtx/internal/conf"
"github.com/stretchr/testify/require"
)
func ptrOf[T any](v T) *T {
p := new(T)
*p = v
return p
}
func TestFindAllPathsWithSegments(t *testing.T) {
dir, err := os.MkdirTemp("", "mediamtx-recordstore")
require.NoError(t, err)
defer os.RemoveAll(dir)
err = os.Mkdir(filepath.Join(dir, "path1"), 0o755)
require.NoError(t, err)
err = os.Mkdir(filepath.Join(dir, "path2"), 0o755)
require.NoError(t, err)
err = os.WriteFile(filepath.Join(dir, "path1", "2015-05-19_22-15-25-000427.mp4"), []byte{1}, 0o644)
require.NoError(t, err)
err = os.WriteFile(filepath.Join(dir, "path2", "2015-07-19_22-15-25-000427.mp4"), []byte{1}, 0o644)
require.NoError(t, err)
paths := FindAllPathsWithSegments(map[string]*conf.Path{
"~^.*$": {
Name: "~^.*$",
Regexp: regexp.MustCompile("^.*$"),
RecordPath: filepath.Join(dir, "%path/%Y-%m-%d_%H-%M-%S-%f"),
RecordFormat: conf.RecordFormatFMP4,
},
"path2": {
Name: "path2",
RecordPath: filepath.Join(dir, "%path/%Y-%m-%d_%H-%M-%S-%f"),
RecordFormat: conf.RecordFormatFMP4,
},
})
require.Equal(t, []string{"path1", "path2"}, paths)
}
func TestFindAllPathsWithSegmentsInvalidPath(t *testing.T) {
dir, err := os.MkdirTemp("", "mediamtx-recordstore")
require.NoError(t, err)
defer os.RemoveAll(dir)
err = os.WriteFile(filepath.Join(dir, "_2015-05-19_22-15-25-000427.mp4"), []byte{1}, 0o644)
require.NoError(t, err)
paths := FindAllPathsWithSegments(map[string]*conf.Path{
"~^.*$": {
Name: "~^.*$",
Regexp: regexp.MustCompile("^.*$"),
RecordPath: filepath.Join(dir, "%path_%Y-%m-%d_%H-%M-%S-%f"),
RecordFormat: conf.RecordFormatFMP4,
},
})
require.Equal(t, []string{}, paths)
}
func TestFindSegments(t *testing.T) {
for _, ca := range []string{
"no filtering",
"filtering",
"start before first",
} {
t.Run(ca, func(t *testing.T) {
dir, err := os.MkdirTemp("", "mediamtx-recordstore")
require.NoError(t, err)
defer os.RemoveAll(dir)
err = os.Mkdir(filepath.Join(dir, "path1"), 0o755)
require.NoError(t, err)
err = os.Mkdir(filepath.Join(dir, "path2"), 0o755)
require.NoError(t, err)
err = os.WriteFile(filepath.Join(dir, "path1", "2015-05-19_22-15-25-000427.mp4"), []byte{1}, 0o644)
require.NoError(t, err)
err = os.WriteFile(filepath.Join(dir, "path1", "2016-05-19_22-15-25-000427.mp4"), []byte{1}, 0o644)
require.NoError(t, err)
var start *time.Time
var end *time.Time
switch ca {
case "no filtering":
case "filtering":
start = ptrOf(time.Date(2015, 5, 19, 22, 18, 25, 427000, time.Local))
end = ptrOf(start.Add(60 * time.Minute))
case "start before first":
start = ptrOf(time.Date(2014, 5, 19, 22, 18, 25, 427000, time.Local))
}
segments, err := FindSegments(
&conf.Path{
Name: "~^.*$",
Regexp: regexp.MustCompile("^.*$"),
RecordPath: filepath.Join(dir, "%path/%Y-%m-%d_%H-%M-%S-%f"),
RecordFormat: conf.RecordFormatFMP4,
},
"path1",
start,
end,
)
require.NoError(t, err)
switch ca {
case "no filtering", "start before first":
require.Equal(t, []*Segment{
{
Fpath: filepath.Join(dir, "path1", "2015-05-19_22-15-25-000427.mp4"),
Start: time.Date(2015, 5, 19, 22, 15, 25, 427000, time.Local),
},
{
Fpath: filepath.Join(dir, "path1", "2016-05-19_22-15-25-000427.mp4"),
Start: time.Date(2016, 5, 19, 22, 15, 25, 427000, time.Local),
},
}, segments)
case "filtering":
require.Equal(t, []*Segment{
{
Fpath: filepath.Join(dir, "path1", "2015-05-19_22-15-25-000427.mp4"),
Start: time.Date(2015, 5, 19, 22, 15, 25, 427000, time.Local),
},
}, segments)
}
})
}
}
================================================
FILE: internal/restrictnetwork/restrict_network.go
================================================
// Package restrictnetwork contains Restrict().
package restrictnetwork
import (
"net"
)
// Restrict prevents listening on IPv6 when address is 0.0.0.0.
func Restrict(network string, address string) (string, string) {
host, _, err := net.SplitHostPort(address)
if err == nil {
if host == "0.0.0.0" {
return network + "4", address
}
}
return network, address
}
================================================
FILE: internal/rlimit/rlimit_unix.go
================================================
//go:build !windows
// Package rlimit contains a function to raise rlimit.
package rlimit
import (
"syscall"
)
// Raise raises the number of file descriptors that can be opened.
func Raise() error {
var rlim syscall.Rlimit
err := syscall.Getrlimit(syscall.RLIMIT_NOFILE, &rlim)
if err != nil {
return err
}
rlim.Cur = 999999
err = syscall.Setrlimit(syscall.RLIMIT_NOFILE, &rlim)
if err != nil {
return err
}
err = syscall.Getrlimit(syscall.RLIMIT_NOFILE, &rlim)
if err != nil {
return err
}
return nil
}
================================================
FILE: internal/rlimit/rlimit_win.go
================================================
//go:build windows
package rlimit
func Raise() error {
return nil
}
================================================
FILE: internal/servers/hls/hlsjsdownloader/HASH
================================================
5cd2be2a4f7106b7c82a12bc15af6117f5230af92a44f26f88a0a32b04e57a81
================================================
FILE: internal/servers/hls/hlsjsdownloader/VERSION
================================================
v1.6.15
================================================
FILE: internal/servers/hls/hlsjsdownloader/main.go
================================================
// Package main contains an utility to download hls.js
package main
import (
"archive/zip"
"bytes"
"crypto/sha256"
"encoding/hex"
"fmt"
"io"
"io/fs"
"log"
"net/http"
"os"
"strings"
)
func do() error {
buf, err := os.ReadFile("./hlsjsdownloader/VERSION")
if err != nil {
return err
}
version := strings.TrimSpace(string(buf))
log.Printf("downloading hls.js %s...", version)
res, err := http.Get("https://github.com/video-dev/hls.js/releases/download/" + version + "/release.zip")
if err != nil {
return err
}
defer res.Body.Close()
if res.StatusCode != http.StatusOK {
return fmt.Errorf("bad status code: %v", res.StatusCode)
}
zipBuf, err := io.ReadAll(res.Body)
if err != nil {
return err
}
buf, err = os.ReadFile("./hlsjsdownloader/HASH")
if err != nil {
return err
}
str := strings.TrimSpace(string(buf))
hash, err := hex.DecodeString(str)
if err != nil {
return err
}
if sum := sha256.Sum256(zipBuf); !bytes.Equal(sum[:], hash) {
return fmt.Errorf("hash mismatch")
}
z, err := zip.NewReader(bytes.NewReader(zipBuf), int64(len(zipBuf)))
if err != nil {
return err
}
hls, err := fs.ReadFile(z, "dist/hls.min.js")
if err != nil {
return err
}
if err = os.WriteFile("hls.min.js", hls, 0o644); err != nil {
return err
}
log.Println("ok")
return nil
}
func main() {
err := do()
if err != nil {
log.Printf("ERR: %v", err)
os.Exit(1)
}
}
================================================
FILE: internal/servers/hls/http_server.go
================================================
package hls
import (
_ "embed"
"errors"
"net"
"net/http"
gopath "path"
"strings"
"time"
"github.com/gin-gonic/gin"
"github.com/bluenviron/mediamtx/internal/auth"
"github.com/bluenviron/mediamtx/internal/conf"
"github.com/bluenviron/mediamtx/internal/defs"
"github.com/bluenviron/mediamtx/internal/logger"
"github.com/bluenviron/mediamtx/internal/protocols/httpp"
)
//go:generate go run ./hlsjsdownloader
//go:embed index.html
var hlsIndex []byte
//go:embed hls.min.js
var hlsMinJS []byte
func mergePathAndQuery(path string, rawQuery string) string {
res := path
if rawQuery != "" {
res += "?" + rawQuery
}
return res
}
type httpServer struct {
address string
dumpPackets bool
encryption bool
serverKey string
serverCert string
allowOrigins []string
trustedProxies conf.IPNetworks
readTimeout conf.Duration
writeTimeout conf.Duration
pathManager serverPathManager
parent *Server
inner *httpp.Server
}
func (s *httpServer) initialize() error {
router := gin.New()
router.SetTrustedProxies(s.trustedProxies.ToTrustedProxies()) //nolint:errcheck
router.Use(s.middlewarePreflightRequests)
router.Use(s.onRequest)
s.inner = &httpp.Server{
Address: s.address,
AllowOrigins: s.allowOrigins,
DumpPackets: s.dumpPackets,
DumpPacketsPrefix: "hls_server_conn",
ReadTimeout: time.Duration(s.readTimeout),
WriteTimeout: time.Duration(s.writeTimeout),
Encryption: s.encryption,
ServerCert: s.serverCert,
ServerKey: s.serverKey,
Handler: router,
Parent: s,
}
err := s.inner.Initialize()
if err != nil {
return err
}
return nil
}
// Log implements logger.Writer.
func (s *httpServer) Log(level logger.Level, format string, args ...any) {
s.parent.Log(level, format, args...)
}
func (s *httpServer) close() {
s.inner.Close()
}
func (s *httpServer) middlewarePreflightRequests(ctx *gin.Context) {
if ctx.Request.Method == http.MethodOptions &&
ctx.Request.Header.Get("Access-Control-Request-Method") != "" {
ctx.Header("Access-Control-Allow-Methods", "OPTIONS, GET")
ctx.Header("Access-Control-Allow-Headers", "Authorization, Range")
ctx.AbortWithStatus(http.StatusNoContent)
return
}
}
func (s *httpServer) onRequest(ctx *gin.Context) {
if ctx.Request.Method != http.MethodGet {
return
}
// remove leading prefix
pa := ctx.Request.URL.Path[1:]
var dir string
var fname string
switch {
case strings.HasSuffix(pa, "/hls.min.js"):
ctx.Header("Cache-Control", "max-age=3600")
ctx.Header("Content-Type", "application/javascript")
ctx.Writer.WriteHeader(http.StatusOK)
ctx.Writer.Write(hlsMinJS)
return
case pa == "", pa == "favicon.ico", strings.HasSuffix(pa, "/hls.min.js.map"):
return
case strings.HasSuffix(pa, ".m3u8") ||
strings.HasSuffix(pa, ".ts") ||
strings.HasSuffix(pa, ".mp4") ||
strings.HasSuffix(pa, ".mp"):
dir, fname = gopath.Dir(pa), gopath.Base(pa)
if strings.HasSuffix(fname, ".mp") {
fname += "4"
}
default:
dir, fname = pa, ""
if !strings.HasSuffix(dir, "/") {
ctx.Header("Location", mergePathAndQuery(ctx.Request.URL.Path+"/", ctx.Request.URL.RawQuery))
ctx.Writer.WriteHeader(http.StatusMovedPermanently)
return
}
}
dir = strings.TrimSuffix(dir, "/")
if dir == "" {
return
}
res, err := s.pathManager.FindPathConf(defs.PathFindPathConfReq{
AccessRequest: defs.PathAccessRequest{
Name: dir,
Query: ctx.Request.URL.RawQuery,
Publish: false,
Proto: auth.ProtocolHLS,
Credentials: httpp.Credentials(ctx.Request),
IP: net.ParseIP(ctx.ClientIP()),
},
})
if err != nil {
var terr *auth.Error
if errors.As(err, &terr) {
if terr.AskCredentials {
ctx.Header("WWW-Authenticate", `Basic realm="mediamtx"`)
ctx.AbortWithStatusJSON(http.StatusUnauthorized, &defs.APIError{
Status: defs.APIErrorStatusError,
Error: "authentication error",
})
return
}
s.Log(logger.Info, "connection %v failed to authenticate: %v", httpp.RemoteAddr(ctx), terr.Wrapped)
// wait some seconds to delay brute force attacks
<-time.After(auth.PauseAfterError)
ctx.AbortWithStatusJSON(http.StatusUnauthorized, &defs.APIError{
Status: defs.APIErrorStatusError,
Error: "authentication error",
})
return
}
ctx.Writer.WriteHeader(http.StatusNotFound)
return
}
switch fname {
case "":
ctx.Header("Cache-Control", "max-age=3600")
ctx.Header("Content-Type", "text/html")
ctx.Writer.WriteHeader(http.StatusOK)
ctx.Writer.Write(hlsIndex)
default:
var mux *muxer
mux, err = s.parent.getMuxer(serverGetMuxerReq{
path: dir,
remoteAddr: httpp.RemoteAddr(ctx),
query: ctx.Request.URL.RawQuery,
sourceOnDemand: res.Conf.SourceOnDemand,
})
if err != nil {
ctx.Writer.WriteHeader(http.StatusNotFound)
return
}
ctx.Request.URL.Path = fname
mux.handleRequest(ctx)
}
}
================================================
FILE: internal/servers/hls/index.html
================================================
================================================
FILE: internal/servers/hls/muxer.go
================================================
package hls
import (
"context"
"errors"
"fmt"
"net/http"
"sync"
"sync/atomic"
"time"
"github.com/bluenviron/mediamtx/internal/conf"
"github.com/bluenviron/mediamtx/internal/defs"
"github.com/bluenviron/mediamtx/internal/logger"
"github.com/bluenviron/mediamtx/internal/protocols/hls"
"github.com/bluenviron/mediamtx/internal/stream"
"github.com/gin-gonic/gin"
)
const (
closeCheckPeriod = 1 * time.Second
recreatePause = 10 * time.Second
)
func ptrOf[T any](v T) *T {
p := new(T)
*p = v
return p
}
func emptyTimer() *time.Timer {
t := time.NewTimer(0)
<-t.C
return t
}
type responseWriterWithCounter struct {
http.ResponseWriter
bytesSent *uint64
}
func (w *responseWriterWithCounter) Write(p []byte) (int, error) {
n, err := w.ResponseWriter.Write(p)
atomic.AddUint64(w.bytesSent, uint64(n))
return n, err
}
type muxerGetInstanceRes struct {
instance *muxerInstance
cumulatedOutboundFramesDiscarded uint64
}
type muxerGetInstanceReq struct {
res chan muxerGetInstanceRes
}
type muxer struct {
parentCtx context.Context
remoteAddr string
variant conf.HLSVariant
segmentCount int
segmentDuration conf.Duration
partDuration conf.Duration
segmentMaxSize conf.StringSize
directory string
closeAfter conf.Duration
wg *sync.WaitGroup
pathName string
pathManager serverPathManager
parent *Server
query string
ctx context.Context
ctxCancel func()
created time.Time
path defs.Path
lastRequestTime *int64
bytesSent *uint64
// in
chGetInstance chan muxerGetInstanceReq
}
func (m *muxer) initialize() {
ctx, ctxCancel := context.WithCancel(m.parentCtx)
m.ctx = ctx
m.ctxCancel = ctxCancel
m.created = time.Now()
m.lastRequestTime = ptrOf(time.Now().UnixNano())
m.bytesSent = new(uint64)
m.chGetInstance = make(chan muxerGetInstanceReq)
m.Log(logger.Info, "created %s", func() string {
if m.remoteAddr == "" {
return "automatically"
}
return "(requested by " + m.remoteAddr + ")"
}())
m.wg.Add(1)
go m.run()
}
func (m *muxer) Close() {
m.ctxCancel()
}
// Log implements logger.Writer.
func (m *muxer) Log(level logger.Level, format string, args ...any) {
m.parent.Log(level, "[muxer %s] "+format, append([]any{m.pathName}, args...)...)
}
// PathName returns the path name.
func (m *muxer) PathName() string {
return m.pathName
}
func (m *muxer) run() {
defer m.wg.Done()
err := m.runInner()
m.ctxCancel()
m.parent.closeMuxer(m)
m.Log(logger.Info, "destroyed: %v", err)
}
func (m *muxer) runInner() error {
res, err := m.pathManager.AddReader(defs.PathAddReaderReq{
Author: m,
AccessRequest: defs.PathAccessRequest{
Name: m.pathName,
Query: m.query,
SkipAuth: true,
},
})
if err != nil {
return err
}
m.path = res.Path
defer m.path.RemoveReader(defs.PathRemoveReaderReq{Author: m})
mi, err := m.createInstance(res.Stream)
if err != nil {
if m.remoteAddr != "" || errors.Is(err, hls.ErrNoSupportedCodecs) {
return err
}
m.Log(logger.Error, err.Error())
mi = nil
}
defer func() {
if mi != nil {
mi.close()
}
}()
var instanceError chan error
var recreateTimer *time.Timer
if mi != nil {
instanceError = mi.errorChan()
recreateTimer = emptyTimer()
} else {
instanceError = make(chan error)
recreateTimer = time.NewTimer(recreatePause)
}
var activityCheckTimer *time.Timer
if m.remoteAddr != "" {
activityCheckTimer = time.NewTimer(closeCheckPeriod)
} else {
activityCheckTimer = emptyTimer()
}
cumulatedOutboundFramesDiscarded := uint64(0)
for {
select {
case req := <-m.chGetInstance:
req.res <- muxerGetInstanceRes{
instance: mi,
cumulatedOutboundFramesDiscarded: cumulatedOutboundFramesDiscarded,
}
case err = <-instanceError:
if m.remoteAddr != "" {
return err
}
m.Log(logger.Error, err.Error())
mi.close()
cumulatedOutboundFramesDiscarded += mi.reader.OutboundFramesDiscarded()
mi = nil
instanceError = make(chan error)
recreateTimer = time.NewTimer(recreatePause)
case <-recreateTimer.C:
mi, err = m.createInstance(res.Stream)
if err != nil {
m.Log(logger.Error, err.Error())
mi = nil
recreateTimer = time.NewTimer(recreatePause)
} else {
instanceError = mi.errorChan()
}
case <-activityCheckTimer.C:
t := time.Unix(0, atomic.LoadInt64(m.lastRequestTime))
if time.Since(t) >= time.Duration(m.closeAfter) {
return fmt.Errorf("not used anymore")
}
activityCheckTimer = time.NewTimer(closeCheckPeriod)
case <-m.ctx.Done():
return errors.New("terminated")
}
}
}
func (m *muxer) createInstance(strm *stream.Stream) (*muxerInstance, error) {
mi := &muxerInstance{
variant: m.variant,
segmentCount: m.segmentCount,
segmentDuration: m.segmentDuration,
partDuration: m.partDuration,
segmentMaxSize: m.segmentMaxSize,
directory: m.directory,
pathName: m.pathName,
stream: strm,
parent: m,
}
err := mi.initialize()
return mi, err
}
func (m *muxer) getInstance() muxerGetInstanceRes {
req := muxerGetInstanceReq{res: make(chan muxerGetInstanceRes)}
select {
case m.chGetInstance <- req:
return <-req.res
case <-m.ctx.Done():
return muxerGetInstanceRes{}
}
}
// APIReaderDescribe implements reader.
func (m *muxer) APIReaderDescribe() *defs.APIPathReader {
return &defs.APIPathReader{
Type: defs.APIPathReaderTypeHLSMuxer,
ID: "",
}
}
func (m *muxer) handleRequest(ctx *gin.Context) {
atomic.StoreInt64(m.lastRequestTime, time.Now().UnixNano())
res := m.getInstance()
if res.instance == nil {
ctx.Writer.WriteHeader(http.StatusNotFound)
return
}
w := &responseWriterWithCounter{
ResponseWriter: ctx.Writer,
bytesSent: m.bytesSent,
}
res.instance.handleRequest(w, ctx.Request)
}
func (m *muxer) apiItem() *defs.APIHLSMuxer {
res := m.getInstance()
outboundFramesDiscarded := res.cumulatedOutboundFramesDiscarded
if res.instance != nil {
outboundFramesDiscarded += res.instance.reader.OutboundFramesDiscarded()
}
return &defs.APIHLSMuxer{
Path: m.pathName,
Created: m.created,
LastRequest: time.Unix(0, atomic.LoadInt64(m.lastRequestTime)),
OutboundBytes: atomic.LoadUint64(m.bytesSent),
OutboundFramesDiscarded: outboundFramesDiscarded,
BytesSent: atomic.LoadUint64(m.bytesSent),
}
}
================================================
FILE: internal/servers/hls/muxer_instance.go
================================================
package hls
import (
"net/http"
"os"
"path/filepath"
"time"
"github.com/bluenviron/gohlslib/v2"
"github.com/bluenviron/mediamtx/internal/conf"
"github.com/bluenviron/mediamtx/internal/defs"
"github.com/bluenviron/mediamtx/internal/logger"
"github.com/bluenviron/mediamtx/internal/protocols/hls"
"github.com/bluenviron/mediamtx/internal/stream"
)
type muxerInstance struct {
variant conf.HLSVariant
segmentCount int
segmentDuration conf.Duration
partDuration conf.Duration
segmentMaxSize conf.StringSize
directory string
pathName string
stream *stream.Stream
parent logger.Writer
hmuxer *gohlslib.Muxer
reader *stream.Reader
}
func (mi *muxerInstance) initialize() error {
var muxerDirectory string
if mi.directory != "" {
muxerDirectory = filepath.Join(mi.directory, mi.pathName)
os.MkdirAll(muxerDirectory, 0o755)
}
mi.hmuxer = &gohlslib.Muxer{
Variant: gohlslib.MuxerVariant(mi.variant),
SegmentCount: mi.segmentCount,
SegmentMinDuration: time.Duration(mi.segmentDuration),
PartMinDuration: time.Duration(mi.partDuration),
SegmentMaxSize: uint64(mi.segmentMaxSize),
Directory: muxerDirectory,
OnEncodeError: func(err error) {
mi.Log(logger.Warn, err.Error())
},
}
mi.reader = &stream.Reader{
SkipBytesSent: true,
Parent: mi,
}
err := hls.FromStream(mi.stream.Desc, mi.reader, mi.hmuxer)
if err != nil {
return err
}
err = mi.hmuxer.Start()
if err != nil {
return err
}
mi.Log(logger.Info, "is converting into HLS, %s",
defs.FormatsInfo(mi.reader.Formats()))
mi.stream.AddReader(mi.reader)
return nil
}
// Log implements logger.Writer.
func (mi *muxerInstance) Log(level logger.Level, format string, args ...any) {
mi.parent.Log(level, format, args...)
}
func (mi *muxerInstance) close() {
mi.stream.RemoveReader(mi.reader)
mi.hmuxer.Close()
if mi.hmuxer.Directory != "" {
os.Remove(mi.hmuxer.Directory)
}
}
func (mi *muxerInstance) errorChan() chan error {
return mi.reader.Error()
}
func (mi *muxerInstance) handleRequest(w http.ResponseWriter, r *http.Request) {
mi.hmuxer.Handle(w, r)
}
================================================
FILE: internal/servers/hls/server.go
================================================
// Package hls contains a HLS server.
package hls
import (
"context"
"errors"
"fmt"
"reflect"
"sort"
"sync"
"github.com/bluenviron/mediamtx/internal/conf"
"github.com/bluenviron/mediamtx/internal/defs"
"github.com/bluenviron/mediamtx/internal/logger"
)
// ErrMuxerNotFound is returned when a muxer is not found.
var ErrMuxerNotFound = errors.New("muxer not found")
func interfaceIsEmpty(i any) bool {
return reflect.ValueOf(i).Kind() != reflect.Pointer || reflect.ValueOf(i).IsNil()
}
type serverGetMuxerRes struct {
muxer *muxer
err error
}
type serverGetMuxerReq struct {
path string
remoteAddr string
query string
sourceOnDemand bool
res chan serverGetMuxerRes
}
type serverAPIMuxersListRes struct {
data *defs.APIHLSMuxerList
err error
}
type serverAPIMuxersListReq struct {
res chan serverAPIMuxersListRes
}
type serverAPIMuxersGetRes struct {
data *defs.APIHLSMuxer
err error
}
type serverAPIMuxersGetReq struct {
name string
res chan serverAPIMuxersGetRes
}
type serverMetrics interface {
SetHLSServer(defs.APIHLSServer)
}
type serverPathManager interface {
SetHLSServer(*Server) []defs.Path
FindPathConf(req defs.PathFindPathConfReq) (*defs.PathFindPathConfRes, error)
AddReader(req defs.PathAddReaderReq) (*defs.PathAddReaderRes, error)
}
type serverParent interface {
logger.Writer
}
// Server is a HLS server.
type Server struct {
Address string
DumpPackets bool
Encryption bool
ServerKey string
ServerCert string
AllowOrigins []string
TrustedProxies conf.IPNetworks
AlwaysRemux bool
Variant conf.HLSVariant
SegmentCount int
SegmentDuration conf.Duration
PartDuration conf.Duration
SegmentMaxSize conf.StringSize
Directory string
ReadTimeout conf.Duration
WriteTimeout conf.Duration
MuxerCloseAfter conf.Duration
Metrics serverMetrics
PathManager serverPathManager
Parent serverParent
ctx context.Context
ctxCancel func()
wg sync.WaitGroup
httpServer *httpServer
muxers map[string]*muxer
// in
chPathReady chan defs.Path
chPathNotReady chan defs.Path
chGetMuxer chan serverGetMuxerReq
chCloseMuxer chan *muxer
chAPIMuxerList chan serverAPIMuxersListReq
chAPIMuxerGet chan serverAPIMuxersGetReq
}
// Initialize initializes the server.
func (s *Server) Initialize() error {
ctx, ctxCancel := context.WithCancel(context.Background())
s.ctx = ctx
s.ctxCancel = ctxCancel
s.muxers = make(map[string]*muxer)
s.chPathReady = make(chan defs.Path)
s.chPathNotReady = make(chan defs.Path)
s.chGetMuxer = make(chan serverGetMuxerReq)
s.chCloseMuxer = make(chan *muxer)
s.chAPIMuxerList = make(chan serverAPIMuxersListReq)
s.chAPIMuxerGet = make(chan serverAPIMuxersGetReq)
s.httpServer = &httpServer{
address: s.Address,
dumpPackets: s.DumpPackets,
encryption: s.Encryption,
serverKey: s.ServerKey,
serverCert: s.ServerCert,
allowOrigins: s.AllowOrigins,
trustedProxies: s.TrustedProxies,
readTimeout: s.ReadTimeout,
writeTimeout: s.WriteTimeout,
pathManager: s.PathManager,
parent: s,
}
err := s.httpServer.initialize()
if err != nil {
ctxCancel()
return err
}
s.Log(logger.Info, "listener opened on "+s.Address)
s.wg.Add(1)
go s.run()
if !interfaceIsEmpty(s.Metrics) {
s.Metrics.SetHLSServer(s)
}
return nil
}
// Log implements logger.Writer.
func (s *Server) Log(level logger.Level, format string, args ...any) {
s.Parent.Log(level, "[HLS] "+format, args...)
}
// Close closes the server.
func (s *Server) Close() {
s.Log(logger.Info, "listener is closing")
if !interfaceIsEmpty(s.Metrics) {
s.Metrics.SetHLSServer(nil)
}
s.ctxCancel()
s.wg.Wait()
}
func (s *Server) run() {
defer s.wg.Done()
readyPaths := s.PathManager.SetHLSServer(s)
defer s.PathManager.SetHLSServer(nil)
if s.AlwaysRemux {
for _, pa := range readyPaths {
if !pa.SafeConf().SourceOnDemand {
if _, ok := s.muxers[pa.Name()]; !ok {
s.createMuxer(pa.Name(), "", "")
}
}
}
}
outer:
for {
select {
case pa := <-s.chPathReady:
if s.AlwaysRemux && !pa.SafeConf().SourceOnDemand {
if _, ok := s.muxers[pa.Name()]; !ok {
s.createMuxer(pa.Name(), "", "")
}
}
case pa := <-s.chPathNotReady:
c, ok := s.muxers[pa.Name()]
if ok && c.remoteAddr == "" { // created with "always remux"
c.Close()
delete(s.muxers, pa.Name())
}
case req := <-s.chGetMuxer:
mux, ok := s.muxers[req.path]
switch {
case ok:
req.res <- serverGetMuxerRes{muxer: mux}
case s.AlwaysRemux && !req.sourceOnDemand:
req.res <- serverGetMuxerRes{err: fmt.Errorf("muxer is waiting to be created")}
default:
req.res <- serverGetMuxerRes{muxer: s.createMuxer(req.path, req.remoteAddr, req.query)}
}
case c := <-s.chCloseMuxer:
if c2, ok := s.muxers[c.PathName()]; ok && c2 == c {
delete(s.muxers, c.PathName())
}
case req := <-s.chAPIMuxerList:
data := &defs.APIHLSMuxerList{
Items: []defs.APIHLSMuxer{},
}
for _, muxer := range s.muxers {
data.Items = append(data.Items, *muxer.apiItem())
}
sort.Slice(data.Items, func(i, j int) bool {
return data.Items[i].Created.Before(data.Items[j].Created)
})
req.res <- serverAPIMuxersListRes{
data: data,
}
case req := <-s.chAPIMuxerGet:
muxer, ok := s.muxers[req.name]
if !ok {
req.res <- serverAPIMuxersGetRes{err: ErrMuxerNotFound}
continue
}
req.res <- serverAPIMuxersGetRes{data: muxer.apiItem()}
case <-s.ctx.Done():
break outer
}
}
s.ctxCancel()
s.httpServer.close()
}
func (s *Server) createMuxer(pathName string, remoteAddr string, query string) *muxer {
r := &muxer{
parentCtx: s.ctx,
remoteAddr: remoteAddr,
variant: s.Variant,
segmentCount: s.SegmentCount,
segmentDuration: s.SegmentDuration,
partDuration: s.PartDuration,
segmentMaxSize: s.SegmentMaxSize,
directory: s.Directory,
wg: &s.wg,
pathName: pathName,
pathManager: s.PathManager,
parent: s,
query: query,
closeAfter: s.MuxerCloseAfter,
}
r.initialize()
s.muxers[pathName] = r
return r
}
// closeMuxer is called by muxer.
func (s *Server) closeMuxer(c *muxer) {
select {
case s.chCloseMuxer <- c:
case <-s.ctx.Done():
}
}
func (s *Server) getMuxer(req serverGetMuxerReq) (*muxer, error) {
req.res = make(chan serverGetMuxerRes)
select {
case s.chGetMuxer <- req:
res := <-req.res
return res.muxer, res.err
case <-s.ctx.Done():
return nil, fmt.Errorf("terminated")
}
}
// PathReady is called by pathManager.
func (s *Server) PathReady(pa defs.Path) {
select {
case s.chPathReady <- pa:
case <-s.ctx.Done():
}
}
// PathNotReady is called by pathManager.
func (s *Server) PathNotReady(pa defs.Path) {
select {
case s.chPathNotReady <- pa:
case <-s.ctx.Done():
}
}
// APIMuxersList is called by api.
func (s *Server) APIMuxersList() (*defs.APIHLSMuxerList, error) {
req := serverAPIMuxersListReq{
res: make(chan serverAPIMuxersListRes),
}
select {
case s.chAPIMuxerList <- req:
res := <-req.res
return res.data, res.err
case <-s.ctx.Done():
return nil, fmt.Errorf("terminated")
}
}
// APIMuxersGet is called by api.
func (s *Server) APIMuxersGet(name string) (*defs.APIHLSMuxer, error) {
req := serverAPIMuxersGetReq{
name: name,
res: make(chan serverAPIMuxersGetRes),
}
select {
case s.chAPIMuxerGet <- req:
res := <-req.res
return res.data, res.err
case <-s.ctx.Done():
return nil, fmt.Errorf("terminated")
}
}
================================================
FILE: internal/servers/hls/server_test.go
================================================
package hls
import (
"fmt"
"io"
"net/http"
"os"
"path/filepath"
"testing"
"time"
"github.com/bluenviron/gohlslib/v2"
"github.com/bluenviron/gohlslib/v2/pkg/codecs"
"github.com/bluenviron/gortsplib/v5/pkg/description"
"github.com/bluenviron/mediacommon/v2/pkg/codecs/mpeg4audio"
"github.com/bluenviron/mediamtx/internal/auth"
"github.com/bluenviron/mediamtx/internal/conf"
"github.com/bluenviron/mediamtx/internal/defs"
"github.com/bluenviron/mediamtx/internal/externalcmd"
"github.com/bluenviron/mediamtx/internal/logger"
"github.com/bluenviron/mediamtx/internal/stream"
"github.com/bluenviron/mediamtx/internal/test"
"github.com/bluenviron/mediamtx/internal/unit"
"github.com/stretchr/testify/require"
)
type dummyPathManager struct {
setHLSServerImpl func() []defs.Path
findPathConfImpl func(req defs.PathFindPathConfReq) (*defs.PathFindPathConfRes, error)
addReaderImpl func(req defs.PathAddReaderReq) (*defs.PathAddReaderRes, error)
}
func (pm *dummyPathManager) SetHLSServer(*Server) []defs.Path {
if pm.setHLSServerImpl != nil {
return pm.setHLSServerImpl()
}
return nil
}
func (pm *dummyPathManager) FindPathConf(req defs.PathFindPathConfReq) (*defs.PathFindPathConfRes, error) {
return pm.findPathConfImpl(req)
}
func (pm *dummyPathManager) AddReader(req defs.PathAddReaderReq) (*defs.PathAddReaderRes, error) {
return pm.addReaderImpl(req)
}
type dummyPath struct{}
func (pa *dummyPath) Name() string {
return "teststream"
}
func (pa *dummyPath) SafeConf() *conf.Path {
return &conf.Path{}
}
func (pa *dummyPath) ExternalCmdEnv() externalcmd.Environment {
return nil
}
func (pa *dummyPath) RemovePublisher(_ defs.PathRemovePublisherReq) {
}
func (pa *dummyPath) RemoveReader(_ defs.PathRemoveReaderReq) {
}
func TestServerPreflightRequest(t *testing.T) {
s := &Server{
Address: "127.0.0.1:8888",
AllowOrigins: []string{"*"},
ReadTimeout: conf.Duration(10 * time.Second),
WriteTimeout: conf.Duration(10 * time.Second),
PathManager: &dummyPathManager{},
Parent: test.NilLogger,
}
err := s.Initialize()
require.NoError(t, err)
defer s.Close()
tr := &http.Transport{}
defer tr.CloseIdleConnections()
hc := &http.Client{Transport: tr}
req, err := http.NewRequest(http.MethodOptions, "http://localhost:8888", nil)
require.NoError(t, err)
req.Header.Add("Access-Control-Request-Method", "GET")
res, err := hc.Do(req)
require.NoError(t, err)
defer res.Body.Close()
require.Equal(t, http.StatusNoContent, res.StatusCode)
byts, err := io.ReadAll(res.Body)
require.NoError(t, err)
require.Equal(t, "*", res.Header.Get("Access-Control-Allow-Origin"))
require.Equal(t, "true", res.Header.Get("Access-Control-Allow-Credentials"))
require.Equal(t, "OPTIONS, GET", res.Header.Get("Access-Control-Allow-Methods"))
require.Equal(t, "Authorization, Range", res.Header.Get("Access-Control-Allow-Headers"))
require.Equal(t, byts, []byte{})
}
func TestServerNotFound(t *testing.T) {
for _, ca := range []string{
"always remux off",
"always remux on",
} {
t.Run(ca, func(t *testing.T) {
pm := &dummyPathManager{
findPathConfImpl: func(req defs.PathFindPathConfReq) (*defs.PathFindPathConfRes, error) {
require.Equal(t, "nonexisting", req.AccessRequest.Name)
return &defs.PathFindPathConfRes{Conf: &conf.Path{}, User: req.AccessRequest.Credentials.User}, nil
},
addReaderImpl: func(req defs.PathAddReaderReq) (*defs.PathAddReaderRes, error) {
require.Equal(t, "nonexisting", req.AccessRequest.Name)
return nil, fmt.Errorf("not found")
},
}
s := &Server{
Address: "127.0.0.1:8888",
Encryption: false,
ServerKey: "",
ServerCert: "",
AlwaysRemux: ca == "always remux on",
Variant: conf.HLSVariant(gohlslib.MuxerVariantMPEGTS),
SegmentCount: 7,
SegmentDuration: conf.Duration(1 * time.Second),
PartDuration: conf.Duration(200 * time.Millisecond),
SegmentMaxSize: 50 * 1024 * 1024,
TrustedProxies: conf.IPNetworks{},
Directory: "",
ReadTimeout: conf.Duration(10 * time.Second),
WriteTimeout: conf.Duration(10 * time.Second),
PathManager: pm,
Parent: test.NilLogger,
}
err := s.Initialize()
require.NoError(t, err)
defer s.Close()
tr := &http.Transport{}
defer tr.CloseIdleConnections()
hc := &http.Client{Transport: tr}
func() {
var req *http.Request
req, err = http.NewRequest(http.MethodGet, "http://myuser:mypass@127.0.0.1:8888/nonexisting/", nil)
require.NoError(t, err)
var res *http.Response
res, err = hc.Do(req)
require.NoError(t, err)
defer res.Body.Close()
require.Equal(t, http.StatusOK, res.StatusCode)
}()
func() {
var req *http.Request
req, err = http.NewRequest(http.MethodGet, "http://myuser:mypass@127.0.0.1:8888/nonexisting/index.m3u8", nil)
require.NoError(t, err)
var res *http.Response
res, err = hc.Do(req)
require.NoError(t, err)
defer res.Body.Close()
require.Equal(t, http.StatusNotFound, res.StatusCode)
}()
})
}
}
func TestServerRead(t *testing.T) {
for _, ca := range []string{
"always remux off",
"always remux on",
} {
t.Run(ca, func(t *testing.T) {
desc := &description.Session{Medias: []*description.Media{
test.MediaH264,
test.MediaMPEG4Audio,
}}
strm := &stream.Stream{
Desc: desc,
WriteQueueSize: 512,
RTPMaxPayloadSize: 1450,
ReplaceNTP: false,
Parent: test.NilLogger,
}
err := strm.Initialize()
require.NoError(t, err)
subStream := &stream.SubStream{
Stream: strm,
UseRTPPackets: false,
}
err = subStream.Initialize()
require.NoError(t, err)
pm := &dummyPathManager{
findPathConfImpl: func(req defs.PathFindPathConfReq) (*defs.PathFindPathConfRes, error) {
require.Equal(t, "teststream", req.AccessRequest.Name)
require.Equal(t, "param=value", req.AccessRequest.Query)
require.Equal(t, "myuser", req.AccessRequest.Credentials.User)
require.Equal(t, "mypass", req.AccessRequest.Credentials.Pass)
return &defs.PathFindPathConfRes{Conf: &conf.Path{}, User: req.AccessRequest.Credentials.User}, nil
},
addReaderImpl: func(req defs.PathAddReaderReq) (*defs.PathAddReaderRes, error) {
require.Equal(t, "teststream", req.AccessRequest.Name)
if ca == "always remux off" {
require.Equal(t, "param=value", req.AccessRequest.Query)
} else {
require.Equal(t, "", req.AccessRequest.Query)
}
return &defs.PathAddReaderRes{Path: &dummyPath{}, Stream: strm}, nil
},
}
switch ca {
case "always remux off":
s := &Server{
Address: "127.0.0.1:8888",
AlwaysRemux: false,
Variant: conf.HLSVariant(gohlslib.MuxerVariantMPEGTS),
SegmentCount: 7,
SegmentDuration: conf.Duration(1 * time.Second),
PartDuration: conf.Duration(200 * time.Millisecond),
SegmentMaxSize: 50 * 1024 * 1024,
TrustedProxies: conf.IPNetworks{},
ReadTimeout: conf.Duration(10 * time.Second),
WriteTimeout: conf.Duration(10 * time.Second),
PathManager: pm,
Parent: test.NilLogger,
}
err = s.Initialize()
require.NoError(t, err)
defer s.Close()
c := &gohlslib.Client{
URI: "http://myuser:mypass@127.0.0.1:8888/teststream/index.m3u8?param=value",
StartDistance: 1,
}
recv1 := make(chan struct{})
recv2 := make(chan struct{})
c.OnTracks = func(tracks []*gohlslib.Track) error { //nolint:dupl
require.Equal(t, []*gohlslib.Track{
{
Codec: &codecs.H264{},
ClockRate: 90000,
},
{
Codec: &codecs.MPEG4Audio{
Config: mpeg4audio.AudioSpecificConfig{
Type: 2,
ChannelCount: 2,
ChannelConfig: 2,
SampleRate: 44100,
},
},
ClockRate: 90000,
},
}, tracks)
c.OnDataH26x(tracks[0], func(pts, dts int64, au [][]byte) {
require.Equal(t, int64(0), pts)
require.Equal(t, int64(0), dts)
require.Equal(t, [][]byte{
test.FormatH264.SPS,
test.FormatH264.PPS,
{5, 1},
}, au)
close(recv1)
})
c.OnDataMPEG4Audio(tracks[1], func(pts int64, aus [][]byte) {
require.Equal(t, int64(0), pts)
require.Equal(t, [][]byte{{1, 2}}, aus)
close(recv2)
})
return nil
}
err = c.Start()
require.NoError(t, err)
defer c.Close()
strm.WaitForReaders()
for i := range 2 {
subStream.WriteUnit(test.MediaH264, test.FormatH264, &unit.Unit{
NTP: time.Time{},
PTS: int64(i) * 90000,
Payload: unit.PayloadH264{
{5, 1}, // IDR
},
})
subStream.WriteUnit(test.MediaMPEG4Audio, test.FormatMPEG4Audio, &unit.Unit{
NTP: time.Time{},
PTS: int64(i) * 44100,
Payload: unit.PayloadMPEG4Audio{{1, 2}},
})
}
<-recv1
<-recv2
case "always remux on":
s := &Server{
Address: "127.0.0.1:8888",
AlwaysRemux: true,
Variant: conf.HLSVariant(gohlslib.MuxerVariantMPEGTS),
SegmentCount: 7,
SegmentDuration: conf.Duration(1 * time.Second),
PartDuration: conf.Duration(200 * time.Millisecond),
SegmentMaxSize: 50 * 1024 * 1024,
TrustedProxies: conf.IPNetworks{},
ReadTimeout: conf.Duration(10 * time.Second),
WriteTimeout: conf.Duration(10 * time.Second),
PathManager: pm,
Parent: test.NilLogger,
}
err = s.Initialize()
require.NoError(t, err)
defer s.Close()
s.PathReady(&dummyPath{})
strm.WaitForReaders()
for i := range 2 {
subStream.WriteUnit(test.MediaH264, test.FormatH264, &unit.Unit{
NTP: time.Time{},
PTS: int64(i) * 90000,
Payload: unit.PayloadH264{
{5, 1}, // IDR
},
})
subStream.WriteUnit(test.MediaMPEG4Audio, test.FormatMPEG4Audio, &unit.Unit{
NTP: time.Time{},
PTS: int64(i) * 44100,
Payload: unit.PayloadMPEG4Audio{{1, 2}},
})
}
c := &gohlslib.Client{
URI: "http://myuser:mypass@127.0.0.1:8888/teststream/index.m3u8?param=value",
StartDistance: 1,
}
recv1 := make(chan struct{})
recv2 := make(chan struct{})
c.OnTracks = func(tracks []*gohlslib.Track) error { //nolint:dupl
require.Equal(t, []*gohlslib.Track{
{
Codec: &codecs.H264{},
ClockRate: 90000,
},
{
Codec: &codecs.MPEG4Audio{
Config: mpeg4audio.AudioSpecificConfig{
Type: 2,
ChannelCount: 2,
ChannelConfig: 2,
SampleRate: 44100,
},
},
ClockRate: 90000,
},
}, tracks)
c.OnDataH26x(tracks[0], func(pts, dts int64, au [][]byte) {
require.Equal(t, int64(0), pts)
require.Equal(t, int64(0), dts)
require.Equal(t, [][]byte{
test.FormatH264.SPS,
test.FormatH264.PPS,
{5, 1},
}, au)
close(recv1)
})
c.OnDataMPEG4Audio(tracks[1], func(pts int64, aus [][]byte) {
require.Equal(t, int64(0), pts)
require.Equal(t, [][]byte{{1, 2}}, aus)
close(recv2)
})
return nil
}
err = c.Start()
require.NoError(t, err)
defer c.Close()
<-recv1
<-recv2
}
})
}
}
func TestServerDirectory(t *testing.T) {
dir, err := os.MkdirTemp("", "mediamtx-playback")
require.NoError(t, err)
defer os.RemoveAll(dir)
desc := &description.Session{Medias: []*description.Media{test.MediaH264}}
strm := &stream.Stream{
Desc: desc,
WriteQueueSize: 512,
RTPMaxPayloadSize: 1450,
Parent: test.NilLogger,
}
err = strm.Initialize()
require.NoError(t, err)
subStream := &stream.SubStream{
Stream: strm,
UseRTPPackets: false,
}
err = subStream.Initialize()
require.NoError(t, err)
pm := &dummyPathManager{
addReaderImpl: func(_ defs.PathAddReaderReq) (*defs.PathAddReaderRes, error) {
return &defs.PathAddReaderRes{Path: &dummyPath{}, Stream: strm}, nil
},
}
s := &Server{
Address: "127.0.0.1:8888",
Encryption: false,
ServerKey: "",
ServerCert: "",
AlwaysRemux: true,
Variant: conf.HLSVariant(gohlslib.MuxerVariantMPEGTS),
SegmentCount: 7,
SegmentDuration: conf.Duration(1 * time.Second),
PartDuration: conf.Duration(200 * time.Millisecond),
SegmentMaxSize: 50 * 1024 * 1024,
TrustedProxies: conf.IPNetworks{},
Directory: filepath.Join(dir, "mydir"),
ReadTimeout: conf.Duration(10 * time.Second),
WriteTimeout: conf.Duration(10 * time.Second),
PathManager: pm,
Parent: test.NilLogger,
}
err = s.Initialize()
require.NoError(t, err)
defer s.Close()
s.PathReady(&dummyPath{})
time.Sleep(100 * time.Millisecond)
_, err = os.Stat(filepath.Join(dir, "mydir", "teststream"))
require.NoError(t, err)
}
func TestServerDynamicAlwaysRemux(t *testing.T) {
desc := &description.Session{Medias: []*description.Media{test.MediaH264}}
strm := &stream.Stream{
Desc: desc,
WriteQueueSize: 512,
RTPMaxPayloadSize: 1450,
Parent: test.NilLogger,
}
err := strm.Initialize()
require.NoError(t, err)
subStream := &stream.SubStream{
Stream: strm,
UseRTPPackets: false,
}
err = subStream.Initialize()
require.NoError(t, err)
done := make(chan struct{})
pm := &dummyPathManager{
setHLSServerImpl: func() []defs.Path {
return []defs.Path{&dummyPath{}}
},
addReaderImpl: func(_ defs.PathAddReaderReq) (*defs.PathAddReaderRes, error) {
close(done)
return &defs.PathAddReaderRes{Path: &dummyPath{}, Stream: strm}, nil
},
}
s := &Server{
Address: "127.0.0.1:8888",
Encryption: false,
ServerKey: "",
ServerCert: "",
AlwaysRemux: true,
Variant: conf.HLSVariant(gohlslib.MuxerVariantMPEGTS),
SegmentCount: 7,
SegmentDuration: conf.Duration(1 * time.Second),
PartDuration: conf.Duration(200 * time.Millisecond),
SegmentMaxSize: 50 * 1024 * 1024,
ReadTimeout: conf.Duration(10 * time.Second),
WriteTimeout: conf.Duration(10 * time.Second),
PathManager: pm,
Parent: test.NilLogger,
}
err = s.Initialize()
require.NoError(t, err)
defer s.Close()
<-done
}
func TestAuthError(t *testing.T) {
n := 0
s := &Server{
Address: "127.0.0.1:8888",
Encryption: false,
ServerKey: "",
ServerCert: "",
AlwaysRemux: true,
Variant: conf.HLSVariant(gohlslib.MuxerVariantMPEGTS),
SegmentCount: 7,
SegmentDuration: conf.Duration(1 * time.Second),
PartDuration: conf.Duration(200 * time.Millisecond),
SegmentMaxSize: 50 * 1024 * 1024,
ReadTimeout: conf.Duration(10 * time.Second),
WriteTimeout: conf.Duration(10 * time.Second),
PathManager: &dummyPathManager{
findPathConfImpl: func(req defs.PathFindPathConfReq) (*defs.PathFindPathConfRes, error) {
if req.AccessRequest.Credentials.User == "" && req.AccessRequest.Credentials.Pass == "" {
return nil, &auth.Error{AskCredentials: true, Wrapped: fmt.Errorf("auth error")}
}
return nil, &auth.Error{Wrapped: fmt.Errorf("auth error")}
},
},
Parent: test.Logger(func(l logger.Level, s string, i ...any) {
if l == logger.Info {
if n == 1 {
require.Regexp(t, "failed to authenticate: auth error$", fmt.Sprintf(s, i...))
}
n++
}
}),
}
err := s.Initialize()
require.NoError(t, err)
defer s.Close()
req, err := http.NewRequest(http.MethodGet, "http://127.0.0.1:8888/stream/index.m3u8", nil)
require.NoError(t, err)
res, err := http.DefaultClient.Do(req)
require.NoError(t, err)
defer res.Body.Close()
require.Equal(t, http.StatusUnauthorized, res.StatusCode)
require.Equal(t, `Basic realm="mediamtx"`, res.Header.Get("WWW-Authenticate"))
req, err = http.NewRequest(http.MethodGet, "http://myuser:mypass@127.0.0.1:8888/stream/index.m3u8", nil)
require.NoError(t, err)
start := time.Now()
res, err = http.DefaultClient.Do(req)
require.NoError(t, err)
defer res.Body.Close()
require.Greater(t, time.Since(start), 2*time.Second)
require.Equal(t, http.StatusUnauthorized, res.StatusCode)
require.Equal(t, 2, n)
}
================================================
FILE: internal/servers/rtmp/conn.go
================================================
package rtmp
import (
"context"
"errors"
"fmt"
"net"
"strings"
"sync"
"time"
"github.com/bluenviron/gortmplib"
"github.com/bluenviron/gortsplib/v5/pkg/description"
"github.com/google/uuid"
"github.com/bluenviron/mediamtx/internal/auth"
"github.com/bluenviron/mediamtx/internal/conf"
"github.com/bluenviron/mediamtx/internal/defs"
"github.com/bluenviron/mediamtx/internal/externalcmd"
"github.com/bluenviron/mediamtx/internal/hooks"
"github.com/bluenviron/mediamtx/internal/logger"
"github.com/bluenviron/mediamtx/internal/protocols/rtmp"
"github.com/bluenviron/mediamtx/internal/stream"
)
type conn struct {
parentCtx context.Context
isTLS bool
rtspAddress string
readTimeout conf.Duration
writeTimeout conf.Duration
runOnConnect string
runOnConnectRestart bool
runOnDisconnect string
wg *sync.WaitGroup
nconn net.Conn
externalCmdPool *externalcmd.Pool
pathManager serverPathManager
parent *Server
ctx context.Context
ctxCancel func()
uuid uuid.UUID
created time.Time
mutex sync.RWMutex
rconn *gortmplib.ServerConn
state defs.APIRTMPConnState
pathName string
query string
user string
reader *stream.Reader
}
func (c *conn) initialize() {
c.ctx, c.ctxCancel = context.WithCancel(c.parentCtx)
c.uuid = uuid.New()
c.created = time.Now()
c.state = defs.APIRTMPConnStateIdle
c.Log(logger.Info, "opened")
c.wg.Add(1)
go c.run()
}
func (c *conn) Close() {
c.ctxCancel()
}
func (c *conn) remoteAddr() net.Addr {
return c.nconn.RemoteAddr()
}
// Log implements logger.Writer.
func (c *conn) Log(level logger.Level, format string, args ...any) {
c.parent.Log(level, "[conn %v] "+format, append([]any{c.nconn.RemoteAddr()}, args...)...)
}
func (c *conn) ip() net.IP {
return c.nconn.RemoteAddr().(*net.TCPAddr).IP
}
func (c *conn) run() { //nolint:dupl
defer c.wg.Done()
onDisconnectHook := hooks.OnConnect(hooks.OnConnectParams{
Logger: c,
ExternalCmdPool: c.externalCmdPool,
RunOnConnect: c.runOnConnect,
RunOnConnectRestart: c.runOnConnectRestart,
RunOnDisconnect: c.runOnDisconnect,
RTSPAddress: c.rtspAddress,
Desc: *c.APIReaderDescribe(),
})
defer onDisconnectHook()
err := c.runInner()
c.ctxCancel()
c.parent.closeConn(c)
c.Log(logger.Info, "closed: %v", err)
}
func (c *conn) runInner() error {
readerErr := make(chan error)
go func() {
readerErr <- c.runReader()
}()
select {
case err := <-readerErr:
c.nconn.Close()
return err
case <-c.ctx.Done():
c.nconn.Close()
<-readerErr
return errors.New("terminated")
}
}
func (c *conn) runReader() error {
c.nconn.SetReadDeadline(time.Now().Add(time.Duration(c.readTimeout)))
c.nconn.SetWriteDeadline(time.Now().Add(time.Duration(c.writeTimeout)))
conn := &gortmplib.ServerConn{
RW: c.nconn,
}
err := conn.Initialize()
if err != nil {
return err
}
err = conn.Accept()
if err != nil {
return err
}
c.mutex.Lock()
c.rconn = conn
c.mutex.Unlock()
if !conn.Publish {
return c.runRead()
}
return c.runPublish()
}
func (c *conn) runRead() error {
pathName := strings.TrimLeft(c.rconn.URL.Path, "/")
query := c.rconn.URL.Query()
res, err := c.pathManager.AddReader(defs.PathAddReaderReq{
Author: c,
AccessRequest: defs.PathAccessRequest{
Name: pathName,
Query: c.rconn.URL.RawQuery,
Proto: auth.ProtocolRTMP,
ID: &c.uuid,
Credentials: &auth.Credentials{
User: query.Get("user"),
Pass: query.Get("pass"),
},
IP: c.ip(),
},
})
if err != nil {
var terr *auth.Error
if errors.As(err, &terr) {
// wait some seconds to delay brute force attacks
<-time.After(auth.PauseAfterError)
return terr
}
return err
}
defer res.Path.RemoveReader(defs.PathRemoveReaderReq{Author: c})
c.mutex.Lock()
c.state = defs.APIRTMPConnStateRead
c.pathName = pathName
c.query = c.rconn.URL.RawQuery
c.user = res.User
c.mutex.Unlock()
r := &stream.Reader{Parent: c}
err = rtmp.FromStream(res.Stream.Desc, r, c.rconn, c.nconn, time.Duration(c.writeTimeout))
if err != nil {
return err
}
c.Log(logger.Info, "is reading from path '%s', %s",
res.Path.Name(), defs.FormatsInfo(r.Formats()))
onUnreadHook := hooks.OnRead(hooks.OnReadParams{
Logger: c,
ExternalCmdPool: c.externalCmdPool,
Conf: res.Path.SafeConf(),
ExternalCmdEnv: res.Path.ExternalCmdEnv(),
Reader: *c.APIReaderDescribe(),
Query: c.rconn.URL.RawQuery,
})
defer onUnreadHook()
c.nconn.SetReadDeadline(time.Time{})
res.Stream.AddReader(r)
defer res.Stream.RemoveReader(r)
c.mutex.Lock()
c.reader = r
c.mutex.Unlock()
select {
case <-c.ctx.Done():
return fmt.Errorf("terminated")
case err = <-r.Error():
return err
}
}
func (c *conn) runPublish() error {
pathName := strings.TrimLeft(c.rconn.URL.Path, "/")
query := c.rconn.URL.Query()
r := &gortmplib.Reader{
Conn: c.rconn,
}
err := r.Initialize()
if err != nil {
return err
}
var subStream *stream.SubStream
medias, err := rtmp.ToStream(r, &subStream)
if err != nil {
return err
}
res, err := c.pathManager.AddPublisher(defs.PathAddPublisherReq{
Author: c,
Desc: &description.Session{Medias: medias},
UseRTPPackets: false,
ReplaceNTP: true,
AccessRequest: defs.PathAccessRequest{
Name: pathName,
Query: c.rconn.URL.RawQuery,
Publish: true,
Proto: auth.ProtocolRTMP,
ID: &c.uuid,
Credentials: &auth.Credentials{
User: query.Get("user"),
Pass: query.Get("pass"),
},
IP: c.ip(),
},
})
if err != nil {
var terr *auth.Error
if errors.As(err, &terr) {
// wait some seconds to delay brute force attacks
<-time.After(auth.PauseAfterError)
return terr
}
return err
}
defer res.Path.RemovePublisher(defs.PathRemovePublisherReq{Author: c})
subStream = res.SubStream
c.mutex.Lock()
c.state = defs.APIRTMPConnStatePublish
c.pathName = pathName
c.query = c.rconn.URL.RawQuery
c.user = res.User
c.mutex.Unlock()
c.nconn.SetWriteDeadline(time.Time{})
for {
c.nconn.SetReadDeadline(time.Now().Add(time.Duration(c.readTimeout)))
err = r.Read()
if err != nil {
return err
}
}
}
// APIReaderDescribe implements reader.
func (c *conn) APIReaderDescribe() *defs.APIPathReader {
return &defs.APIPathReader{
Type: func() defs.APIPathReaderType {
if c.isTLS {
return defs.APIPathReaderTypeRTMPSConn
}
return defs.APIPathReaderTypeRTMPConn
}(),
ID: c.uuid.String(),
}
}
// APISourceDescribe implements source.
func (c *conn) APISourceDescribe() *defs.APIPathSource {
return &defs.APIPathSource{
Type: func() defs.APIPathSourceType {
if c.isTLS {
return defs.APIPathSourceTypeRTMPSConn
}
return defs.APIPathSourceTypeRTMPConn
}(),
ID: c.uuid.String(),
}
}
func (c *conn) apiItem() *defs.APIRTMPConn {
c.mutex.RLock()
defer c.mutex.RUnlock()
bytesReceived := uint64(0)
bytesSent := uint64(0)
outboundFramesDiscarded := uint64(0)
if c.rconn != nil {
bytesReceived = c.rconn.BytesReceived()
bytesSent = c.rconn.BytesSent()
}
if c.reader != nil {
outboundFramesDiscarded = c.reader.OutboundFramesDiscarded()
}
return &defs.APIRTMPConn{
ID: c.uuid,
Created: c.created,
RemoteAddr: c.remoteAddr().String(),
State: c.state,
Path: c.pathName,
Query: c.query,
User: c.user,
InboundBytes: bytesReceived,
OutboundBytes: bytesSent,
BytesReceived: bytesReceived,
BytesSent: bytesSent,
OutboundFramesDiscarded: outboundFramesDiscarded,
}
}
================================================
FILE: internal/servers/rtmp/listener.go
================================================
package rtmp
import (
"net"
"sync"
)
type listener struct {
ln net.Listener
wg *sync.WaitGroup
parent *Server
}
func (l *listener) initialize() {
l.wg.Add(1)
go l.run()
}
func (l *listener) run() {
defer l.wg.Done()
err := l.runInner()
l.parent.acceptError(err)
}
func (l *listener) runInner() error {
for {
conn, err := l.ln.Accept()
if err != nil {
return err
}
l.parent.newConn(conn)
}
}
================================================
FILE: internal/servers/rtmp/server.go
================================================
// Package rtmp contains a RTMP server.
package rtmp
import (
"context"
"crypto/tls"
"errors"
"fmt"
"net"
"reflect"
"sort"
"sync"
"github.com/google/uuid"
"github.com/bluenviron/mediamtx/internal/certloader"
"github.com/bluenviron/mediamtx/internal/conf"
"github.com/bluenviron/mediamtx/internal/defs"
"github.com/bluenviron/mediamtx/internal/externalcmd"
"github.com/bluenviron/mediamtx/internal/logger"
"github.com/bluenviron/mediamtx/internal/packetdumper"
"github.com/bluenviron/mediamtx/internal/restrictnetwork"
)
// ErrConnNotFound is returned when a connection is not found.
var ErrConnNotFound = errors.New("connection not found")
func interfaceIsEmpty(i any) bool {
return reflect.ValueOf(i).Kind() != reflect.Pointer || reflect.ValueOf(i).IsNil()
}
type serverAPIConnsListRes struct {
data *defs.APIRTMPConnList
err error
}
type serverAPIConnsListReq struct {
res chan serverAPIConnsListRes
}
type serverAPIConnsGetRes struct {
data *defs.APIRTMPConn
err error
}
type serverAPIConnsGetReq struct {
uuid uuid.UUID
res chan serverAPIConnsGetRes
}
type serverAPIConnsKickRes struct {
err error
}
type serverAPIConnsKickReq struct {
uuid uuid.UUID
res chan serverAPIConnsKickRes
}
type serverMetrics interface {
SetRTMPSServer(defs.APIRTMPServer)
SetRTMPServer(defs.APIRTMPServer)
}
type serverPathManager interface {
AddPublisher(req defs.PathAddPublisherReq) (*defs.PathAddPublisherRes, error)
AddReader(req defs.PathAddReaderReq) (*defs.PathAddReaderRes, error)
}
type serverParent interface {
logger.Writer
}
// Server is a RTMP server.
type Server struct {
Address string
DumpPackets bool
ReadTimeout conf.Duration
WriteTimeout conf.Duration
IsTLS bool
ServerCert string
ServerKey string
RTSPAddress string
RunOnConnect string
RunOnConnectRestart bool
RunOnDisconnect string
ExternalCmdPool *externalcmd.Pool
Metrics serverMetrics
PathManager serverPathManager
Parent serverParent
ctx context.Context
ctxCancel func()
wg sync.WaitGroup
ln net.Listener
conns map[*conn]struct{}
loader *certloader.CertLoader
// in
chNewConn chan net.Conn
chAcceptErr chan error
chCloseConn chan *conn
chAPIConnsList chan serverAPIConnsListReq
chAPIConnsGet chan serverAPIConnsGetReq
chAPIConnsKick chan serverAPIConnsKickReq
}
// Initialize initializes the server.
func (s *Server) Initialize() error {
var err error
s.ln, err = net.Listen(restrictnetwork.Restrict("tcp", s.Address))
if err != nil {
return err
}
if s.DumpPackets {
s.ln = &packetdumper.Listener{
Prefix: "rtmp_server_conn",
Listener: s.ln,
}
}
if s.IsTLS {
s.loader = &certloader.CertLoader{
CertPath: s.ServerCert,
KeyPath: s.ServerKey,
Parent: s.Parent,
}
err = s.loader.Initialize()
if err != nil {
s.ln.Close()
return err
}
s.ln = tls.NewListener(s.ln, &tls.Config{GetCertificate: s.loader.GetCertificate()})
}
s.ctx, s.ctxCancel = context.WithCancel(context.Background())
s.conns = make(map[*conn]struct{})
s.chNewConn = make(chan net.Conn)
s.chAcceptErr = make(chan error)
s.chCloseConn = make(chan *conn)
s.chAPIConnsList = make(chan serverAPIConnsListReq)
s.chAPIConnsGet = make(chan serverAPIConnsGetReq)
s.chAPIConnsKick = make(chan serverAPIConnsKickReq)
s.Log(logger.Info, "listener opened on %s", s.Address)
l := &listener{
ln: s.ln,
wg: &s.wg,
parent: s,
}
l.initialize()
s.wg.Add(1)
go s.run()
if !interfaceIsEmpty(s.Metrics) {
if s.IsTLS {
s.Metrics.SetRTMPSServer(s)
} else {
s.Metrics.SetRTMPServer(s)
}
}
return nil
}
// Log implements logger.Writer.
func (s *Server) Log(level logger.Level, format string, args ...any) {
label := func() string {
if s.IsTLS {
return "RTMPS"
}
return "RTMP"
}()
s.Parent.Log(level, "[%s] "+format, append([]any{label}, args...)...)
}
// Close closes the server.
func (s *Server) Close() {
s.Log(logger.Info, "listener is closing")
if !interfaceIsEmpty((s.Metrics)) {
if s.IsTLS {
s.Metrics.SetRTMPSServer(nil)
} else {
s.Metrics.SetRTMPServer(nil)
}
}
s.ctxCancel()
s.wg.Wait()
if s.loader != nil {
s.loader.Close()
}
}
func (s *Server) run() {
defer s.wg.Done()
outer:
for {
select {
case err := <-s.chAcceptErr:
s.Log(logger.Error, "%s", err)
break outer
case nconn := <-s.chNewConn:
c := &conn{
parentCtx: s.ctx,
isTLS: s.IsTLS,
rtspAddress: s.RTSPAddress,
readTimeout: s.ReadTimeout,
writeTimeout: s.WriteTimeout,
runOnConnect: s.RunOnConnect,
runOnConnectRestart: s.RunOnConnectRestart,
runOnDisconnect: s.RunOnDisconnect,
wg: &s.wg,
nconn: nconn,
externalCmdPool: s.ExternalCmdPool,
pathManager: s.PathManager,
parent: s,
}
c.initialize()
s.conns[c] = struct{}{}
case c := <-s.chCloseConn:
delete(s.conns, c)
case req := <-s.chAPIConnsList:
data := &defs.APIRTMPConnList{
Items: []defs.APIRTMPConn{},
}
for c := range s.conns {
data.Items = append(data.Items, *c.apiItem())
}
sort.Slice(data.Items, func(i, j int) bool {
return data.Items[i].Created.Before(data.Items[j].Created)
})
req.res <- serverAPIConnsListRes{data: data}
case req := <-s.chAPIConnsGet:
c := s.findConnByUUID(req.uuid)
if c == nil {
req.res <- serverAPIConnsGetRes{err: ErrConnNotFound}
continue
}
req.res <- serverAPIConnsGetRes{data: c.apiItem()}
case req := <-s.chAPIConnsKick:
c := s.findConnByUUID(req.uuid)
if c == nil {
req.res <- serverAPIConnsKickRes{err: ErrConnNotFound}
continue
}
delete(s.conns, c)
c.Close()
req.res <- serverAPIConnsKickRes{}
case <-s.ctx.Done():
break outer
}
}
s.ctxCancel()
s.ln.Close()
}
func (s *Server) findConnByUUID(uuid uuid.UUID) *conn {
for c := range s.conns {
if c.uuid == uuid {
return c
}
}
return nil
}
// newConn is called by rtmpListener.
func (s *Server) newConn(conn net.Conn) {
select {
case s.chNewConn <- conn:
case <-s.ctx.Done():
conn.Close()
}
}
// acceptError is called by rtmpListener.
func (s *Server) acceptError(err error) {
select {
case s.chAcceptErr <- err:
case <-s.ctx.Done():
}
}
// closeConn is called by conn.
func (s *Server) closeConn(c *conn) {
select {
case s.chCloseConn <- c:
case <-s.ctx.Done():
}
}
// APIConnsList is called by api.
func (s *Server) APIConnsList() (*defs.APIRTMPConnList, error) {
req := serverAPIConnsListReq{
res: make(chan serverAPIConnsListRes),
}
select {
case s.chAPIConnsList <- req:
res := <-req.res
return res.data, res.err
case <-s.ctx.Done():
return nil, fmt.Errorf("terminated")
}
}
// APIConnsGet is called by api.
func (s *Server) APIConnsGet(uuid uuid.UUID) (*defs.APIRTMPConn, error) {
req := serverAPIConnsGetReq{
uuid: uuid,
res: make(chan serverAPIConnsGetRes),
}
select {
case s.chAPIConnsGet <- req:
res := <-req.res
return res.data, res.err
case <-s.ctx.Done():
return nil, fmt.Errorf("terminated")
}
}
// APIConnsKick is called by api.
func (s *Server) APIConnsKick(uuid uuid.UUID) error {
req := serverAPIConnsKickReq{
uuid: uuid,
res: make(chan serverAPIConnsKickRes),
}
select {
case s.chAPIConnsKick <- req:
res := <-req.res
return res.err
case <-s.ctx.Done():
return fmt.Errorf("terminated")
}
}
================================================
FILE: internal/servers/rtmp/server_test.go
================================================
package rtmp
import (
"context"
"crypto/tls"
"net/url"
"os"
"testing"
"time"
"github.com/bluenviron/gortmplib"
"github.com/bluenviron/gortmplib/pkg/codecs"
"github.com/bluenviron/gortsplib/v5/pkg/description"
"github.com/bluenviron/mediamtx/internal/conf"
"github.com/bluenviron/mediamtx/internal/defs"
"github.com/bluenviron/mediamtx/internal/externalcmd"
"github.com/bluenviron/mediamtx/internal/stream"
"github.com/bluenviron/mediamtx/internal/test"
"github.com/bluenviron/mediamtx/internal/unit"
"github.com/stretchr/testify/require"
)
type dummyPath struct{}
func (p *dummyPath) Name() string {
return "teststream"
}
func (p *dummyPath) SafeConf() *conf.Path {
return &conf.Path{}
}
func (p *dummyPath) ExternalCmdEnv() externalcmd.Environment {
return externalcmd.Environment{}
}
func (p *dummyPath) RemovePublisher(_ defs.PathRemovePublisherReq) {
}
func (p *dummyPath) RemoveReader(_ defs.PathRemoveReaderReq) {
}
func TestServerPublish(t *testing.T) {
for _, encrypt := range []string{
"plain",
"tls",
} {
t.Run(encrypt, func(t *testing.T) {
var serverCertFpath string
var serverKeyFpath string
if encrypt == "tls" {
var err error
serverCertFpath, err = test.CreateTempFile(test.TLSCertPub)
require.NoError(t, err)
defer os.Remove(serverCertFpath)
serverKeyFpath, err = test.CreateTempFile(test.TLSCertKey)
require.NoError(t, err)
defer os.Remove(serverKeyFpath)
}
var strm *stream.Stream
var reader *stream.Reader
defer func() {
strm.RemoveReader(reader)
}()
dataReceived := make(chan struct{})
n := 0
pathManager := &test.PathManager{
AddPublisherImpl: func(req defs.PathAddPublisherReq) (*defs.PathAddPublisherRes, error) {
require.Equal(t, "teststream", req.AccessRequest.Name)
require.Equal(t, "user=myuser&pass=mypass¶m=value", req.AccessRequest.Query)
require.Equal(t, "myuser", req.AccessRequest.Credentials.User)
require.Equal(t, "mypass", req.AccessRequest.Credentials.Pass)
strm = &stream.Stream{
Desc: req.Desc,
WriteQueueSize: 512,
RTPMaxPayloadSize: 1450,
Parent: test.NilLogger,
}
err := strm.Initialize()
require.NoError(t, err)
subStream := &stream.SubStream{
Stream: strm,
UseRTPPackets: false,
}
err = subStream.Initialize()
require.NoError(t, err)
reader = &stream.Reader{Parent: test.NilLogger}
reader.OnData(
strm.Desc.Medias[0],
strm.Desc.Medias[0].Formats[0],
func(u *unit.Unit) error {
switch n {
case 0:
require.Equal(t, unit.PayloadH264(nil), u.Payload)
case 1:
require.Equal(t, unit.PayloadH264{
test.FormatH264.SPS,
test.FormatH264.PPS,
{5, 2, 3, 4},
}, u.Payload)
close(dataReceived)
default:
t.Errorf("should not happen")
}
n++
return nil
})
strm.AddReader(reader)
return &defs.PathAddPublisherRes{
Path: &dummyPath{},
User: req.AccessRequest.Credentials.User,
SubStream: subStream,
}, nil
},
}
s := &Server{
Address: "127.0.0.1:1939",
ReadTimeout: conf.Duration(10 * time.Second),
WriteTimeout: conf.Duration(10 * time.Second),
IsTLS: encrypt == "tls",
ServerCert: serverCertFpath,
ServerKey: serverKeyFpath,
RTSPAddress: "",
RunOnConnect: "",
RunOnConnectRestart: false,
RunOnDisconnect: "",
ExternalCmdPool: nil,
PathManager: pathManager,
Parent: test.NilLogger,
}
err := s.Initialize()
require.NoError(t, err)
defer s.Close()
var rawURL string
if encrypt == "tls" {
rawURL += "rtmps://"
} else {
rawURL += "rtmp://"
}
rawURL += "127.0.0.1:1939/teststream?user=myuser&pass=mypass¶m=value"
u, err := url.Parse(rawURL)
require.NoError(t, err)
conn := &gortmplib.Client{
URL: u,
TLSConfig: &tls.Config{InsecureSkipVerify: true},
Publish: true,
}
err = conn.Initialize(context.Background())
require.NoError(t, err)
defer conn.Close()
w := &gortmplib.Writer{
Conn: conn,
Tracks: []*gortmplib.Track{
{Codec: &codecs.H264{
SPS: test.FormatH264.SPS,
PPS: test.FormatH264.PPS,
}},
{Codec: &codecs.MPEG4Audio{
Config: test.FormatMPEG4Audio.Config,
}},
},
}
err = w.Initialize()
require.NoError(t, err)
err = w.WriteH264(
w.Tracks[0],
2*time.Second, 2*time.Second, [][]byte{
{5, 2, 3, 4},
})
require.NoError(t, err)
<-dataReceived
list, err := s.APIConnsList()
require.NoError(t, err)
require.Equal(t, &defs.APIRTMPConnList{
Items: []defs.APIRTMPConn{
{
ID: list.Items[0].ID,
Created: list.Items[0].Created,
RemoteAddr: list.Items[0].RemoteAddr,
State: "publish",
Path: "teststream",
Query: "user=myuser&pass=mypass¶m=value",
User: "myuser",
InboundBytes: list.Items[0].InboundBytes,
OutboundBytes: list.Items[0].OutboundBytes,
OutboundFramesDiscarded: list.Items[0].OutboundFramesDiscarded,
BytesReceived: list.Items[0].BytesReceived,
BytesSent: list.Items[0].BytesSent,
},
},
}, list)
})
}
}
func TestServerRead(t *testing.T) {
for _, encrypt := range []string{
"plain",
"tls",
} {
t.Run(encrypt, func(t *testing.T) {
var serverCertFpath string
var serverKeyFpath string
if encrypt == "tls" {
var err error
serverCertFpath, err = test.CreateTempFile(test.TLSCertPub)
require.NoError(t, err)
defer os.Remove(serverCertFpath)
serverKeyFpath, err = test.CreateTempFile(test.TLSCertKey)
require.NoError(t, err)
defer os.Remove(serverKeyFpath)
}
desc := &description.Session{Medias: []*description.Media{test.MediaH264}}
strm := &stream.Stream{
Desc: desc,
WriteQueueSize: 512,
RTPMaxPayloadSize: 1450,
Parent: test.NilLogger,
}
err := strm.Initialize()
require.NoError(t, err)
subStream := &stream.SubStream{
Stream: strm,
UseRTPPackets: false,
}
err = subStream.Initialize()
require.NoError(t, err)
pathManager := &test.PathManager{
AddReaderImpl: func(req defs.PathAddReaderReq) (*defs.PathAddReaderRes, error) {
require.Equal(t, "teststream", req.AccessRequest.Name)
require.Equal(t, "user=myuser&pass=mypass¶m=value", req.AccessRequest.Query)
require.Equal(t, "myuser", req.AccessRequest.Credentials.User)
require.Equal(t, "mypass", req.AccessRequest.Credentials.Pass)
return &defs.PathAddReaderRes{Path: &dummyPath{}, User: req.AccessRequest.Credentials.User, Stream: strm}, nil
},
}
s := &Server{
Address: "127.0.0.1:1939",
ReadTimeout: conf.Duration(10 * time.Second),
WriteTimeout: conf.Duration(10 * time.Second),
IsTLS: encrypt == "tls",
ServerCert: serverCertFpath,
ServerKey: serverKeyFpath,
RTSPAddress: "",
RunOnConnect: "",
RunOnConnectRestart: false,
RunOnDisconnect: "",
ExternalCmdPool: nil,
PathManager: pathManager,
Parent: test.NilLogger,
}
err = s.Initialize()
require.NoError(t, err)
defer s.Close()
var rawURL string
if encrypt == "tls" {
rawURL += "rtmps://"
} else {
rawURL += "rtmp://"
}
rawURL += "127.0.0.1:1939/teststream?user=myuser&pass=mypass¶m=value"
u, err := url.Parse(rawURL)
require.NoError(t, err)
conn := &gortmplib.Client{
URL: u,
TLSConfig: &tls.Config{InsecureSkipVerify: true},
Publish: false,
}
err = conn.Initialize(context.Background())
require.NoError(t, err)
defer conn.Close()
strm.WaitForReaders()
go func() {
subStream.WriteUnit(desc.Medias[0], desc.Medias[0].Formats[0], &unit.Unit{
NTP: time.Time{},
Payload: unit.PayloadH264{
{5, 2, 3, 4}, // IDR
},
})
subStream.WriteUnit(desc.Medias[0], desc.Medias[0].Formats[0], &unit.Unit{
NTP: time.Time{},
PTS: 2 * 90000,
Payload: unit.PayloadH264{
{5, 2, 3, 4}, // IDR
},
})
subStream.WriteUnit(desc.Medias[0], desc.Medias[0].Formats[0], &unit.Unit{
NTP: time.Time{},
PTS: 3 * 90000,
Payload: unit.PayloadH264{
{5, 2, 3, 4}, // IDR
},
})
}()
r := &gortmplib.Reader{
Conn: conn,
}
err = r.Initialize()
require.NoError(t, err)
tracks := r.Tracks()
require.Len(t, tracks, 1)
_, ok := tracks[0].Codec.(*codecs.H264)
require.True(t, ok)
r.OnDataH264(tracks[0], func(_ time.Duration, _ time.Duration, au [][]byte) {
require.Equal(t, [][]byte{
test.FormatH264.SPS,
test.FormatH264.PPS,
{5, 2, 3, 4},
}, au)
})
err = r.Read()
require.NoError(t, err)
list, err := s.APIConnsList()
require.NoError(t, err)
require.Equal(t, &defs.APIRTMPConnList{
Items: []defs.APIRTMPConn{
{
ID: list.Items[0].ID,
Created: list.Items[0].Created,
RemoteAddr: list.Items[0].RemoteAddr,
State: "read",
Path: "teststream",
Query: "user=myuser&pass=mypass¶m=value",
User: "myuser",
InboundBytes: list.Items[0].InboundBytes,
OutboundBytes: list.Items[0].OutboundBytes,
OutboundFramesDiscarded: list.Items[0].OutboundFramesDiscarded,
BytesReceived: list.Items[0].BytesReceived,
BytesSent: list.Items[0].BytesSent,
},
},
}, list)
})
}
}
================================================
FILE: internal/servers/rtsp/conn.go
================================================
package rtsp
import (
"errors"
"fmt"
"net"
"slices"
"strings"
"time"
"github.com/bluenviron/gortsplib/v5"
rtspauth "github.com/bluenviron/gortsplib/v5/pkg/auth"
"github.com/bluenviron/gortsplib/v5/pkg/base"
"github.com/bluenviron/gortsplib/v5/pkg/liberrors"
"github.com/google/uuid"
"github.com/bluenviron/mediamtx/internal/auth"
"github.com/bluenviron/mediamtx/internal/conf"
"github.com/bluenviron/mediamtx/internal/defs"
"github.com/bluenviron/mediamtx/internal/externalcmd"
"github.com/bluenviron/mediamtx/internal/hooks"
"github.com/bluenviron/mediamtx/internal/logger"
"github.com/bluenviron/mediamtx/internal/protocols/rtsp"
)
func absoluteURL(req *base.Request, v string) string {
if strings.HasPrefix(v, "/") {
ur := base.URL{
Scheme: req.URL.Scheme,
Host: req.URL.Host,
Path: v,
}
return ur.String()
}
return v
}
func tunnelLabel(t gortsplib.Tunnel) string {
switch t {
case gortsplib.TunnelHTTP:
return "http"
case gortsplib.TunnelWebSocket:
return "websocket"
case gortsplib.TunnelNone:
return "none"
}
return "unknown"
}
type connParent interface {
logger.Writer
getSessionByRSessionUnsafe(rsession *gortsplib.ServerSession) *session
}
type conn struct {
isTLS bool
rtspAddress string
authMethods []rtspauth.VerifyMethod
readTimeout conf.Duration
runOnConnect string
runOnConnectRestart bool
runOnDisconnect string
externalCmdPool *externalcmd.Pool
pathManager serverPathManager
rconn *gortsplib.ServerConn
rserver *gortsplib.Server
parent connParent
uuid uuid.UUID
created time.Time
onDisconnectHook func()
}
func (c *conn) initialize() {
c.uuid = uuid.New()
c.created = time.Now()
c.Log(logger.Info, "opened")
c.onDisconnectHook = hooks.OnConnect(hooks.OnConnectParams{
Logger: c,
ExternalCmdPool: c.externalCmdPool,
RunOnConnect: c.runOnConnect,
RunOnConnectRestart: c.runOnConnectRestart,
RunOnDisconnect: c.runOnDisconnect,
RTSPAddress: c.rtspAddress,
Desc: defs.APIPathReader{
Type: func() defs.APIPathReaderType {
if c.isTLS {
return defs.APIPathReaderTypeRTSPSConn
}
return defs.APIPathReaderTypeRTSPConn
}(),
ID: c.uuid.String(),
},
})
}
// Log implements logger.Writer.
func (c *conn) Log(level logger.Level, format string, args ...any) {
c.parent.Log(level, "[conn %v] "+format, append([]any{c.rconn.NetConn().RemoteAddr()}, args...)...)
}
// Conn returns the RTSP connection.
func (c *conn) Conn() *gortsplib.ServerConn {
return c.rconn
}
func (c *conn) remoteAddr() net.Addr {
return c.rconn.NetConn().RemoteAddr()
}
func (c *conn) ip() net.IP {
return c.rconn.NetConn().RemoteAddr().(*net.TCPAddr).IP
}
// onClose is called by rtspServer.
func (c *conn) onClose(err error) {
c.Log(logger.Info, "closed: %v", err)
c.onDisconnectHook()
}
// onRequest is called by rtspServer.
func (c *conn) onRequest(req *base.Request) {
c.Log(logger.Debug, "[c->s] %v", req)
}
// OnResponse is called by rtspServer.
func (c *conn) OnResponse(res *base.Response) {
c.Log(logger.Debug, "[s->c] %v", res)
}
// onDescribe is called by rtspServer.
func (c *conn) onDescribe(ctx *gortsplib.ServerHandlerOnDescribeCtx,
) (*base.Response, *gortsplib.ServerStream, error) {
if len(ctx.Path) == 0 || ctx.Path[0] != '/' {
return &base.Response{
StatusCode: base.StatusBadRequest,
}, nil, fmt.Errorf("invalid path")
}
ctx.Path = ctx.Path[1:]
// CustomVerifyFunc prevents hashed credentials from working.
// Use it only when strictly needed.
var customVerifyFunc func(expectedUser, expectedPass string) bool
if slices.Contains(c.authMethods, rtspauth.VerifyMethodDigestMD5) {
customVerifyFunc = func(expectedUser, expectedPass string) bool {
return c.rconn.VerifyCredentials(ctx.Request, expectedUser, expectedPass)
}
}
res := c.pathManager.Describe(defs.PathDescribeReq{
AccessRequest: defs.PathAccessRequest{
Name: ctx.Path,
Query: ctx.Query,
Proto: auth.ProtocolRTSP,
ID: &c.uuid,
Credentials: rtsp.Credentials(ctx.Request),
IP: c.ip(),
CustomVerifyFunc: customVerifyFunc,
},
})
if res.Err != nil {
var terr *auth.Error
if errors.As(res.Err, &terr) {
res, err2 := c.handleAuthError(terr)
return res, nil, err2
}
var terr2 defs.PathNoStreamAvailableError
if errors.As(res.Err, &terr2) {
return &base.Response{
StatusCode: base.StatusNotFound,
}, nil, res.Err
}
return &base.Response{
StatusCode: base.StatusBadRequest,
}, nil, res.Err
}
if res.Redirect != "" {
return &base.Response{
StatusCode: base.StatusMovedPermanently,
Header: base.Header{
"Location": base.HeaderValue{absoluteURL(ctx.Request, res.Redirect)},
},
}, nil, nil
}
var strm *gortsplib.ServerStream
if !c.isTLS {
strm = res.Stream.RTSPStream(c.rserver)
} else {
strm = res.Stream.RTSPSStream(c.rserver)
}
return &base.Response{
StatusCode: base.StatusOK,
}, strm, nil
}
func (c *conn) handleAuthError(err *auth.Error) (*base.Response, error) {
if err.AskCredentials {
return &base.Response{
StatusCode: base.StatusUnauthorized,
}, liberrors.ErrServerAuth{}
}
// wait some seconds to delay brute force attacks
<-time.After(auth.PauseAfterError)
return &base.Response{
StatusCode: base.StatusUnauthorized,
}, err
}
func (c *conn) apiItem() *defs.APIRTSPConn {
stats := c.rconn.Stats()
return &defs.APIRTSPConn{
ID: c.uuid,
Created: c.created,
RemoteAddr: c.remoteAddr().String(),
Session: func() *uuid.UUID {
sx := c.parent.getSessionByRSessionUnsafe(c.rconn.Session())
if sx != nil {
return &sx.uuid
}
return nil
}(),
Tunnel: tunnelLabel(c.rconn.Transport().Tunnel),
InboundBytes: stats.InboundBytes,
OutboundBytes: stats.OutboundBytes,
BytesReceived: stats.InboundBytes,
BytesSent: stats.OutboundBytes,
}
}
================================================
FILE: internal/servers/rtsp/mpegts_demuxer.go
================================================
package rtsp
import (
"errors"
"fmt"
"io"
"github.com/bluenviron/gortsplib/v5/pkg/description"
"github.com/bluenviron/gortsplib/v5/pkg/format"
"github.com/pion/rtp"
"github.com/bluenviron/mediamtx/internal/conf"
"github.com/bluenviron/mediamtx/internal/defs"
"github.com/bluenviron/mediamtx/internal/errordumper"
"github.com/bluenviron/mediamtx/internal/logger"
"github.com/bluenviron/mediamtx/internal/protocols/mpegts"
"github.com/bluenviron/mediamtx/internal/stream"
)
// mpegtsDemuxer demuxes an MPEG-TS stream received via RTP into component streams.
type mpegtsDemuxer struct {
session *session
pathManager serverPathManager
pathConf *conf.Path
mpegtsMedia *description.Media
mpegtsFormat *format.MPEGTS
decodeErrors *errordumper.Dumper
pathName string
query string
pipeWriter *io.PipeWriter
}
func (d *mpegtsDemuxer) initialize() error {
decoder, err := d.mpegtsFormat.CreateDecoder()
if err != nil {
return fmt.Errorf("failed to create MPEG-TS decoder: %w", err)
}
pr, pw := io.Pipe()
d.pipeWriter = pw
d.session.rsession.OnPacketRTP(d.mpegtsMedia, d.mpegtsFormat, func(pkt *rtp.Packet) {
tsData, decErr := decoder.Decode(pkt)
if decErr != nil {
d.decodeErrors.Add(decErr)
return
}
for _, data := range tsData {
_, err = pw.Write(data)
if err != nil {
d.session.Log(logger.Warn, "demuxer pipe write error: %v", err)
return
}
}
})
go d.run(pr)
return nil
}
func (d *mpegtsDemuxer) close() {
d.pipeWriter.CloseWithError(io.EOF)
}
func (d *mpegtsDemuxer) run(pr *io.PipeReader) {
err := d.doRun(pr)
if err != nil {
d.session.Log(logger.Error, "MPEG-TS demuxer error: %v", err)
d.session.Close()
}
}
func (d *mpegtsDemuxer) doRun(pr *io.PipeReader) error {
r := &mpegts.EnhancedReader{R: pr}
err := r.Initialize()
if err != nil {
return fmt.Errorf("failed to initialize MPEG-TS reader: %w", err)
}
r.OnDecodeError(func(err error) {
d.decodeErrors.Add(err)
})
var subStream *stream.SubStream
medias, err := mpegts.ToStream(r, &subStream, d.session)
if err != nil {
return fmt.Errorf("failed to map MPEG-TS to stream: %w", err)
}
res, err := d.pathManager.AddPublisher(defs.PathAddPublisherReq{
Author: d.session,
Desc: &description.Session{Medias: medias},
UseRTPPackets: false,
ReplaceNTP: true,
ConfToCompare: d.pathConf,
AccessRequest: defs.PathAccessRequest{
Name: d.pathName,
Query: d.query,
Publish: true,
SkipAuth: true,
},
})
if err != nil {
return fmt.Errorf("failed to add publisher: %w", err)
}
defer res.Path.RemovePublisher(defs.PathRemovePublisherReq{Author: d.session})
subStream = res.SubStream
for {
err = r.Read()
if err != nil {
if !errors.Is(err, io.EOF) {
return err
}
return nil
}
}
}
================================================
FILE: internal/servers/rtsp/server.go
================================================
// Package rtsp contains a RTSP server.
package rtsp
import (
"context"
"crypto/tls"
"errors"
"fmt"
"net"
"reflect"
"sort"
"strings"
"sync"
"time"
"github.com/bluenviron/gortsplib/v5"
"github.com/bluenviron/gortsplib/v5/pkg/auth"
"github.com/bluenviron/gortsplib/v5/pkg/base"
"github.com/bluenviron/gortsplib/v5/pkg/liberrors"
"github.com/google/uuid"
"github.com/bluenviron/mediamtx/internal/certloader"
"github.com/bluenviron/mediamtx/internal/conf"
"github.com/bluenviron/mediamtx/internal/defs"
"github.com/bluenviron/mediamtx/internal/externalcmd"
"github.com/bluenviron/mediamtx/internal/logger"
"github.com/bluenviron/mediamtx/internal/packetdumper"
)
// ErrConnNotFound is returned when a connection is not found.
var ErrConnNotFound = errors.New("connection not found")
// ErrSessionNotFound is returned when a session is not found.
var ErrSessionNotFound = errors.New("session not found")
func interfaceIsEmpty(i any) bool {
return reflect.ValueOf(i).Kind() != reflect.Pointer || reflect.ValueOf(i).IsNil()
}
func printAddresses(srv *gortsplib.Server) string {
var ret []string
tmp := srv.RTSPAddress
if srv.TLSConfig == nil {
tmp += " (TCP/RTSP)"
} else {
tmp += " (TCP/RTSPS)"
}
ret = append(ret, tmp)
if srv.UDPRTPAddress != "" {
tmp = srv.UDPRTPAddress
if srv.TLSConfig == nil {
tmp += " (UDP/RTP)"
} else {
tmp += " (UDP/SRTP)"
}
ret = append(ret, tmp)
}
if srv.UDPRTCPAddress != "" {
tmp = srv.UDPRTCPAddress
if srv.TLSConfig == nil {
tmp += " (UDP/RTCP)"
} else {
tmp += " (UDP/SRTCP)"
}
ret = append(ret, tmp)
}
return strings.Join(ret, ", ")
}
type serverMetrics interface {
SetRTSPSServer(defs.APIRTSPServer)
SetRTSPServer(defs.APIRTSPServer)
}
type serverPathManager interface {
FindPathConf(req defs.PathFindPathConfReq) (*defs.PathFindPathConfRes, error)
Describe(req defs.PathDescribeReq) defs.PathDescribeRes
AddPublisher(_ defs.PathAddPublisherReq) (*defs.PathAddPublisherRes, error)
AddReader(_ defs.PathAddReaderReq) (*defs.PathAddReaderRes, error)
}
type serverParent interface {
logger.Writer
}
// Server is a RTSP server.
type Server struct {
Address string
AuthMethods []auth.VerifyMethod
DumpPackets bool
UDPReadBufferSize uint
ReadTimeout conf.Duration
WriteTimeout conf.Duration
WriteQueueSize int
RTSPTransports conf.RTSPTransports
RTPAddress string
RTCPAddress string
MulticastIPRange string
MulticastRTPPort int
MulticastRTCPPort int
IsTLS bool
ServerCert string
ServerKey string
RTSPAddress string
Transports conf.RTSPTransports
RunOnConnect string
RunOnConnectRestart bool
RunOnDisconnect string
ExternalCmdPool *externalcmd.Pool
Metrics serverMetrics
PathManager serverPathManager
Parent serverParent
ctx context.Context
ctxCancel func()
wg sync.WaitGroup
srv *gortsplib.Server
mutex sync.RWMutex
conns map[*gortsplib.ServerConn]*conn
sessions map[*gortsplib.ServerSession]*session
loader *certloader.CertLoader
}
// Initialize initializes the server.
func (s *Server) Initialize() error {
s.ctx, s.ctxCancel = context.WithCancel(context.Background())
s.conns = make(map[*gortsplib.ServerConn]*conn)
s.sessions = make(map[*gortsplib.ServerSession]*session)
s.srv = &gortsplib.Server{
Handler: s,
ReadTimeout: time.Duration(s.ReadTimeout),
WriteTimeout: time.Duration(s.WriteTimeout),
UDPReadBufferSize: int(s.UDPReadBufferSize),
WriteQueueSize: s.WriteQueueSize,
RTSPAddress: s.Address,
AuthMethods: s.AuthMethods,
}
if _, ok := s.RTSPTransports[gortsplib.ProtocolUDP]; ok {
s.srv.UDPRTPAddress = s.RTPAddress
s.srv.UDPRTCPAddress = s.RTCPAddress
}
if _, ok := s.RTSPTransports[gortsplib.ProtocolUDPMulticast]; ok {
s.srv.MulticastIPRange = s.MulticastIPRange
s.srv.MulticastRTPPort = s.MulticastRTPPort
s.srv.MulticastRTCPPort = s.MulticastRTCPPort
}
if s.IsTLS {
s.loader = &certloader.CertLoader{
CertPath: s.ServerCert,
KeyPath: s.ServerKey,
Parent: s.Parent,
}
err := s.loader.Initialize()
if err != nil {
return err
}
s.srv.TLSConfig = &tls.Config{GetCertificate: s.loader.GetCertificate()}
}
if s.DumpPackets {
s.srv.Listen = (&packetdumper.Listen{
Prefix: "rtsp_server_conn",
Listen: net.Listen,
}).Do
s.srv.ListenPacket = (&packetdumper.ListenPacket{
Prefix: "rtsp_server_packetconn",
ListenPacket: net.ListenPacket,
}).Do
}
err := s.srv.Start()
if err != nil {
return err
}
s.Log(logger.Info, "listener opened on %s", printAddresses(s.srv))
s.wg.Add(1)
go s.run()
if !interfaceIsEmpty(s.Metrics) {
if s.IsTLS {
s.Metrics.SetRTSPSServer(s)
} else {
s.Metrics.SetRTSPServer(s)
}
}
return nil
}
// Log implements logger.Writer.
func (s *Server) Log(level logger.Level, format string, args ...any) {
label := func() string {
if s.IsTLS {
return "RTSPS"
}
return "RTSP"
}()
s.Parent.Log(level, "[%s] "+format, append([]any{label}, args...)...)
}
// Close closes the server.
func (s *Server) Close() {
s.Log(logger.Info, "listener is closing")
if !interfaceIsEmpty(s.Metrics) {
if s.IsTLS {
s.Metrics.SetRTSPSServer(nil)
} else {
s.Metrics.SetRTSPServer(nil)
}
}
s.ctxCancel()
s.wg.Wait()
if s.loader != nil {
s.loader.Close()
}
}
func (s *Server) run() {
defer s.wg.Done()
serverErr := make(chan error)
go func() {
serverErr <- s.srv.Wait()
}()
outer:
select {
case err := <-serverErr:
s.Log(logger.Error, "%s", err)
break outer
case <-s.ctx.Done():
s.srv.Close()
<-serverErr
break outer
}
s.ctxCancel()
}
// OnConnOpen implements gortsplib.ServerHandlerOnConnOpen.
func (s *Server) OnConnOpen(ctx *gortsplib.ServerHandlerOnConnOpenCtx) {
c := &conn{
isTLS: s.IsTLS,
rtspAddress: s.RTSPAddress,
authMethods: s.AuthMethods,
readTimeout: s.ReadTimeout,
runOnConnect: s.RunOnConnect,
runOnConnectRestart: s.RunOnConnectRestart,
runOnDisconnect: s.RunOnDisconnect,
externalCmdPool: s.ExternalCmdPool,
pathManager: s.PathManager,
rconn: ctx.Conn,
rserver: s.srv,
parent: s,
}
c.initialize()
s.mutex.Lock()
s.conns[ctx.Conn] = c
s.mutex.Unlock()
ctx.Conn.SetUserData(c)
}
// OnConnClose implements gortsplib.ServerHandlerOnConnClose.
func (s *Server) OnConnClose(ctx *gortsplib.ServerHandlerOnConnCloseCtx) {
s.mutex.Lock()
c := s.conns[ctx.Conn]
delete(s.conns, ctx.Conn)
s.mutex.Unlock()
c.onClose(ctx.Error)
}
// OnRequest implements gortsplib.ServerHandlerOnRequest.
func (s *Server) OnRequest(sc *gortsplib.ServerConn, req *base.Request) {
c := sc.UserData().(*conn)
c.onRequest(req)
}
// OnResponse implements gortsplib.ServerHandlerOnResponse.
func (s *Server) OnResponse(sc *gortsplib.ServerConn, res *base.Response) {
c := sc.UserData().(*conn)
c.OnResponse(res)
}
// OnSessionOpen implements gortsplib.ServerHandlerOnSessionOpen.
func (s *Server) OnSessionOpen(ctx *gortsplib.ServerHandlerOnSessionOpenCtx) {
se := &session{
isTLS: s.IsTLS,
transports: s.Transports,
rsession: ctx.Session,
rconn: ctx.Conn,
rserver: s.srv,
externalCmdPool: s.ExternalCmdPool,
pathManager: s.PathManager,
parent: s,
}
se.initialize()
s.mutex.Lock()
s.sessions[ctx.Session] = se
s.mutex.Unlock()
ctx.Session.SetUserData(se)
}
// OnSessionClose implements gortsplib.ServerHandlerOnSessionClose.
func (s *Server) OnSessionClose(ctx *gortsplib.ServerHandlerOnSessionCloseCtx) {
s.mutex.Lock()
se := s.sessions[ctx.Session]
delete(s.sessions, ctx.Session)
s.mutex.Unlock()
if se != nil {
se.onClose(ctx.Error)
}
}
// OnDescribe implements gortsplib.ServerHandlerOnDescribe.
func (s *Server) OnDescribe(ctx *gortsplib.ServerHandlerOnDescribeCtx,
) (*base.Response, *gortsplib.ServerStream, error) {
c := ctx.Conn.UserData().(*conn)
return c.onDescribe(ctx)
}
// OnAnnounce implements gortsplib.ServerHandlerOnAnnounce.
func (s *Server) OnAnnounce(ctx *gortsplib.ServerHandlerOnAnnounceCtx) (*base.Response, error) {
c := ctx.Conn.UserData().(*conn)
se := ctx.Session.UserData().(*session)
return se.onAnnounce(c, ctx)
}
// OnSetup implements gortsplib.ServerHandlerOnSetup.
func (s *Server) OnSetup(ctx *gortsplib.ServerHandlerOnSetupCtx) (*base.Response, *gortsplib.ServerStream, error) {
c := ctx.Conn.UserData().(*conn)
se := ctx.Session.UserData().(*session)
return se.onSetup(c, ctx)
}
// OnPlay implements gortsplib.ServerHandlerOnPlay.
func (s *Server) OnPlay(ctx *gortsplib.ServerHandlerOnPlayCtx) (*base.Response, error) {
se := ctx.Session.UserData().(*session)
return se.onPlay(ctx)
}
// OnRecord implements gortsplib.ServerHandlerOnRecord.
func (s *Server) OnRecord(ctx *gortsplib.ServerHandlerOnRecordCtx) (*base.Response, error) {
se := ctx.Session.UserData().(*session)
return se.onRecord(ctx)
}
// OnPause implements gortsplib.ServerHandlerOnPause.
func (s *Server) OnPause(ctx *gortsplib.ServerHandlerOnPauseCtx) (*base.Response, error) {
se := ctx.Session.UserData().(*session)
return se.onPause(ctx)
}
// OnPacketsLost implements gortsplib.ServerHandlerOnPacketsLost.
func (s *Server) OnPacketsLost(ctx *gortsplib.ServerHandlerOnPacketsLostCtx) {
se := ctx.Session.UserData().(*session)
se.onPacketsLost(ctx)
}
// OnDecodeError implements gortsplib.ServerHandlerOnDecodeError.
func (s *Server) OnDecodeError(ctx *gortsplib.ServerHandlerOnDecodeErrorCtx) {
se := ctx.Session.UserData().(*session)
se.onDecodeError(ctx)
}
// OnStreamWriteError implements gortsplib.ServerHandlerOnStreamWriteError.
func (s *Server) OnStreamWriteError(ctx *gortsplib.ServerHandlerOnStreamWriteErrorCtx) {
se := ctx.Session.UserData().(*session)
se.onStreamWriteError(ctx)
}
func (s *Server) findConnByUUID(uuid uuid.UUID) *conn {
for _, c := range s.conns {
if c.uuid == uuid {
return c
}
}
return nil
}
func (s *Server) findSessionByUUID(uuid uuid.UUID) (*gortsplib.ServerSession, *session) {
for key, sx := range s.sessions {
if sx.uuid == uuid {
return key, sx
}
}
return nil, nil
}
func (s *Server) getConnByRConnUnsafe(rconn *gortsplib.ServerConn) *conn {
return s.conns[rconn]
}
func (s *Server) getSessionByRSessionUnsafe(rsession *gortsplib.ServerSession) *session {
return s.sessions[rsession]
}
// APIConnsList is called by api and metrics.
func (s *Server) APIConnsList() (*defs.APIRTSPConnsList, error) {
select {
case <-s.ctx.Done():
return nil, fmt.Errorf("terminated")
default:
}
s.mutex.RLock()
defer s.mutex.RUnlock()
data := &defs.APIRTSPConnsList{
Items: []defs.APIRTSPConn{},
}
for _, c := range s.conns {
data.Items = append(data.Items, *c.apiItem())
}
sort.Slice(data.Items, func(i, j int) bool {
return data.Items[i].Created.Before(data.Items[j].Created)
})
return data, nil
}
// APIConnsGet is called by api.
func (s *Server) APIConnsGet(uuid uuid.UUID) (*defs.APIRTSPConn, error) {
select {
case <-s.ctx.Done():
return nil, fmt.Errorf("terminated")
default:
}
s.mutex.RLock()
defer s.mutex.RUnlock()
conn := s.findConnByUUID(uuid)
if conn == nil {
return nil, ErrConnNotFound
}
return conn.apiItem(), nil
}
// APISessionsList is called by api and metrics.
func (s *Server) APISessionsList() (*defs.APIRTSPSessionList, error) {
select {
case <-s.ctx.Done():
return nil, fmt.Errorf("terminated")
default:
}
s.mutex.RLock()
defer s.mutex.RUnlock()
data := &defs.APIRTSPSessionList{
Items: []defs.APIRTSPSession{},
}
for _, s := range s.sessions {
data.Items = append(data.Items, *s.apiItem())
}
sort.Slice(data.Items, func(i, j int) bool {
return data.Items[i].Created.Before(data.Items[j].Created)
})
return data, nil
}
// APISessionsGet is called by api.
func (s *Server) APISessionsGet(uuid uuid.UUID) (*defs.APIRTSPSession, error) {
select {
case <-s.ctx.Done():
return nil, fmt.Errorf("terminated")
default:
}
s.mutex.RLock()
defer s.mutex.RUnlock()
_, sx := s.findSessionByUUID(uuid)
if sx == nil {
return nil, ErrSessionNotFound
}
return sx.apiItem(), nil
}
// APISessionsKick is called by api.
func (s *Server) APISessionsKick(uuid uuid.UUID) error {
select {
case <-s.ctx.Done():
return fmt.Errorf("terminated")
default:
}
s.mutex.RLock()
defer s.mutex.RUnlock()
key, sx := s.findSessionByUUID(uuid)
if sx == nil {
return ErrSessionNotFound
}
sx.Close()
delete(s.sessions, key)
sx.onClose(liberrors.ErrServerTerminated{})
return nil
}
================================================
FILE: internal/servers/rtsp/server_test.go
================================================
package rtsp
import (
"bufio"
"bytes"
"fmt"
"sync/atomic"
"testing"
"time"
"github.com/bluenviron/gortsplib/v5"
rtspauth "github.com/bluenviron/gortsplib/v5/pkg/auth"
"github.com/bluenviron/gortsplib/v5/pkg/base"
"github.com/bluenviron/gortsplib/v5/pkg/description"
"github.com/bluenviron/gortsplib/v5/pkg/format"
mpegts "github.com/bluenviron/mediacommon/v2/pkg/formats/mpegts"
tscodecs "github.com/bluenviron/mediacommon/v2/pkg/formats/mpegts/codecs"
"github.com/bluenviron/mediamtx/internal/auth"
"github.com/bluenviron/mediamtx/internal/conf"
"github.com/bluenviron/mediamtx/internal/defs"
"github.com/bluenviron/mediamtx/internal/externalcmd"
"github.com/bluenviron/mediamtx/internal/logger"
"github.com/bluenviron/mediamtx/internal/stream"
"github.com/bluenviron/mediamtx/internal/test"
"github.com/bluenviron/mediamtx/internal/unit"
"github.com/pion/rtp"
"github.com/stretchr/testify/require"
)
func ptrOf[T any](v T) *T {
p := new(T)
*p = v
return p
}
type dummyPath struct{}
func (p *dummyPath) Name() string {
return "teststream"
}
func (p *dummyPath) SafeConf() *conf.Path {
return &conf.Path{}
}
func (p *dummyPath) ExternalCmdEnv() externalcmd.Environment {
return externalcmd.Environment{}
}
func (p *dummyPath) RemovePublisher(_ defs.PathRemovePublisherReq) {
}
func (p *dummyPath) RemoveReader(_ defs.PathRemoveReaderReq) {
}
func TestServerPublish(t *testing.T) {
for _, ca := range []string{"basic", "digest", "basic+digest"} {
t.Run(ca, func(t *testing.T) {
var strm *stream.Stream
var reader *stream.Reader
defer func() {
strm.RemoveReader(reader)
}()
dataReceived := make(chan struct{})
n := 0
pathManager := &test.PathManager{
FindPathConfImpl: func(req defs.PathFindPathConfReq) (*defs.PathFindPathConfRes, error) {
require.Equal(t, "teststream", req.AccessRequest.Name)
require.Equal(t, "param=value", req.AccessRequest.Query)
if ca == "basic" {
require.Nil(t, req.AccessRequest.CustomVerifyFunc)
if req.AccessRequest.Credentials.User == "" && req.AccessRequest.Credentials.Pass == "" {
return nil, &auth.Error{AskCredentials: true, Wrapped: fmt.Errorf("auth error")}
}
require.Equal(t, "myuser", req.AccessRequest.Credentials.User)
require.Equal(t, "mypass", req.AccessRequest.Credentials.Pass)
} else {
ok := req.AccessRequest.CustomVerifyFunc("myuser", "mypass")
if n == 0 {
require.False(t, ok)
n++
return nil, &auth.Error{AskCredentials: true, Wrapped: fmt.Errorf("auth error")}
}
require.True(t, ok)
}
return &defs.PathFindPathConfRes{Conf: &conf.Path{}, User: req.AccessRequest.Credentials.User}, nil
},
AddPublisherImpl: func(req defs.PathAddPublisherReq) (*defs.PathAddPublisherRes, error) {
require.Equal(t, "teststream", req.AccessRequest.Name)
require.Equal(t, "param=value", req.AccessRequest.Query)
require.True(t, req.AccessRequest.SkipAuth)
strm = &stream.Stream{
Desc: req.Desc,
WriteQueueSize: 512,
RTPMaxPayloadSize: 1450,
Parent: test.NilLogger,
}
err := strm.Initialize()
require.NoError(t, err)
subStream := &stream.SubStream{
Stream: strm,
UseRTPPackets: true,
}
err = subStream.Initialize()
require.NoError(t, err)
reader = &stream.Reader{Parent: test.NilLogger}
reader.OnData(
strm.Desc.Medias[0],
strm.Desc.Medias[0].Formats[0],
func(u *unit.Unit) error {
require.Equal(t, unit.PayloadH264{
test.FormatH264.SPS,
test.FormatH264.PPS,
{5, 2, 3, 4},
}, u.Payload)
close(dataReceived)
return nil
})
strm.AddReader(reader)
return &defs.PathAddPublisherRes{Path: &dummyPath{}, SubStream: subStream}, nil
},
}
var authMethods []rtspauth.VerifyMethod
switch ca {
case "basic":
authMethods = []rtspauth.VerifyMethod{rtspauth.VerifyMethodBasic}
case "digest":
authMethods = []rtspauth.VerifyMethod{rtspauth.VerifyMethodDigestMD5}
default:
authMethods = []rtspauth.VerifyMethod{rtspauth.VerifyMethodBasic, rtspauth.VerifyMethodDigestMD5}
}
s := &Server{
Address: "127.0.0.1:8557",
AuthMethods: authMethods,
ReadTimeout: conf.Duration(10 * time.Second),
WriteTimeout: conf.Duration(10 * time.Second),
WriteQueueSize: 512,
Transports: conf.RTSPTransports{gortsplib.ProtocolTCP: {}},
PathManager: pathManager,
Parent: test.NilLogger,
}
err := s.Initialize()
require.NoError(t, err)
defer s.Close()
source := gortsplib.Client{}
media0 := test.UniqueMediaH264()
err = source.StartRecording(
"rtsp://myuser:mypass@127.0.0.1:8557/teststream?param=value",
&description.Session{Medias: []*description.Media{media0}})
require.NoError(t, err)
defer source.Close()
err = source.WritePacketRTP(media0, &rtp.Packet{
Header: rtp.Header{
Version: 2,
Marker: true,
PayloadType: 96,
SequenceNumber: 123,
Timestamp: 45343,
SSRC: 563423,
},
Payload: []byte{5, 2, 3, 4},
})
require.NoError(t, err)
<-dataReceived
list, err := s.APISessionsList()
require.NoError(t, err)
require.Equal(t, &defs.APIRTSPSessionList{
Items: []defs.APIRTSPSession{
{
ID: list.Items[0].ID,
Created: list.Items[0].Created,
RemoteAddr: list.Items[0].RemoteAddr,
State: "publish",
Path: "teststream",
Query: "param=value",
User: "myuser",
InboundBytes: list.Items[0].InboundBytes,
InboundRTPPackets: list.Items[0].InboundRTPPackets,
OutboundBytes: list.Items[0].OutboundBytes,
BytesReceived: list.Items[0].BytesReceived,
BytesSent: list.Items[0].BytesSent,
Conns: list.Items[0].Conns,
RTPPacketsReceived: list.Items[0].RTPPacketsReceived,
Transport: ptrOf("TCP"),
Profile: ptrOf("AVP"),
},
},
}, list)
})
}
}
func TestServerPublishMPEGTS(t *testing.T) {
var strm *stream.Stream
var reader *stream.Reader
defer func() {
if strm != nil && reader != nil {
strm.RemoveReader(reader)
}
}()
dataReceived := make(chan struct{})
pathConf := &conf.Path{RTSPDemuxMpegts: true}
pathManager := &test.PathManager{
FindPathConfImpl: func(req defs.PathFindPathConfReq) (*defs.PathFindPathConfRes, error) {
require.Equal(t, "teststream", req.AccessRequest.Name)
require.Equal(t, "param=value", req.AccessRequest.Query)
return &defs.PathFindPathConfRes{Conf: pathConf}, nil
},
AddPublisherImpl: func(req defs.PathAddPublisherReq) (*defs.PathAddPublisherRes, error) {
require.Equal(t, "teststream", req.AccessRequest.Name)
require.Equal(t, "param=value", req.AccessRequest.Query)
require.True(t, req.AccessRequest.SkipAuth)
require.False(t, req.UseRTPPackets)
require.True(t, req.ReplaceNTP)
require.Same(t, pathConf, req.ConfToCompare)
require.Equal(t, &description.Session{Medias: []*description.Media{{
Type: description.MediaTypeVideo,
Formats: []format.Format{&format.H264{
PayloadTyp: 96,
PacketizationMode: 1,
}},
}}}, req.Desc)
strm = &stream.Stream{
Desc: req.Desc,
WriteQueueSize: 512,
RTPMaxPayloadSize: 1450,
Parent: test.NilLogger,
}
err := strm.Initialize()
require.NoError(t, err)
subStream := &stream.SubStream{
Stream: strm,
UseRTPPackets: false,
}
err = subStream.Initialize()
require.NoError(t, err)
reader = &stream.Reader{Parent: test.NilLogger}
n := 0
reader.OnData(
strm.Desc.Medias[0],
strm.Desc.Medias[0].Formats[0],
func(u *unit.Unit) error {
if n == 0 {
require.Equal(t, unit.PayloadH264{
test.FormatH264.SPS,
test.FormatH264.PPS,
{5, 1},
}, u.Payload)
close(dataReceived)
}
n++
return nil
})
strm.AddReader(reader)
return &defs.PathAddPublisherRes{Path: &dummyPath{}, SubStream: subStream}, nil
},
}
s := &Server{
Address: "127.0.0.1:8557",
ReadTimeout: conf.Duration(10 * time.Second),
WriteTimeout: conf.Duration(10 * time.Second),
WriteQueueSize: 512,
Transports: conf.RTSPTransports{gortsplib.ProtocolTCP: {}},
PathManager: pathManager,
Parent: test.NilLogger,
}
err := s.Initialize()
require.NoError(t, err)
defer s.Close()
source := gortsplib.Client{}
media0 := &description.Media{
Type: description.MediaTypeApplication,
Formats: []format.Format{&format.MPEGTS{}},
}
err = source.StartRecording(
"rtsp://127.0.0.1:8557/teststream?param=value",
&description.Session{Medias: []*description.Media{media0}})
require.NoError(t, err)
defer source.Close()
track := &mpegts.Track{Codec: &tscodecs.H264{}}
var buf bytes.Buffer
bw := bufio.NewWriter(&buf)
w := &mpegts.Writer{W: bw, Tracks: []*mpegts.Track{track}}
err = w.Initialize()
require.NoError(t, err)
// the MPEG-TS muxer needs two PES packets in order to write the first one
err = w.WriteH264(track, 0, 0, [][]byte{
test.FormatH264.SPS,
test.FormatH264.PPS,
{5, 1},
})
require.NoError(t, err)
err = w.WriteH264(track, 0, 0, [][]byte{{5, 2}})
require.NoError(t, err)
err = bw.Flush()
require.NoError(t, err)
raw := buf.Bytes()
require.NotEmpty(t, raw)
require.Zero(t, len(raw)%188)
tsPackets := make([][]byte, 0, len(raw)/188)
for len(raw) > 0 {
tsPackets = append(tsPackets, raw[:188:188])
raw = raw[188:]
}
encoder, err := media0.Formats[0].(*format.MPEGTS).CreateEncoder()
require.NoError(t, err)
rtpPackets, err := encoder.Encode(tsPackets)
require.NoError(t, err)
for _, pkt := range rtpPackets {
err = source.WritePacketRTP(media0, pkt)
require.NoError(t, err)
}
<-dataReceived
}
func TestServerRead(t *testing.T) {
for _, ca := range []string{"basic", "digest", "basic+digest"} {
t.Run(ca, func(t *testing.T) {
desc := &description.Session{Medias: []*description.Media{test.MediaH264}}
strm := &stream.Stream{
Desc: desc,
WriteQueueSize: 512,
RTPMaxPayloadSize: 1450,
Parent: test.NilLogger,
}
err := strm.Initialize()
require.NoError(t, err)
subStream := &stream.SubStream{
Stream: strm,
UseRTPPackets: false,
}
err = subStream.Initialize()
require.NoError(t, err)
n := 0
pathManager := &test.PathManager{
DescribeImpl: func(req defs.PathDescribeReq) defs.PathDescribeRes {
require.Equal(t, "teststream", req.AccessRequest.Name)
require.Equal(t, "param=value", req.AccessRequest.Query)
if ca == "basic" {
require.Nil(t, req.AccessRequest.CustomVerifyFunc)
if req.AccessRequest.Credentials.User == "" && req.AccessRequest.Credentials.Pass == "" {
return defs.PathDescribeRes{Err: &auth.Error{AskCredentials: true, Wrapped: fmt.Errorf("auth error")}}
}
require.Equal(t, "myuser", req.AccessRequest.Credentials.User)
require.Equal(t, "mypass", req.AccessRequest.Credentials.Pass)
} else {
ok := req.AccessRequest.CustomVerifyFunc("myuser", "mypass")
if n == 0 {
require.False(t, ok)
n++
return defs.PathDescribeRes{Err: &auth.Error{AskCredentials: true, Wrapped: fmt.Errorf("auth error")}}
}
require.True(t, ok)
}
return defs.PathDescribeRes{
Path: &dummyPath{},
Stream: strm,
Err: nil,
}
},
AddReaderImpl: func(req defs.PathAddReaderReq) (*defs.PathAddReaderRes, error) {
require.Equal(t, "teststream", req.AccessRequest.Name)
require.Equal(t, "param=value", req.AccessRequest.Query)
if ca == "basic" {
require.Nil(t, req.AccessRequest.CustomVerifyFunc)
require.Equal(t, "myuser", req.AccessRequest.Credentials.User)
require.Equal(t, "mypass", req.AccessRequest.Credentials.Pass)
} else {
ok := req.AccessRequest.CustomVerifyFunc("myuser", "mypass")
require.True(t, ok)
}
return &defs.PathAddReaderRes{Path: &dummyPath{}, User: req.AccessRequest.Credentials.User, Stream: strm}, nil
},
}
var authMethods []rtspauth.VerifyMethod
switch ca {
case "basic":
authMethods = []rtspauth.VerifyMethod{rtspauth.VerifyMethodBasic}
case "digest":
authMethods = []rtspauth.VerifyMethod{rtspauth.VerifyMethodDigestMD5}
default:
authMethods = []rtspauth.VerifyMethod{rtspauth.VerifyMethodBasic, rtspauth.VerifyMethodDigestMD5}
}
s := &Server{
Address: "127.0.0.1:8557",
AuthMethods: authMethods,
ReadTimeout: conf.Duration(10 * time.Second),
WriteTimeout: conf.Duration(10 * time.Second),
WriteQueueSize: 512,
Transports: conf.RTSPTransports{gortsplib.ProtocolTCP: {}},
PathManager: pathManager,
Parent: test.NilLogger,
}
err = s.Initialize()
require.NoError(t, err)
defer s.Close()
u, err := base.ParseURL("rtsp://myuser:mypass@127.0.0.1:8557/teststream?param=value")
require.NoError(t, err)
reader := gortsplib.Client{
Scheme: u.Scheme,
Host: u.Host,
}
err = reader.Start()
require.NoError(t, err)
defer reader.Close()
desc2, _, err := reader.Describe(u)
require.NoError(t, err)
err = reader.SetupAll(desc2.BaseURL, desc2.Medias)
require.NoError(t, err)
recv := make(chan struct{})
reader.OnPacketRTPAny(func(_ *description.Media, _ format.Format, p *rtp.Packet) {
require.Equal(t, &rtp.Packet{
Header: rtp.Header{
Version: 2,
Marker: true,
PayloadType: 96,
SequenceNumber: p.SequenceNumber,
Timestamp: p.Timestamp,
SSRC: p.SSRC,
},
Payload: []byte{
0x18, 0x00, 0x19, 0x67, 0x42, 0xc0, 0x28, 0xd9,
0x00, 0x78, 0x02, 0x27, 0xe5, 0x84, 0x00, 0x00,
0x03, 0x00, 0x04, 0x00, 0x00, 0x03, 0x00, 0xf0,
0x3c, 0x60, 0xc9, 0x20, 0x00, 0x04, 0x08, 0x06,
0x07, 0x08, 0x00, 0x04, 0x05, 0x02, 0x03, 0x04,
},
}, p)
close(recv)
})
_, err = reader.Play(nil)
require.NoError(t, err)
subStream.WriteUnit(desc.Medias[0], desc.Medias[0].Formats[0], &unit.Unit{
NTP: time.Time{},
Payload: unit.PayloadH264{
{5, 2, 3, 4}, // IDR
},
})
<-recv
list, err := s.APISessionsList()
require.NoError(t, err)
require.Equal(t, &defs.APIRTSPSessionList{
Items: []defs.APIRTSPSession{
{
ID: list.Items[0].ID,
Created: list.Items[0].Created,
RemoteAddr: list.Items[0].RemoteAddr,
State: "read",
Path: "teststream",
Query: "param=value",
User: "myuser",
InboundBytes: list.Items[0].InboundBytes,
InboundRTPPackets: list.Items[0].InboundRTPPackets,
OutboundBytes: list.Items[0].OutboundBytes,
OutboundRTPPackets: list.Items[0].OutboundRTPPackets,
BytesReceived: list.Items[0].BytesReceived,
BytesSent: list.Items[0].BytesSent,
Conns: list.Items[0].Conns,
RTPPacketsReceived: list.Items[0].RTPPacketsReceived,
RTPPacketsSent: list.Items[0].RTPPacketsSent,
Transport: ptrOf("TCP"),
Profile: ptrOf("AVP"),
},
},
}, list)
})
}
}
func TestServerRedirect(t *testing.T) {
for _, ca := range []string{"relative", "absolute"} {
t.Run(ca, func(t *testing.T) {
desc := &description.Session{Medias: []*description.Media{test.MediaH264}}
strm := &stream.Stream{
Desc: desc,
WriteQueueSize: 512,
RTPMaxPayloadSize: 1450,
Parent: test.NilLogger,
}
err := strm.Initialize()
require.NoError(t, err)
subStream := &stream.SubStream{
Stream: strm,
UseRTPPackets: true,
}
err = subStream.Initialize()
require.NoError(t, err)
pathManager := &test.PathManager{
DescribeImpl: func(req defs.PathDescribeReq) defs.PathDescribeRes {
if req.AccessRequest.Name == "path1" {
if ca == "relative" {
return defs.PathDescribeRes{
Redirect: "/path2",
}
}
return defs.PathDescribeRes{
Redirect: "rtsp://localhost:8557/path2",
}
}
if req.AccessRequest.Credentials.User == "" && req.AccessRequest.Credentials.Pass == "" {
return defs.PathDescribeRes{Err: &auth.Error{AskCredentials: true, Wrapped: fmt.Errorf("auth error")}}
}
require.Equal(t, "path2", req.AccessRequest.Name)
require.Equal(t, "", req.AccessRequest.Query)
require.Equal(t, "myuser", req.AccessRequest.Credentials.User)
require.Equal(t, "mypass", req.AccessRequest.Credentials.Pass)
return defs.PathDescribeRes{
Path: &dummyPath{},
Stream: strm,
}
},
}
s := &Server{
Address: "127.0.0.1:8557",
AuthMethods: []rtspauth.VerifyMethod{rtspauth.VerifyMethodBasic},
ReadTimeout: conf.Duration(10 * time.Second),
WriteTimeout: conf.Duration(10 * time.Second),
WriteQueueSize: 512,
Transports: conf.RTSPTransports{gortsplib.ProtocolTCP: {}},
PathManager: pathManager,
Parent: test.NilLogger,
}
err = s.Initialize()
require.NoError(t, err)
defer s.Close()
u, err := base.ParseURL("rtsp://myuser:mypass@127.0.0.1:8557/path1?param=value")
require.NoError(t, err)
reader := gortsplib.Client{
Scheme: u.Scheme,
Host: u.Host,
}
err = reader.Start()
require.NoError(t, err)
defer reader.Close()
desc2, _, err := reader.Describe(u)
require.NoError(t, err)
require.Equal(t, desc.Medias[0].Formats, desc2.Medias[0].Formats)
})
}
}
func TestAuthError(t *testing.T) {
pathManager := &test.PathManager{
DescribeImpl: func(req defs.PathDescribeReq) defs.PathDescribeRes {
if req.AccessRequest.Credentials.User == "" && req.AccessRequest.Credentials.Pass == "" {
return defs.PathDescribeRes{Err: &auth.Error{AskCredentials: true, Wrapped: fmt.Errorf("auth error")}}
}
return defs.PathDescribeRes{Err: &auth.Error{Wrapped: fmt.Errorf("auth error")}}
},
}
n := new(int64)
done := make(chan struct{})
s := &Server{
Address: "127.0.0.1:8557",
ReadTimeout: conf.Duration(10 * time.Second),
WriteTimeout: conf.Duration(10 * time.Second),
WriteQueueSize: 512,
PathManager: pathManager,
Parent: test.Logger(func(l logger.Level, s string, i ...any) {
if l == logger.Info {
if atomic.AddInt64(n, 1) == 3 {
require.Regexp(t, "authentication failed: auth error$", fmt.Sprintf(s, i...))
close(done)
}
}
}),
}
err := s.Initialize()
require.NoError(t, err)
defer s.Close()
u, err := base.ParseURL("rtsp://myuser:mypass@127.0.0.1:8557/teststream?param=value")
require.NoError(t, err)
reader := gortsplib.Client{
Scheme: u.Scheme,
Host: u.Host,
}
err = reader.Start()
require.NoError(t, err)
defer reader.Close()
_, _, err = reader.Describe(u)
require.EqualError(t, err, "bad status code: 401 (Unauthorized)")
<-done
}
================================================
FILE: internal/servers/rtsp/session.go
================================================
package rtsp
import (
"encoding/hex"
"errors"
"fmt"
"net"
"slices"
"sync"
"time"
"github.com/bluenviron/gortsplib/v5"
rtspauth "github.com/bluenviron/gortsplib/v5/pkg/auth"
"github.com/bluenviron/gortsplib/v5/pkg/base"
"github.com/bluenviron/gortsplib/v5/pkg/description"
"github.com/bluenviron/gortsplib/v5/pkg/format"
"github.com/bluenviron/gortsplib/v5/pkg/headers"
"github.com/google/uuid"
"github.com/bluenviron/mediamtx/internal/auth"
"github.com/bluenviron/mediamtx/internal/conf"
"github.com/bluenviron/mediamtx/internal/counterdumper"
"github.com/bluenviron/mediamtx/internal/defs"
"github.com/bluenviron/mediamtx/internal/errordumper"
"github.com/bluenviron/mediamtx/internal/externalcmd"
"github.com/bluenviron/mediamtx/internal/hooks"
"github.com/bluenviron/mediamtx/internal/logger"
"github.com/bluenviron/mediamtx/internal/protocols/rtsp"
"github.com/bluenviron/mediamtx/internal/stream"
)
func profileLabel(p headers.TransportProfile) string {
switch p {
case headers.TransportProfileSAVP:
return "SAVP"
case headers.TransportProfileAVP:
return "AVP"
}
return "unknown"
}
func findSingleMPEGTSFormat(desc *description.Session) (*description.Media, *format.MPEGTS) {
if len(desc.Medias) != 1 || len(desc.Medias[0].Formats) != 1 {
return nil, nil
}
forma := desc.Medias[0].Formats[0]
if forma, ok := forma.(*format.MPEGTS); ok {
return desc.Medias[0], forma
}
return nil, nil
}
type sessionParent interface {
logger.Writer
getConnByRConnUnsafe(rconn *gortsplib.ServerConn) *conn
}
type session struct {
isTLS bool
transports conf.RTSPTransports
rsession *gortsplib.ServerSession
rconn *gortsplib.ServerConn
rserver *gortsplib.Server
externalCmdPool *externalcmd.Pool
pathManager serverPathManager
parent sessionParent
uuid uuid.UUID
created time.Time
pathConf *conf.Path // record only
path defs.Path
stream *stream.Stream
subStream *stream.SubStream
onUnreadHook func()
inboundRTPPacketsLost *counterdumper.Dumper
inboundRTPPacketsInError *errordumper.Dumper
outboundRTPPacketsDiscarded *counterdumper.Dumper
mutex sync.RWMutex
user string
mpegtsDemuxer *mpegtsDemuxer
}
func (s *session) initialize() {
s.uuid = uuid.New()
s.created = time.Now()
s.inboundRTPPacketsLost = &counterdumper.Dumper{
OnReport: func(val uint64) {
s.Log(logger.Warn, "%d RTP %s lost",
val,
func() string {
if val == 1 {
return "packet"
}
return "packets"
}())
},
}
s.inboundRTPPacketsLost.Start()
s.inboundRTPPacketsInError = &errordumper.Dumper{
OnReport: func(val uint64, last error) {
if val == 1 {
s.Log(logger.Warn, "decode error: %v", last)
} else {
s.Log(logger.Warn, "%d decode errors, last was: %v", val, last)
}
},
}
s.inboundRTPPacketsInError.Start()
s.outboundRTPPacketsDiscarded = &counterdumper.Dumper{
OnReport: func(val uint64) {
s.Log(logger.Warn, "reader is too slow, discarding %d %s",
val,
func() string {
if val == 1 {
return "frame"
}
return "frames"
}())
},
}
s.outboundRTPPacketsDiscarded.Start()
s.Log(logger.Info, "created by %v", s.rconn.NetConn().RemoteAddr())
}
// Close closes a Session.
// this is not always called, so things that need to be released
// must go in onClose().
func (s *session) Close() {
s.rsession.Close()
}
func (s *session) remoteAddr() net.Addr {
return s.rconn.NetConn().RemoteAddr()
}
// Log implements logger.Writer.
func (s *session) Log(level logger.Level, format string, args ...any) {
id := hex.EncodeToString(s.uuid[:4])
s.parent.Log(level, "[session %s] "+format, append([]any{id}, args...)...)
}
// onClose is called by rtspServer.
func (s *session) onClose(err error) {
if s.rsession.State() == gortsplib.ServerSessionStatePlay {
s.onUnreadHook()
}
if s.mpegtsDemuxer != nil {
s.mpegtsDemuxer.close()
}
switch s.rsession.State() {
case gortsplib.ServerSessionStatePrePlay, gortsplib.ServerSessionStatePlay:
s.path.RemoveReader(defs.PathRemoveReaderReq{Author: s})
case gortsplib.ServerSessionStateRecord:
if s.path != nil {
s.path.RemovePublisher(defs.PathRemovePublisherReq{Author: s})
}
}
s.path = nil
s.stream = nil
s.subStream = nil
s.outboundRTPPacketsDiscarded.Stop()
s.inboundRTPPacketsInError.Stop()
s.inboundRTPPacketsLost.Stop()
s.Log(logger.Info, "destroyed: %v", err)
}
// onAnnounce is called by rtspServer.
func (s *session) onAnnounce(c *conn, ctx *gortsplib.ServerHandlerOnAnnounceCtx) (*base.Response, error) {
if len(ctx.Path) == 0 || ctx.Path[0] != '/' {
return &base.Response{
StatusCode: base.StatusBadRequest,
}, fmt.Errorf("invalid path")
}
ctx.Path = ctx.Path[1:]
// CustomVerifyFunc prevents hashed credentials from working.
// Use it only when strictly needed.
var customVerifyFunc func(expectedUser, expectedPass string) bool
if slices.Contains(c.authMethods, rtspauth.VerifyMethodDigestMD5) {
customVerifyFunc = func(expectedUser, expectedPass string) bool {
return c.rconn.VerifyCredentials(ctx.Request, expectedUser, expectedPass)
}
}
res, err := s.pathManager.FindPathConf(defs.PathFindPathConfReq{
AccessRequest: defs.PathAccessRequest{
Name: ctx.Path,
Query: ctx.Query,
Publish: true,
Proto: auth.ProtocolRTSP,
ID: &c.uuid,
Credentials: rtsp.Credentials(ctx.Request),
IP: c.ip(),
CustomVerifyFunc: customVerifyFunc,
},
})
if err != nil {
var terr *auth.Error
if errors.As(err, &terr) {
return c.handleAuthError(terr)
}
return &base.Response{
StatusCode: base.StatusBadRequest,
}, err
}
s.pathConf = res.Conf
s.mutex.Lock()
s.user = res.User
s.mutex.Unlock()
return &base.Response{
StatusCode: base.StatusOK,
}, nil
}
func (s *session) rtspStream() *gortsplib.ServerStream {
if !s.isTLS {
return s.stream.RTSPStream(s.rserver)
}
return s.stream.RTSPSStream(s.rserver)
}
// onSetup is called by rtspServer.
func (s *session) onSetup(c *conn, ctx *gortsplib.ServerHandlerOnSetupCtx,
) (*base.Response, *gortsplib.ServerStream, error) {
if len(ctx.Path) == 0 || ctx.Path[0] != '/' {
return &base.Response{
StatusCode: base.StatusBadRequest,
}, nil, fmt.Errorf("invalid path")
}
ctx.Path = ctx.Path[1:]
// in case the client is setupping a stream with UDP or UDP-multicast, and these
// transport protocols are disabled, gortsplib already blocks the request.
// we only have to handle the case in which the transport protocol is TCP
// and it is disabled.
if ctx.Transport.Protocol == gortsplib.ProtocolTCP {
if _, ok := s.transports[gortsplib.ProtocolTCP]; !ok {
return &base.Response{
StatusCode: base.StatusUnsupportedTransport,
}, nil, nil
}
}
// CustomVerifyFunc prevents hashed credentials from working.
// Use it only when strictly needed.
var customVerifyFunc func(expectedUser, expectedPass string) bool
if slices.Contains(c.authMethods, rtspauth.VerifyMethodDigestMD5) {
customVerifyFunc = func(expectedUser, expectedPass string) bool {
return c.rconn.VerifyCredentials(ctx.Request, expectedUser, expectedPass)
}
}
switch s.rsession.State() {
case gortsplib.ServerSessionStateInitial: // play
res, err := s.pathManager.AddReader(defs.PathAddReaderReq{
Author: s,
AccessRequest: defs.PathAccessRequest{
Name: ctx.Path,
Query: ctx.Query,
Proto: auth.ProtocolRTSP,
ID: &c.uuid,
Credentials: rtsp.Credentials(ctx.Request),
IP: c.ip(),
CustomVerifyFunc: customVerifyFunc,
},
})
if err != nil {
var terr *auth.Error
if errors.As(err, &terr) {
res, err2 := c.handleAuthError(terr)
return res, nil, err2
}
var terr2 defs.PathNoStreamAvailableError
if errors.As(err, &terr2) {
return &base.Response{
StatusCode: base.StatusNotFound,
}, nil, err
}
return &base.Response{
StatusCode: base.StatusBadRequest,
}, nil, err
}
s.path = res.Path
s.stream = res.Stream
s.mutex.Lock()
s.user = res.User
s.mutex.Unlock()
return &base.Response{
StatusCode: base.StatusOK,
}, s.rtspStream(), nil
case gortsplib.ServerSessionStatePrePlay: // play, subsequent calls
return &base.Response{
StatusCode: base.StatusOK,
}, s.rtspStream(), nil
default: // record
return &base.Response{
StatusCode: base.StatusOK,
}, nil, nil
}
}
// onPlay is called by rtspServer.
func (s *session) onPlay(_ *gortsplib.ServerHandlerOnPlayCtx) (*base.Response, error) {
h := make(base.Header)
if s.rsession.State() == gortsplib.ServerSessionStatePrePlay {
s.Log(logger.Info, "is reading from path '%s', with %s, %s",
s.path.Name(),
s.rsession.Transport().Protocol,
defs.MediasInfo(s.rsession.Medias()))
s.onUnreadHook = hooks.OnRead(hooks.OnReadParams{
Logger: s,
ExternalCmdPool: s.externalCmdPool,
Conf: s.path.SafeConf(),
ExternalCmdEnv: s.path.ExternalCmdEnv(),
Reader: *s.APIReaderDescribe(),
Query: s.rsession.Query(),
})
}
return &base.Response{
StatusCode: base.StatusOK,
Header: h,
}, nil
}
// onRecord is called by rtspServer.
func (s *session) onRecord(_ *gortsplib.ServerHandlerOnRecordCtx) (*base.Response, error) {
if s.pathConf.RTSPDemuxMpegts {
mpegtsMedia, mpegtsFormat := findSingleMPEGTSFormat(s.rsession.AnnouncedDescription())
if mpegtsFormat != nil {
s.Log(logger.Info, "MPEG-TS demux mode enabled, starting demuxer...")
s.mpegtsDemuxer = &mpegtsDemuxer{
session: s,
pathManager: s.pathManager,
pathConf: s.pathConf,
mpegtsMedia: mpegtsMedia,
mpegtsFormat: mpegtsFormat,
decodeErrors: s.inboundRTPPacketsInError,
pathName: s.rsession.Path()[1:],
query: s.rsession.Query(),
}
err := s.mpegtsDemuxer.initialize()
if err != nil {
return &base.Response{
StatusCode: base.StatusInternalServerError,
}, err
}
return &base.Response{
StatusCode: base.StatusOK,
}, nil
}
}
res, err := s.pathManager.AddPublisher(defs.PathAddPublisherReq{
Author: s,
Desc: s.rsession.AnnouncedDescription(),
UseRTPPackets: true,
ReplaceNTP: !s.pathConf.UseAbsoluteTimestamp,
ConfToCompare: s.pathConf,
AccessRequest: defs.PathAccessRequest{
Name: s.rsession.Path()[1:],
Query: s.rsession.Query(),
Publish: true,
SkipAuth: true,
},
})
if err != nil {
return &base.Response{
StatusCode: base.StatusBadRequest,
}, err
}
rtsp.ToStream(
s.rsession,
s.rsession.AnnouncedDescription().Medias,
res.Path.SafeConf(),
&s.subStream,
s)
s.path = res.Path
s.subStream = res.SubStream
return &base.Response{
StatusCode: base.StatusOK,
}, nil
}
// onPause is called by rtspServer.
func (s *session) onPause(_ *gortsplib.ServerHandlerOnPauseCtx) (*base.Response, error) {
// we can't close mpegtsDemuxer during pause because OnPacketRTP() is paused after onPause(),
// therefore a call to pipeWriter.CloseWithError() would cause a race condition.
if s.mpegtsDemuxer != nil {
return &base.Response{
StatusCode: base.StatusBadRequest,
}, fmt.Errorf("cannot pause in MPEG-TS demux mode")
}
switch s.rsession.State() {
case gortsplib.ServerSessionStatePlay:
s.onUnreadHook()
case gortsplib.ServerSessionStateRecord:
s.path.RemovePublisher(defs.PathRemovePublisherReq{Author: s})
}
return &base.Response{
StatusCode: base.StatusOK,
}, nil
}
// APIReaderDescribe implements reader.
func (s *session) APIReaderDescribe() *defs.APIPathReader {
return &defs.APIPathReader{
Type: func() defs.APIPathReaderType {
if s.isTLS {
return defs.APIPathReaderTypeRTSPSSession
}
return defs.APIPathReaderTypeRTSPSession
}(),
ID: s.uuid.String(),
}
}
// APISourceDescribe implements source.
func (s *session) APISourceDescribe() *defs.APIPathSource {
return &defs.APIPathSource{
Type: func() defs.APIPathSourceType {
if s.isTLS {
return defs.APIPathSourceTypeRTSPSSession
}
return defs.APIPathSourceTypeRTSPSession
}(),
ID: s.uuid.String(),
}
}
// onPacketLost is called by rtspServer.
func (s *session) onPacketsLost(ctx *gortsplib.ServerHandlerOnPacketsLostCtx) {
s.inboundRTPPacketsLost.Add(ctx.Lost)
}
// onDecodeError is called by rtspServer.
func (s *session) onDecodeError(ctx *gortsplib.ServerHandlerOnDecodeErrorCtx) {
s.inboundRTPPacketsInError.Add(ctx.Error)
}
// onStreamWriteError is called by rtspServer.
func (s *session) onStreamWriteError(_ *gortsplib.ServerHandlerOnStreamWriteErrorCtx) {
// currently the only error returned by OnStreamWriteError is ErrServerWriteQueueFull
s.outboundRTPPacketsDiscarded.Increase()
}
func (s *session) apiItem() *defs.APIRTSPSession {
stats := s.rsession.Stats()
s.mutex.RLock()
defer s.mutex.RUnlock()
return &defs.APIRTSPSession{
ID: s.uuid,
Created: s.created,
RemoteAddr: s.remoteAddr().String(),
State: func() defs.APIRTSPSessionState {
state := s.rsession.State()
switch state {
case gortsplib.ServerSessionStatePlay:
return defs.APIRTSPSessionStateRead
case gortsplib.ServerSessionStateRecord:
return defs.APIRTSPSessionStatePublish
default:
return defs.APIRTSPSessionStateIdle
}
}(),
Path: func() string {
pa := s.rsession.Path()
if len(pa) >= 1 {
return pa[1:]
}
return ""
}(),
Query: s.rsession.Query(),
User: s.user,
Transport: func() *string {
transport := s.rsession.Transport()
if transport == nil {
return nil
}
v := transport.Protocol.String()
return &v
}(),
Profile: func() *string {
transport := s.rsession.Transport()
if transport == nil {
return nil
}
v := profileLabel(transport.Profile)
return &v
}(),
Conns: func() []uuid.UUID {
ret := []uuid.UUID{}
for _, rconn := range s.rsession.Conns() {
conn := s.parent.getConnByRConnUnsafe(rconn)
if conn != nil {
ret = append(ret, conn.uuid)
}
}
return ret
}(),
InboundBytes: stats.InboundBytes,
InboundRTPPackets: stats.InboundRTPPackets,
InboundRTPPacketsLost: stats.InboundRTPPacketsLost,
InboundRTPPacketsInError: stats.InboundRTPPacketsInError,
InboundRTPPacketsJitter: stats.InboundRTPPacketsJitter,
InboundRTCPPackets: stats.InboundRTCPPackets,
InboundRTCPPacketsInError: stats.InboundRTCPPacketsInError,
OutboundBytes: stats.OutboundBytes,
OutboundRTPPackets: stats.OutboundRTPPackets,
OutboundRTPPacketsReportedLost: stats.OutboundRTPPacketsReportedLost,
OutboundRTPPacketsDiscarded: s.outboundRTPPacketsDiscarded.Get(),
OutboundRTCPPackets: stats.OutboundRTCPPackets,
BytesReceived: stats.InboundBytes,
BytesSent: stats.OutboundBytes,
RTPPacketsReceived: stats.InboundRTPPackets,
RTPPacketsSent: stats.OutboundRTPPackets,
RTPPacketsLost: stats.InboundRTPPacketsLost,
RTPPacketsInError: stats.InboundRTPPacketsInError,
RTPPacketsJitter: stats.InboundRTPPacketsJitter,
RTCPPacketsReceived: stats.InboundRTCPPackets,
RTCPPacketsSent: stats.OutboundRTCPPackets,
RTCPPacketsInError: stats.InboundRTCPPacketsInError,
}
}
================================================
FILE: internal/servers/srt/conn.go
================================================
package srt
import (
"bufio"
"context"
"errors"
"fmt"
"net"
"sync"
"time"
"github.com/bluenviron/gortsplib/v5/pkg/description"
srt "github.com/datarhei/gosrt"
"github.com/google/uuid"
"github.com/bluenviron/mediamtx/internal/auth"
"github.com/bluenviron/mediamtx/internal/conf"
"github.com/bluenviron/mediamtx/internal/defs"
"github.com/bluenviron/mediamtx/internal/errordumper"
"github.com/bluenviron/mediamtx/internal/externalcmd"
"github.com/bluenviron/mediamtx/internal/hooks"
"github.com/bluenviron/mediamtx/internal/logger"
"github.com/bluenviron/mediamtx/internal/protocols/mpegts"
"github.com/bluenviron/mediamtx/internal/stream"
)
func srtCheckPassphrase(connReq srt.ConnRequest, passphrase string) error {
if passphrase == "" {
return nil
}
if !connReq.IsEncrypted() {
return fmt.Errorf("connection is encrypted, but not passphrase is defined in configuration")
}
err := connReq.SetPassphrase(passphrase)
if err != nil {
return fmt.Errorf("invalid passphrase")
}
return nil
}
type conn struct {
parentCtx context.Context
rtspAddress string
readTimeout conf.Duration
writeTimeout conf.Duration
udpMaxPayloadSize int
connReq srt.ConnRequest
runOnConnect string
runOnConnectRestart bool
runOnDisconnect string
wg *sync.WaitGroup
externalCmdPool *externalcmd.Pool
pathManager serverPathManager
parent *Server
ctx context.Context
ctxCancel func()
created time.Time
uuid uuid.UUID
mutex sync.RWMutex
state defs.APISRTConnState
pathName string
query string
user string
sconn srt.Conn
reader *stream.Reader
}
func (c *conn) initialize() {
c.ctx, c.ctxCancel = context.WithCancel(c.parentCtx)
c.created = time.Now()
c.uuid = uuid.New()
c.state = defs.APISRTConnStateIdle
c.Log(logger.Info, "opened")
c.wg.Add(1)
go c.run()
}
func (c *conn) Close() {
c.ctxCancel()
}
// Log implements logger.Writer.
func (c *conn) Log(level logger.Level, format string, args ...any) {
c.parent.Log(level, "[conn %v] "+format, append([]any{c.connReq.RemoteAddr()}, args...)...)
}
func (c *conn) ip() net.IP {
return c.connReq.RemoteAddr().(*net.UDPAddr).IP
}
func (c *conn) run() { //nolint:dupl
defer c.wg.Done()
onDisconnectHook := hooks.OnConnect(hooks.OnConnectParams{
Logger: c,
ExternalCmdPool: c.externalCmdPool,
RunOnConnect: c.runOnConnect,
RunOnConnectRestart: c.runOnConnectRestart,
RunOnDisconnect: c.runOnDisconnect,
RTSPAddress: c.rtspAddress,
Desc: *c.APIReaderDescribe(),
})
defer onDisconnectHook()
err := c.runInner()
c.ctxCancel()
c.parent.closeConn(c)
c.Log(logger.Info, "closed: %v", err)
}
func (c *conn) runInner() error {
var streamID streamID
err := streamID.unmarshal(c.connReq.StreamId())
if err != nil {
c.connReq.Reject(srt.REJ_PEER)
return fmt.Errorf("invalid stream ID '%s': %w", c.connReq.StreamId(), err)
}
if streamID.mode == streamIDModePublish {
return c.runPublish(&streamID)
}
return c.runRead(&streamID)
}
func (c *conn) runPublish(streamID *streamID) error {
res, err := c.pathManager.FindPathConf(defs.PathFindPathConfReq{
AccessRequest: defs.PathAccessRequest{
Name: streamID.path,
Query: streamID.query,
Publish: true,
Proto: auth.ProtocolSRT,
ID: &c.uuid,
Credentials: &auth.Credentials{
User: streamID.user,
Pass: streamID.pass,
},
IP: c.ip(),
},
})
if err != nil {
var terr *auth.Error
if errors.As(err, &terr) {
// wait some seconds to delay brute force attacks
<-time.After(auth.PauseAfterError)
c.connReq.Reject(srt.REJ_PEER)
return terr
}
c.connReq.Reject(srt.REJ_PEER)
return err
}
c.mutex.Lock()
c.user = res.User
c.mutex.Unlock()
err = srtCheckPassphrase(c.connReq, res.Conf.SRTPublishPassphrase)
if err != nil {
c.connReq.Reject(srt.REJ_PEER)
return err
}
sconn, err := c.connReq.Accept()
if err != nil {
return err
}
readerErr := make(chan error)
go func() {
readerErr <- c.runPublishReader(sconn, streamID, res.Conf)
}()
select {
case err = <-readerErr:
sconn.Close()
return err
case <-c.ctx.Done():
sconn.Close()
<-readerErr
return errors.New("terminated")
}
}
func (c *conn) runPublishReader(sconn srt.Conn, streamID *streamID, pathConf *conf.Path) error {
sconn.SetReadDeadline(time.Now().Add(time.Duration(c.readTimeout)))
r := &mpegts.EnhancedReader{R: sconn}
err := r.Initialize()
if err != nil {
return err
}
decodeErrors := &errordumper.Dumper{
OnReport: func(val uint64, last error) {
if val == 1 {
c.Log(logger.Warn, "decode error: %v", last)
} else {
c.Log(logger.Warn, "%d decode errors, last was: %v", val, last)
}
},
}
decodeErrors.Start()
defer decodeErrors.Stop()
r.OnDecodeError(func(err error) {
decodeErrors.Add(err)
})
var subStream *stream.SubStream
medias, err := mpegts.ToStream(r, &subStream, c)
if err != nil {
return err
}
res, err := c.pathManager.AddPublisher(defs.PathAddPublisherReq{
Author: c,
Desc: &description.Session{Medias: medias},
UseRTPPackets: false,
ReplaceNTP: true,
ConfToCompare: pathConf,
AccessRequest: defs.PathAccessRequest{
Name: streamID.path,
Query: streamID.query,
Publish: true,
SkipAuth: true,
},
})
if err != nil {
return err
}
defer res.Path.RemovePublisher(defs.PathRemovePublisherReq{Author: c})
subStream = res.SubStream
c.mutex.Lock()
c.state = defs.APISRTConnStatePublish
c.pathName = streamID.path
c.query = streamID.query
c.sconn = sconn
c.mutex.Unlock()
for {
err = r.Read()
if err != nil {
return err
}
}
}
func (c *conn) runRead(streamID *streamID) error {
res, err := c.pathManager.AddReader(defs.PathAddReaderReq{
Author: c,
AccessRequest: defs.PathAccessRequest{
Name: streamID.path,
Query: streamID.query,
Proto: auth.ProtocolSRT,
ID: &c.uuid,
Credentials: &auth.Credentials{
User: streamID.user,
Pass: streamID.pass,
},
IP: c.ip(),
},
})
if err != nil {
var terr *auth.Error
if errors.As(err, &terr) {
// wait some seconds to delay brute force attacks
<-time.After(auth.PauseAfterError)
c.connReq.Reject(srt.REJ_PEER)
return terr
}
c.connReq.Reject(srt.REJ_PEER)
return err
}
defer res.Path.RemoveReader(defs.PathRemoveReaderReq{Author: c})
err = srtCheckPassphrase(c.connReq, res.Path.SafeConf().SRTReadPassphrase)
if err != nil {
c.connReq.Reject(srt.REJ_PEER)
return err
}
sconn, err := c.connReq.Accept()
if err != nil {
return err
}
defer sconn.Close()
bw := bufio.NewWriterSize(sconn, srtMaxPayloadSize(c.udpMaxPayloadSize))
r := &stream.Reader{Parent: c}
err = mpegts.FromStream(res.Stream.Desc, r, bw, sconn, time.Duration(c.writeTimeout))
if err != nil {
return err
}
c.mutex.Lock()
c.state = defs.APISRTConnStateRead
c.pathName = streamID.path
c.query = streamID.query
c.user = res.User
c.sconn = sconn
c.mutex.Unlock()
c.Log(logger.Info, "is reading from path '%s', %s",
res.Path.Name(), defs.FormatsInfo(r.Formats()))
onUnreadHook := hooks.OnRead(hooks.OnReadParams{
Logger: c,
ExternalCmdPool: c.externalCmdPool,
Conf: res.Path.SafeConf(),
ExternalCmdEnv: res.Path.ExternalCmdEnv(),
Reader: *c.APIReaderDescribe(),
Query: streamID.query,
})
defer onUnreadHook()
// disable read deadline
sconn.SetReadDeadline(time.Time{})
res.Stream.AddReader(r)
defer res.Stream.RemoveReader(r)
c.mutex.Lock()
c.reader = r
c.mutex.Unlock()
select {
case <-c.ctx.Done():
return fmt.Errorf("terminated")
case err = <-r.Error():
return err
}
}
// APIReaderDescribe implements reader.
func (c *conn) APIReaderDescribe() *defs.APIPathReader {
return &defs.APIPathReader{
Type: defs.APIPathReaderTypeSRTConn,
ID: c.uuid.String(),
}
}
// APISourceDescribe implements source.
func (c *conn) APISourceDescribe() *defs.APIPathSource {
return &defs.APIPathSource{
Type: defs.APIPathSourceTypeSRTConn,
ID: c.uuid.String(),
}
}
func (c *conn) apiItem() *defs.APISRTConn {
c.mutex.RLock()
defer c.mutex.RUnlock()
item := &defs.APISRTConn{
ID: c.uuid,
Created: c.created,
RemoteAddr: c.connReq.RemoteAddr().String(),
State: c.state,
Path: c.pathName,
Query: c.query,
User: c.user,
}
if c.sconn != nil {
var s srt.Statistics
c.sconn.Stats(&s)
item.PacketsSent = s.Accumulated.PktSent
item.PacketsReceived = s.Accumulated.PktRecv
item.PacketsSentUnique = s.Accumulated.PktSentUnique
item.PacketsReceivedUnique = s.Accumulated.PktRecvUnique
item.PacketsSendLoss = s.Accumulated.PktSendLoss
item.PacketsReceivedLoss = s.Accumulated.PktRecvLoss
item.PacketsRetrans = s.Accumulated.PktRetrans
item.PacketsReceivedRetrans = s.Accumulated.PktRecvRetrans
item.PacketsSentACK = s.Accumulated.PktSentACK
item.PacketsReceivedACK = s.Accumulated.PktRecvACK
item.PacketsSentNAK = s.Accumulated.PktSentNAK
item.PacketsReceivedNAK = s.Accumulated.PktRecvNAK
item.PacketsSentKM = s.Accumulated.PktSentKM
item.PacketsReceivedKM = s.Accumulated.PktRecvKM
item.UsSndDuration = s.Accumulated.UsSndDuration
item.PacketsReceivedBelated = s.Accumulated.PktRecvBelated
item.PacketsSendDrop = s.Accumulated.PktSendDrop
item.PacketsReceivedDrop = s.Accumulated.PktRecvDrop
item.PacketsReceivedUndecrypt = s.Accumulated.PktRecvUndecrypt
item.BytesSent = s.Accumulated.ByteSent
item.BytesReceived = s.Accumulated.ByteRecv
item.BytesSentUnique = s.Accumulated.ByteSentUnique
item.BytesReceivedUnique = s.Accumulated.ByteRecvUnique
item.BytesReceivedLoss = s.Accumulated.ByteRecvLoss
item.BytesRetrans = s.Accumulated.ByteRetrans
item.BytesReceivedRetrans = s.Accumulated.ByteRecvRetrans
item.BytesReceivedBelated = s.Accumulated.ByteRecvBelated
item.BytesSendDrop = s.Accumulated.ByteSendDrop
item.BytesReceivedDrop = s.Accumulated.ByteRecvDrop
item.BytesReceivedUndecrypt = s.Accumulated.ByteRecvUndecrypt
item.UsPacketsSendPeriod = s.Instantaneous.UsPktSendPeriod
item.PacketsFlowWindow = s.Instantaneous.PktFlowWindow
item.PacketsFlightSize = s.Instantaneous.PktFlightSize
item.MsRTT = s.Instantaneous.MsRTT
item.MbpsSendRate = s.Instantaneous.MbpsSentRate
item.MbpsReceiveRate = s.Instantaneous.MbpsRecvRate
item.MbpsLinkCapacity = s.Instantaneous.MbpsLinkCapacity
item.BytesAvailSendBuf = s.Instantaneous.ByteAvailSendBuf
item.BytesAvailReceiveBuf = s.Instantaneous.ByteAvailRecvBuf
item.MbpsMaxBW = s.Instantaneous.MbpsMaxBW
item.ByteMSS = s.Instantaneous.ByteMSS
item.PacketsSendBuf = s.Instantaneous.PktSendBuf
item.BytesSendBuf = s.Instantaneous.ByteSendBuf
item.MsSendBuf = s.Instantaneous.MsSendBuf
item.MsSendTsbPdDelay = s.Instantaneous.MsSendTsbPdDelay
item.PacketsReceiveBuf = s.Instantaneous.PktRecvBuf
item.BytesReceiveBuf = s.Instantaneous.ByteRecvBuf
item.MsReceiveBuf = s.Instantaneous.MsRecvBuf
item.MsReceiveTsbPdDelay = s.Instantaneous.MsRecvTsbPdDelay
item.PacketsReorderTolerance = s.Instantaneous.PktReorderTolerance
item.PacketsReceivedAvgBelatedTime = s.Instantaneous.PktRecvAvgBelatedTime
item.PacketsSendLossRate = s.Instantaneous.PktSendLossRate
item.PacketsReceivedLossRate = s.Instantaneous.PktRecvLossRate
}
if c.reader != nil {
item.OutboundFramesDiscarded = c.reader.OutboundFramesDiscarded()
}
return item
}
================================================
FILE: internal/servers/srt/listener.go
================================================
package srt
import (
"sync"
srt "github.com/datarhei/gosrt"
)
type listener struct {
ln srt.Listener
wg *sync.WaitGroup
parent *Server
}
func (l *listener) initialize() {
l.wg.Add(1)
go l.run()
}
func (l *listener) run() {
defer l.wg.Done()
err := l.runInner()
l.parent.acceptError(err)
}
func (l *listener) runInner() error {
for {
req, err := l.ln.Accept2()
if err != nil {
return err
}
l.parent.newConnRequest(req)
}
}
================================================
FILE: internal/servers/srt/server.go
================================================
// Package srt contains a SRT server.
package srt
import (
"context"
"errors"
"fmt"
"reflect"
"sort"
"sync"
"time"
srt "github.com/datarhei/gosrt"
"github.com/google/uuid"
"github.com/bluenviron/mediamtx/internal/conf"
"github.com/bluenviron/mediamtx/internal/defs"
"github.com/bluenviron/mediamtx/internal/externalcmd"
"github.com/bluenviron/mediamtx/internal/logger"
)
// ErrConnNotFound is returned when a connection is not found.
var ErrConnNotFound = errors.New("connection not found")
func interfaceIsEmpty(i any) bool {
return reflect.ValueOf(i).Kind() != reflect.Pointer || reflect.ValueOf(i).IsNil()
}
func srtMaxPayloadSize(u int) int {
return ((u - 16) / 188) * 188 // 16 = SRT header, 188 = MPEG-TS packet
}
type serverAPIConnsListRes struct {
data *defs.APISRTConnList
err error
}
type serverAPIConnsListReq struct {
res chan serverAPIConnsListRes
}
type serverAPIConnsGetRes struct {
data *defs.APISRTConn
err error
}
type serverAPIConnsGetReq struct {
uuid uuid.UUID
res chan serverAPIConnsGetRes
}
type serverAPIConnsKickRes struct {
err error
}
type serverAPIConnsKickReq struct {
uuid uuid.UUID
res chan serverAPIConnsKickRes
}
type serverMetrics interface {
SetSRTServer(defs.APISRTServer)
}
type serverPathManager interface {
FindPathConf(req defs.PathFindPathConfReq) (*defs.PathFindPathConfRes, error)
AddPublisher(req defs.PathAddPublisherReq) (*defs.PathAddPublisherRes, error)
AddReader(req defs.PathAddReaderReq) (*defs.PathAddReaderRes, error)
}
type serverParent interface {
logger.Writer
}
// Server is a SRT server.
type Server struct {
Address string
RTSPAddress string
ReadTimeout conf.Duration
WriteTimeout conf.Duration
UDPMaxPayloadSize int
RunOnConnect string
RunOnConnectRestart bool
RunOnDisconnect string
ExternalCmdPool *externalcmd.Pool
Metrics serverMetrics
PathManager serverPathManager
Parent serverParent
ctx context.Context
ctxCancel func()
wg sync.WaitGroup
ln srt.Listener
conns map[*conn]struct{}
// in
chNewConnRequest chan srt.ConnRequest
chAcceptErr chan error
chCloseConn chan *conn
chAPIConnsList chan serverAPIConnsListReq
chAPIConnsGet chan serverAPIConnsGetReq
chAPIConnsKick chan serverAPIConnsKickReq
}
// Initialize initializes the server.
func (s *Server) Initialize() error {
conf := srt.DefaultConfig()
conf.ConnectionTimeout = time.Duration(s.ReadTimeout)
conf.PeerIdleTimeout = time.Duration(s.ReadTimeout)
conf.PayloadSize = uint32(srtMaxPayloadSize(s.UDPMaxPayloadSize))
var err error
s.ln, err = srt.Listen("srt", s.Address, conf)
if err != nil {
return err
}
s.ctx, s.ctxCancel = context.WithCancel(context.Background())
s.conns = make(map[*conn]struct{})
s.chNewConnRequest = make(chan srt.ConnRequest)
s.chAcceptErr = make(chan error)
s.chCloseConn = make(chan *conn)
s.chAPIConnsList = make(chan serverAPIConnsListReq)
s.chAPIConnsGet = make(chan serverAPIConnsGetReq)
s.chAPIConnsKick = make(chan serverAPIConnsKickReq)
s.Log(logger.Info, "listener opened on "+s.Address+" (UDP)")
l := &listener{
ln: s.ln,
wg: &s.wg,
parent: s,
}
l.initialize()
s.wg.Add(1)
go s.run()
if !interfaceIsEmpty(s.Metrics) {
s.Metrics.SetSRTServer(s)
}
return nil
}
// Log implements logger.Writer.
func (s *Server) Log(level logger.Level, format string, args ...any) {
s.Parent.Log(level, "[SRT] "+format, args...)
}
// Close closes the server.
func (s *Server) Close() {
s.Log(logger.Info, "listener is closing")
if !interfaceIsEmpty(s.Metrics) {
s.Metrics.SetSRTServer(nil)
}
s.ctxCancel()
s.wg.Wait()
}
func (s *Server) run() {
defer s.wg.Done()
outer:
for {
select {
case err := <-s.chAcceptErr:
s.Log(logger.Error, "%s", err)
break outer
case req := <-s.chNewConnRequest:
c := &conn{
parentCtx: s.ctx,
rtspAddress: s.RTSPAddress,
readTimeout: s.ReadTimeout,
writeTimeout: s.WriteTimeout,
udpMaxPayloadSize: s.UDPMaxPayloadSize,
connReq: req,
runOnConnect: s.RunOnConnect,
runOnConnectRestart: s.RunOnConnectRestart,
runOnDisconnect: s.RunOnDisconnect,
wg: &s.wg,
externalCmdPool: s.ExternalCmdPool,
pathManager: s.PathManager,
parent: s,
}
c.initialize()
s.conns[c] = struct{}{}
case c := <-s.chCloseConn:
delete(s.conns, c)
case req := <-s.chAPIConnsList:
data := &defs.APISRTConnList{
Items: []defs.APISRTConn{},
}
for c := range s.conns {
data.Items = append(data.Items, *c.apiItem())
}
sort.Slice(data.Items, func(i, j int) bool {
return data.Items[i].Created.Before(data.Items[j].Created)
})
req.res <- serverAPIConnsListRes{data: data}
case req := <-s.chAPIConnsGet:
c := s.findConnByUUID(req.uuid)
if c == nil {
req.res <- serverAPIConnsGetRes{err: ErrConnNotFound}
continue
}
req.res <- serverAPIConnsGetRes{data: c.apiItem()}
case req := <-s.chAPIConnsKick:
c := s.findConnByUUID(req.uuid)
if c == nil {
req.res <- serverAPIConnsKickRes{err: ErrConnNotFound}
continue
}
delete(s.conns, c)
c.Close()
req.res <- serverAPIConnsKickRes{}
case <-s.ctx.Done():
break outer
}
}
s.ctxCancel()
s.ln.Close()
}
func (s *Server) findConnByUUID(uuid uuid.UUID) *conn {
for sx := range s.conns {
if sx.uuid == uuid {
return sx
}
}
return nil
}
// newConnRequest is called by srtListener.
func (s *Server) newConnRequest(connReq srt.ConnRequest) {
select {
case s.chNewConnRequest <- connReq:
case <-s.ctx.Done():
connReq.Reject(srt.REJ_CLOSE)
}
}
// acceptError is called by srtListener.
func (s *Server) acceptError(err error) {
select {
case s.chAcceptErr <- err:
case <-s.ctx.Done():
}
}
// closeConn is called by conn.
func (s *Server) closeConn(c *conn) {
select {
case s.chCloseConn <- c:
case <-s.ctx.Done():
}
}
// APIConnsList is called by api.
func (s *Server) APIConnsList() (*defs.APISRTConnList, error) {
req := serverAPIConnsListReq{
res: make(chan serverAPIConnsListRes),
}
select {
case s.chAPIConnsList <- req:
res := <-req.res
return res.data, res.err
case <-s.ctx.Done():
return nil, fmt.Errorf("terminated")
}
}
// APIConnsGet is called by api.
func (s *Server) APIConnsGet(uuid uuid.UUID) (*defs.APISRTConn, error) {
req := serverAPIConnsGetReq{
uuid: uuid,
res: make(chan serverAPIConnsGetRes),
}
select {
case s.chAPIConnsGet <- req:
res := <-req.res
return res.data, res.err
case <-s.ctx.Done():
return nil, fmt.Errorf("terminated")
}
}
// APIConnsKick is called by api.
func (s *Server) APIConnsKick(uuid uuid.UUID) error {
req := serverAPIConnsKickReq{
uuid: uuid,
res: make(chan serverAPIConnsKickRes),
}
select {
case s.chAPIConnsKick <- req:
res := <-req.res
return res.err
case <-s.ctx.Done():
return fmt.Errorf("terminated")
}
}
================================================
FILE: internal/servers/srt/server_test.go
================================================
package srt
import (
"bufio"
"testing"
"time"
"github.com/bluenviron/gortsplib/v5/pkg/description"
"github.com/bluenviron/mediacommon/v2/pkg/formats/mpegts"
tscodecs "github.com/bluenviron/mediacommon/v2/pkg/formats/mpegts/codecs"
"github.com/bluenviron/mediamtx/internal/conf"
"github.com/bluenviron/mediamtx/internal/defs"
"github.com/bluenviron/mediamtx/internal/externalcmd"
"github.com/bluenviron/mediamtx/internal/stream"
"github.com/bluenviron/mediamtx/internal/test"
"github.com/bluenviron/mediamtx/internal/unit"
srt "github.com/datarhei/gosrt"
"github.com/stretchr/testify/require"
)
type dummyPath struct{}
func (p *dummyPath) Name() string {
return "teststream"
}
func (p *dummyPath) SafeConf() *conf.Path {
return &conf.Path{}
}
func (p *dummyPath) ExternalCmdEnv() externalcmd.Environment {
return externalcmd.Environment{}
}
func (p *dummyPath) RemovePublisher(_ defs.PathRemovePublisherReq) {
}
func (p *dummyPath) RemoveReader(_ defs.PathRemoveReaderReq) {
}
func TestServerPublish(t *testing.T) {
externalCmdPool := &externalcmd.Pool{}
externalCmdPool.Initialize()
defer externalCmdPool.Close()
var strm *stream.Stream
var reader *stream.Reader
defer func() {
strm.RemoveReader(reader)
}()
dataReceived := make(chan struct{})
dataReceived2 := make(chan struct{})
n := 0
pathManager := &test.PathManager{
FindPathConfImpl: func(req defs.PathFindPathConfReq) (*defs.PathFindPathConfRes, error) {
require.Equal(t, "teststream", req.AccessRequest.Name)
require.Equal(t, "param=value", req.AccessRequest.Query)
require.Equal(t, "myuser", req.AccessRequest.Credentials.User)
require.Equal(t, "mypass", req.AccessRequest.Credentials.Pass)
return &defs.PathFindPathConfRes{Conf: &conf.Path{}, User: req.AccessRequest.Credentials.User}, nil
},
AddPublisherImpl: func(req defs.PathAddPublisherReq) (*defs.PathAddPublisherRes, error) {
require.Equal(t, "teststream", req.AccessRequest.Name)
require.Equal(t, "param=value", req.AccessRequest.Query)
require.True(t, req.AccessRequest.SkipAuth)
strm = &stream.Stream{
Desc: req.Desc,
WriteQueueSize: 512,
RTPMaxPayloadSize: 1450,
Parent: test.NilLogger,
}
err := strm.Initialize()
require.NoError(t, err)
subStream := &stream.SubStream{
Stream: strm,
UseRTPPackets: false,
}
err = subStream.Initialize()
require.NoError(t, err)
reader = &stream.Reader{Parent: test.NilLogger}
reader.OnData(
strm.Desc.Medias[0],
strm.Desc.Medias[0].Formats[0],
func(u *unit.Unit) error {
switch n {
case 0:
require.Equal(t, unit.PayloadH264{
test.FormatH264.SPS,
test.FormatH264.PPS,
{5, 1},
}, u.Payload)
close(dataReceived)
case 1:
require.Equal(t, unit.PayloadH264{
test.FormatH264.SPS,
test.FormatH264.PPS,
{5, 2},
}, u.Payload)
close(dataReceived2)
default:
t.Errorf("should not happen")
}
n++
return nil
})
strm.AddReader(reader)
return &defs.PathAddPublisherRes{Path: &dummyPath{}, SubStream: subStream}, nil
},
}
s := &Server{
Address: "127.0.0.1:8890",
RTSPAddress: "",
ReadTimeout: conf.Duration(10 * time.Second),
WriteTimeout: conf.Duration(10 * time.Second),
UDPMaxPayloadSize: 1472,
RunOnConnect: "",
RunOnConnectRestart: false,
RunOnDisconnect: "string",
ExternalCmdPool: externalCmdPool,
PathManager: pathManager,
Parent: test.NilLogger,
}
err := s.Initialize()
require.NoError(t, err)
defer s.Close()
u := "srt://127.0.0.1:8890?streamid=publish:teststream:myuser:mypass:param=value"
srtConf := srt.DefaultConfig()
address, err := srtConf.UnmarshalURL(u)
require.NoError(t, err)
err = srtConf.Validate()
require.NoError(t, err)
publisher, err := srt.Dial("srt", address, srtConf)
require.NoError(t, err)
track := &mpegts.Track{
Codec: &tscodecs.H264{},
}
bw := bufio.NewWriter(publisher)
w := &mpegts.Writer{W: bw, Tracks: []*mpegts.Track{track}}
err = w.Initialize()
require.NoError(t, err)
// the MPEG-TS muxer needs two PES packets in order to write the first one
err = w.WriteH264(track, 0, 0, [][]byte{
test.FormatH264.SPS,
test.FormatH264.PPS,
{5, 1}, // IDR
})
require.NoError(t, err)
err = w.WriteH264(track, 0, 0, [][]byte{
{5, 2}, // IDR
})
require.NoError(t, err)
err = bw.Flush()
require.NoError(t, err)
<-dataReceived
list, err := s.APIConnsList()
require.NoError(t, err)
require.Equal(t, &defs.APISRTConnList{ //nolint:dupl
Items: []defs.APISRTConn{
{
ID: list.Items[0].ID,
Created: list.Items[0].Created,
RemoteAddr: list.Items[0].RemoteAddr,
State: "publish",
Path: "teststream",
Query: "param=value",
User: "myuser",
PacketsSent: list.Items[0].PacketsSent,
PacketsReceived: list.Items[0].PacketsReceived,
PacketsSentUnique: list.Items[0].PacketsSentUnique,
PacketsReceivedUnique: list.Items[0].PacketsReceivedUnique,
PacketsSendLoss: list.Items[0].PacketsSendLoss,
PacketsReceivedLoss: list.Items[0].PacketsReceivedLoss,
PacketsRetrans: list.Items[0].PacketsRetrans,
PacketsReceivedRetrans: list.Items[0].PacketsReceivedRetrans,
PacketsSentACK: list.Items[0].PacketsSentACK,
PacketsReceivedACK: list.Items[0].PacketsReceivedACK,
PacketsSentNAK: list.Items[0].PacketsSentNAK,
PacketsReceivedNAK: list.Items[0].PacketsReceivedNAK,
PacketsSentKM: list.Items[0].PacketsSentKM,
PacketsReceivedKM: list.Items[0].PacketsReceivedKM,
UsSndDuration: list.Items[0].UsSndDuration,
PacketsReceivedBelated: list.Items[0].PacketsReceivedBelated,
PacketsSendDrop: list.Items[0].PacketsSendDrop,
PacketsReceivedDrop: list.Items[0].PacketsReceivedDrop,
PacketsReceivedUndecrypt: list.Items[0].PacketsReceivedUndecrypt,
BytesReceived: list.Items[0].BytesReceived,
BytesSent: list.Items[0].BytesSent,
BytesSentUnique: list.Items[0].BytesSentUnique,
BytesReceivedUnique: list.Items[0].BytesReceivedUnique,
BytesReceivedLoss: list.Items[0].BytesReceivedLoss,
BytesRetrans: list.Items[0].BytesRetrans,
BytesReceivedRetrans: list.Items[0].BytesReceivedRetrans,
BytesReceivedBelated: list.Items[0].BytesReceivedBelated,
BytesSendDrop: list.Items[0].BytesSendDrop,
BytesReceivedDrop: list.Items[0].BytesReceivedDrop,
BytesReceivedUndecrypt: list.Items[0].BytesReceivedUndecrypt,
OutboundFramesDiscarded: list.Items[0].OutboundFramesDiscarded,
UsPacketsSendPeriod: list.Items[0].UsPacketsSendPeriod,
PacketsFlowWindow: list.Items[0].PacketsFlowWindow,
PacketsFlightSize: list.Items[0].PacketsFlightSize,
MsRTT: list.Items[0].MsRTT,
MbpsSendRate: list.Items[0].MbpsSendRate,
MbpsReceiveRate: list.Items[0].MbpsReceiveRate,
MbpsLinkCapacity: list.Items[0].MbpsLinkCapacity,
BytesAvailSendBuf: list.Items[0].BytesAvailSendBuf,
BytesAvailReceiveBuf: list.Items[0].BytesAvailReceiveBuf,
MbpsMaxBW: list.Items[0].MbpsMaxBW,
ByteMSS: list.Items[0].ByteMSS,
PacketsSendBuf: list.Items[0].PacketsSendBuf,
BytesSendBuf: list.Items[0].BytesSendBuf,
MsSendBuf: list.Items[0].MsSendBuf,
MsSendTsbPdDelay: list.Items[0].MsSendTsbPdDelay,
PacketsReceiveBuf: list.Items[0].PacketsReceiveBuf,
BytesReceiveBuf: list.Items[0].BytesReceiveBuf,
MsReceiveBuf: list.Items[0].MsReceiveBuf,
MsReceiveTsbPdDelay: list.Items[0].MsReceiveTsbPdDelay,
PacketsReorderTolerance: list.Items[0].PacketsReorderTolerance,
PacketsReceivedAvgBelatedTime: list.Items[0].PacketsReceivedAvgBelatedTime,
PacketsSendLossRate: list.Items[0].PacketsSendLossRate,
PacketsReceivedLossRate: list.Items[0].PacketsReceivedLossRate,
},
},
}, list)
// the second PES is written after writer is closed
publisher.Close()
<-dataReceived2
}
func TestServerRead(t *testing.T) {
externalCmdPool := &externalcmd.Pool{}
externalCmdPool.Initialize()
defer externalCmdPool.Close()
desc := &description.Session{Medias: []*description.Media{test.MediaH264}}
strm := &stream.Stream{
Desc: desc,
WriteQueueSize: 512,
RTPMaxPayloadSize: 1450,
Parent: test.NilLogger,
}
err := strm.Initialize()
require.NoError(t, err)
subStream := &stream.SubStream{
Stream: strm,
UseRTPPackets: false,
}
err = subStream.Initialize()
require.NoError(t, err)
pathManager := &test.PathManager{
AddReaderImpl: func(req defs.PathAddReaderReq) (*defs.PathAddReaderRes, error) {
require.Equal(t, "teststream", req.AccessRequest.Name)
require.Equal(t, "param=value", req.AccessRequest.Query)
require.Equal(t, "myuser", req.AccessRequest.Credentials.User)
require.Equal(t, "mypass", req.AccessRequest.Credentials.Pass)
return &defs.PathAddReaderRes{Path: &dummyPath{}, User: req.AccessRequest.Credentials.User, Stream: strm}, nil
},
}
s := &Server{
Address: "127.0.0.1:8890",
RTSPAddress: "",
ReadTimeout: conf.Duration(10 * time.Second),
WriteTimeout: conf.Duration(10 * time.Second),
UDPMaxPayloadSize: 1472,
RunOnConnect: "",
RunOnConnectRestart: false,
RunOnDisconnect: "string",
ExternalCmdPool: externalCmdPool,
PathManager: pathManager,
Parent: test.NilLogger,
}
err = s.Initialize()
require.NoError(t, err)
defer s.Close()
u := "srt://127.0.0.1:8890?streamid=read:teststream:myuser:mypass:param=value"
srtConf := srt.DefaultConfig()
address, err := srtConf.UnmarshalURL(u)
require.NoError(t, err)
err = srtConf.Validate()
require.NoError(t, err)
reader, err := srt.Dial("srt", address, srtConf)
require.NoError(t, err)
defer reader.Close()
strm.WaitForReaders()
subStream.WriteUnit(desc.Medias[0], desc.Medias[0].Formats[0], &unit.Unit{
NTP: time.Time{},
Payload: unit.PayloadH264{
{5, 1}, // IDR
},
})
r := &mpegts.Reader{R: reader}
err = r.Initialize()
require.NoError(t, err)
require.Equal(t, []*mpegts.Track{{
PID: 256,
Codec: &tscodecs.H264{},
}}, r.Tracks())
received := false
r.OnDataH264(r.Tracks()[0], func(pts int64, dts int64, au [][]byte) error {
require.Equal(t, int64(0), pts)
require.Equal(t, int64(0), dts)
require.Equal(t, [][]byte{
test.FormatH264.SPS,
test.FormatH264.PPS,
{0x05, 1},
}, au)
received = true
return nil
})
subStream.WriteUnit(desc.Medias[0], desc.Medias[0].Formats[0], &unit.Unit{
NTP: time.Time{},
Payload: unit.PayloadH264{
{5, 2},
},
})
for {
err = r.Read()
require.NoError(t, err)
if received {
break
}
}
list, err := s.APIConnsList()
require.NoError(t, err)
require.Equal(t, &defs.APISRTConnList{ //nolint:dupl
Items: []defs.APISRTConn{
{
ID: list.Items[0].ID,
Created: list.Items[0].Created,
RemoteAddr: list.Items[0].RemoteAddr,
State: "read",
Path: "teststream",
Query: "param=value",
User: "myuser",
PacketsSent: list.Items[0].PacketsSent,
PacketsReceived: list.Items[0].PacketsReceived,
PacketsSentUnique: list.Items[0].PacketsSentUnique,
PacketsReceivedUnique: list.Items[0].PacketsReceivedUnique,
PacketsSendLoss: list.Items[0].PacketsSendLoss,
PacketsReceivedLoss: list.Items[0].PacketsReceivedLoss,
PacketsRetrans: list.Items[0].PacketsRetrans,
PacketsReceivedRetrans: list.Items[0].PacketsReceivedRetrans,
PacketsSentACK: list.Items[0].PacketsSentACK,
PacketsReceivedACK: list.Items[0].PacketsReceivedACK,
PacketsSentNAK: list.Items[0].PacketsSentNAK,
PacketsReceivedNAK: list.Items[0].PacketsReceivedNAK,
PacketsSentKM: list.Items[0].PacketsSentKM,
PacketsReceivedKM: list.Items[0].PacketsReceivedKM,
UsSndDuration: list.Items[0].UsSndDuration,
PacketsReceivedBelated: list.Items[0].PacketsReceivedBelated,
PacketsSendDrop: list.Items[0].PacketsSendDrop,
PacketsReceivedDrop: list.Items[0].PacketsReceivedDrop,
PacketsReceivedUndecrypt: list.Items[0].PacketsReceivedUndecrypt,
BytesReceived: list.Items[0].BytesReceived,
BytesSent: list.Items[0].BytesSent,
BytesSentUnique: list.Items[0].BytesSentUnique,
BytesReceivedUnique: list.Items[0].BytesReceivedUnique,
BytesReceivedLoss: list.Items[0].BytesReceivedLoss,
BytesRetrans: list.Items[0].BytesRetrans,
BytesReceivedRetrans: list.Items[0].BytesReceivedRetrans,
BytesReceivedBelated: list.Items[0].BytesReceivedBelated,
BytesSendDrop: list.Items[0].BytesSendDrop,
BytesReceivedDrop: list.Items[0].BytesReceivedDrop,
BytesReceivedUndecrypt: list.Items[0].BytesReceivedUndecrypt,
UsPacketsSendPeriod: list.Items[0].UsPacketsSendPeriod,
PacketsFlowWindow: list.Items[0].PacketsFlowWindow,
PacketsFlightSize: list.Items[0].PacketsFlightSize,
MsRTT: list.Items[0].MsRTT,
MbpsSendRate: list.Items[0].MbpsSendRate,
MbpsReceiveRate: list.Items[0].MbpsReceiveRate,
MbpsLinkCapacity: list.Items[0].MbpsLinkCapacity,
BytesAvailSendBuf: list.Items[0].BytesAvailSendBuf,
BytesAvailReceiveBuf: list.Items[0].BytesAvailReceiveBuf,
MbpsMaxBW: list.Items[0].MbpsMaxBW,
ByteMSS: list.Items[0].ByteMSS,
PacketsSendBuf: list.Items[0].PacketsSendBuf,
BytesSendBuf: list.Items[0].BytesSendBuf,
MsSendBuf: list.Items[0].MsSendBuf,
MsSendTsbPdDelay: list.Items[0].MsSendTsbPdDelay,
PacketsReceiveBuf: list.Items[0].PacketsReceiveBuf,
BytesReceiveBuf: list.Items[0].BytesReceiveBuf,
MsReceiveBuf: list.Items[0].MsReceiveBuf,
MsReceiveTsbPdDelay: list.Items[0].MsReceiveTsbPdDelay,
PacketsReorderTolerance: list.Items[0].PacketsReorderTolerance,
PacketsReceivedAvgBelatedTime: list.Items[0].PacketsReceivedAvgBelatedTime,
PacketsSendLossRate: list.Items[0].PacketsSendLossRate,
PacketsReceivedLossRate: list.Items[0].PacketsReceivedLossRate,
},
},
}, list)
}
================================================
FILE: internal/servers/srt/streamid.go
================================================
package srt
import (
"fmt"
"strings"
)
type streamIDMode int
const (
streamIDModeRead streamIDMode = iota
streamIDModePublish
)
type streamID struct {
mode streamIDMode
path string
query string
user string
pass string
}
func (s *streamID) unmarshal(raw string) error {
// standard syntax
// https://github.com/Haivision/srt/blob/master/docs/features/access-control.md
if strings.HasPrefix(raw, "#!::") {
for kv := range strings.SplitSeq(raw[len("#!::"):], ",") {
kv2 := strings.SplitN(kv, "=", 2)
if len(kv2) != 2 {
return fmt.Errorf("invalid value")
}
key, value := kv2[0], kv2[1]
switch key {
case "u":
s.user = value
case "r":
s.path = value
case "h":
case "s":
s.pass = value
case "t":
case "m":
switch value {
case "request":
s.mode = streamIDModeRead
case "publish":
s.mode = streamIDModePublish
default:
return fmt.Errorf("unsupported mode '%s'", value)
}
}
}
} else {
parts := strings.Split(raw, ":")
if len(parts) < 2 || len(parts) > 5 {
return fmt.Errorf("stream ID must be 'action:pathname[:query]' or 'action:pathname:user:pass[:query]', " +
"where action is either read or publish, pathname is the path name, user and pass are the credentials, " +
"query is an optional token containing additional information")
}
switch parts[0] {
case "read":
s.mode = streamIDModeRead
case "publish":
s.mode = streamIDModePublish
default:
return fmt.Errorf("stream ID must be 'action:pathname[:query]' or 'action:pathname:user:pass[:query]', " +
"where action is either read or publish, pathname is the path name, user and pass are the credentials, " +
"query is an optional token containing additional information")
}
s.path = parts[1]
if len(parts) == 4 || len(parts) == 5 {
s.user, s.pass = parts[2], parts[3]
}
if len(parts) == 3 {
s.query = parts[2]
} else if len(parts) == 5 {
s.query = parts[4]
}
}
return nil
}
================================================
FILE: internal/servers/srt/streamid_test.go
================================================
package srt
import (
"testing"
"github.com/stretchr/testify/require"
)
func TestStreamIDUnmarshal(t *testing.T) {
for _, ca := range []struct {
name string
raw string
dec streamID
}{
{
"mediamtx syntax 1",
"read:mypath",
streamID{
mode: streamIDModeRead,
path: "mypath",
},
},
{
"mediamtx syntax 2",
"publish:mypath:myquery",
streamID{
mode: streamIDModePublish,
path: "mypath",
query: "myquery",
},
},
{
"mediamtx syntax 3",
"read:mypath:myuser:mypass:myquery",
streamID{
mode: streamIDModeRead,
path: "mypath",
user: "myuser",
pass: "mypass",
query: "myquery",
},
},
{
"standard syntax",
"#!::u=johnny,t=file,m=publish,r=results.csv,s=mypass,h=myhost.com",
streamID{
mode: streamIDModePublish,
path: "results.csv",
user: "johnny",
pass: "mypass",
},
},
{
"issue 3701",
"#!::bmd_uuid=0e1df79f-77e6-465c-b099-29a616e964f7,bmd_name=rdt-wp-003,r=test3,m=publish",
streamID{
mode: streamIDModePublish,
path: "test3",
},
},
} {
t.Run(ca.name, func(t *testing.T) {
var sid streamID
err := sid.unmarshal(ca.raw)
require.NoError(t, err)
require.Equal(t, ca.dec, sid)
})
}
}
================================================
FILE: internal/servers/webrtc/http_server.go
================================================
package webrtc
import (
_ "embed"
"errors"
"fmt"
"io"
"net"
"net/http"
"regexp"
"strings"
"time"
"github.com/gin-gonic/gin"
"github.com/google/uuid"
"github.com/bluenviron/mediamtx/internal/auth"
"github.com/bluenviron/mediamtx/internal/conf"
"github.com/bluenviron/mediamtx/internal/defs"
"github.com/bluenviron/mediamtx/internal/logger"
"github.com/bluenviron/mediamtx/internal/protocols/httpp"
"github.com/bluenviron/mediamtx/internal/protocols/whip"
)
//go:embed publish_index.html
var publishIndex []byte
//go:embed publisher.js
var publisherJS []byte
//go:embed read_index.html
var readIndex []byte
//go:embed reader.js
var readerJS []byte
var (
reWHIPWHEPNoID = regexp.MustCompile("^/(.+?)/(whip|whep)$")
reWHIPWHEPWithID = regexp.MustCompile("^/(.+?)/(whip|whep)/(.+?)$")
)
func mergePathAndQuery(path string, rawQuery string) string {
res := path
if rawQuery != "" {
res += "?" + rawQuery
}
return res
}
func writeError(ctx *gin.Context, statusCode int, err error) {
ctx.JSON(statusCode, &defs.APIError{
Status: defs.APIErrorStatusError,
Error: err.Error(),
})
}
func sessionLocation(publish bool, path string, rawQuery string, secret uuid.UUID) string {
ret := "/" + path + "/"
if publish {
ret += "whip"
} else {
ret += "whep"
}
ret += "/" + secret.String()
if rawQuery != "" {
ret += "?" + rawQuery
}
return ret
}
type httpServer struct {
address string
dumpPackets bool
encryption bool
serverKey string
serverCert string
allowOrigins []string
trustedProxies conf.IPNetworks
readTimeout conf.Duration
writeTimeout conf.Duration
pathManager serverPathManager
parent *Server
inner *httpp.Server
}
func (s *httpServer) initialize() error {
router := gin.New()
router.SetTrustedProxies(s.trustedProxies.ToTrustedProxies()) //nolint:errcheck
router.Use(s.middlewarePreflightRequests)
router.Use(s.onRequest)
s.inner = &httpp.Server{
Address: s.address,
AllowOrigins: s.allowOrigins,
DumpPackets: s.dumpPackets,
DumpPacketsPrefix: "webrtc_server_conn",
ReadTimeout: time.Duration(s.readTimeout),
WriteTimeout: time.Duration(s.writeTimeout),
Encryption: s.encryption,
ServerCert: s.serverCert,
ServerKey: s.serverKey,
Handler: router,
Parent: s,
}
err := s.inner.Initialize()
if err != nil {
return err
}
return nil
}
// Log implements logger.Writer.
func (s *httpServer) Log(level logger.Level, format string, args ...any) {
s.parent.Log(level, format, args...)
}
func (s *httpServer) close() {
s.inner.Close()
}
func (s *httpServer) checkAuthOutsideSession(ctx *gin.Context, pathName string, publish bool) bool {
_, err := s.pathManager.FindPathConf(defs.PathFindPathConfReq{
AccessRequest: defs.PathAccessRequest{
Name: pathName,
Query: ctx.Request.URL.RawQuery,
Publish: publish,
Proto: auth.ProtocolWebRTC,
Credentials: httpp.Credentials(ctx.Request),
IP: net.ParseIP(ctx.ClientIP()),
},
})
if err != nil {
var terr *auth.Error
if errors.As(err, &terr) {
if terr.AskCredentials {
ctx.Header("WWW-Authenticate", `Basic realm="mediamtx"`)
ctx.AbortWithStatusJSON(http.StatusUnauthorized, &defs.APIError{
Status: defs.APIErrorStatusError,
Error: "authentication error",
})
return false
}
s.Log(logger.Info, "connection %v failed to authenticate: %v", httpp.RemoteAddr(ctx), terr.Wrapped)
// wait some seconds to delay brute force attacks
<-time.After(auth.PauseAfterError)
writeError(ctx, http.StatusUnauthorized, terr)
return false
}
writeError(ctx, http.StatusInternalServerError, err)
return false
}
return true
}
func (s *httpServer) onWHIPOptions(ctx *gin.Context, pathName string, publish bool) {
if !s.checkAuthOutsideSession(ctx, pathName, publish) {
return
}
servers, err := s.parent.generateICEServers(true)
if err != nil {
writeError(ctx, http.StatusInternalServerError, err)
return
}
ctx.Header("Access-Control-Allow-Methods", "OPTIONS, GET, POST, PATCH, DELETE")
ctx.Header("Access-Control-Allow-Headers", "Authorization, Content-Type, If-Match")
ctx.Header("Access-Control-Expose-Headers", "Link")
ctx.Writer.Header()["Link"] = whip.LinkHeaderMarshal(servers)
ctx.Writer.WriteHeader(http.StatusNoContent)
}
func (s *httpServer) onWHIPPost(ctx *gin.Context, pathName string, publish bool) {
contentType := httpp.ParseContentType(ctx.Request.Header.Get("Content-Type"))
if contentType != "application/sdp" {
writeError(ctx, http.StatusBadRequest, fmt.Errorf("invalid Content-Type"))
return
}
offer, err := io.ReadAll(ctx.Request.Body)
if err != nil {
return
}
res := s.parent.newSession(webRTCNewSessionReq{
pathName: pathName,
remoteAddr: httpp.RemoteAddr(ctx),
offer: offer,
publish: publish,
httpRequest: ctx.Request,
})
if res.err != nil {
var terr *auth.Error
if errors.As(res.err, &terr) {
if terr.AskCredentials {
ctx.Header("WWW-Authenticate", `Basic realm="mediamtx"`)
ctx.AbortWithStatusJSON(http.StatusUnauthorized, &defs.APIError{
Status: defs.APIErrorStatusError,
Error: "authentication error",
})
return
}
s.Log(logger.Info, "connection %v failed to authenticate: %v", httpp.RemoteAddr(ctx), terr.Wrapped)
// wait some seconds to delay brute force attacks
<-time.After(auth.PauseAfterError)
ctx.AbortWithStatusJSON(http.StatusUnauthorized, &defs.APIError{
Status: defs.APIErrorStatusError,
Error: "authentication error",
})
return
}
writeError(ctx, res.errStatusCode, res.err)
return
}
servers, err := s.parent.generateICEServers(true)
if err != nil {
writeError(ctx, http.StatusInternalServerError, err)
return
}
ctx.Header("Content-Type", "application/sdp")
ctx.Header("Access-Control-Expose-Headers", "ETag, ID, Accept-Patch, Link, Location")
ctx.Header("ETag", "*")
ctx.Header("ID", res.sx.uuid.String())
ctx.Header("Accept-Patch", "application/trickle-ice-sdpfrag")
ctx.Writer.Header()["Link"] = whip.LinkHeaderMarshal(servers)
ctx.Header("Location", sessionLocation(publish, pathName, ctx.Request.URL.RawQuery, res.sx.secret))
ctx.Writer.WriteHeader(http.StatusCreated)
ctx.Writer.Write(res.answer)
res.sx.Log(logger.Debug, "SDP answer:\n"+string(res.answer))
}
func (s *httpServer) onWHIPPatch(ctx *gin.Context, pathName string, rawSecret string) {
secret, err := uuid.Parse(rawSecret)
if err != nil {
writeError(ctx, http.StatusBadRequest, fmt.Errorf("invalid secret"))
return
}
contentType := httpp.ParseContentType(ctx.Request.Header.Get("Content-Type"))
if contentType != "application/trickle-ice-sdpfrag" {
writeError(ctx, http.StatusBadRequest, fmt.Errorf("invalid Content-Type"))
return
}
byts, err := io.ReadAll(ctx.Request.Body)
if err != nil {
return
}
candidates, err := whip.ICEFragmentUnmarshal(byts)
if err != nil {
writeError(ctx, http.StatusBadRequest, err)
return
}
res := s.parent.addSessionCandidates(webRTCAddSessionCandidatesReq{
pathName: pathName,
secret: secret,
candidates: candidates,
})
if res.err != nil {
if errors.Is(res.err, ErrSessionNotFound) {
writeError(ctx, http.StatusNotFound, res.err)
} else {
writeError(ctx, http.StatusInternalServerError, res.err)
}
return
}
ctx.AbortWithStatusJSON(http.StatusNoContent, &defs.APIOK{
Status: defs.APIOKStatusOK,
})
}
func (s *httpServer) onWHIPDelete(ctx *gin.Context, pathName string, rawSecret string) {
secret, err := uuid.Parse(rawSecret)
if err != nil {
writeError(ctx, http.StatusBadRequest, fmt.Errorf("invalid secret"))
return
}
err = s.parent.deleteSession(webRTCDeleteSessionReq{
pathName: pathName,
secret: secret,
})
if err != nil {
if errors.Is(err, ErrSessionNotFound) {
writeError(ctx, http.StatusNotFound, err)
} else {
writeError(ctx, http.StatusInternalServerError, err)
}
return
}
ctx.AbortWithStatusJSON(http.StatusOK, &defs.APIOK{
Status: defs.APIOKStatusOK,
})
}
func (s *httpServer) onPage(ctx *gin.Context, pathName string, publish bool) {
if !s.checkAuthOutsideSession(ctx, pathName, publish) {
return
}
// Do not cache the HTML page.
// This prevents a bug in Firefox in which, when the page
// is loaded in an iframe and the iframe is deleted and recreated,
// WebRTC is unable to re-establish the connection.
ctx.Header("Cache-Control", "no-cache")
ctx.Header("Content-Type", "text/html")
ctx.Writer.WriteHeader(http.StatusOK)
if publish {
ctx.Writer.Write(publishIndex)
} else {
ctx.Writer.Write(readIndex)
}
}
func (s *httpServer) middlewarePreflightRequests(ctx *gin.Context) {
if ctx.Request.Method == http.MethodOptions &&
ctx.Request.Header.Get("Access-Control-Request-Method") != "" {
ctx.Header("Access-Control-Allow-Methods", "OPTIONS, GET, POST, PATCH, DELETE")
ctx.Header("Access-Control-Allow-Headers", "Authorization, Content-Type, If-Match")
ctx.AbortWithStatus(http.StatusNoContent)
return
}
}
func (s *httpServer) onRequest(ctx *gin.Context) {
if strings.HasSuffix(ctx.Request.URL.Path, "/publisher.js") {
ctx.Header("Cache-Control", "max-age=3600")
ctx.Header("Content-Type", "application/javascript")
ctx.Writer.WriteHeader(http.StatusOK)
ctx.Writer.Write(publisherJS)
return
}
if strings.HasSuffix(ctx.Request.URL.Path, "/reader.js") {
ctx.Header("Cache-Control", "max-age=3600")
ctx.Header("Content-Type", "application/javascript")
ctx.Writer.WriteHeader(http.StatusOK)
ctx.Writer.Write(readerJS)
return
}
// WHIP/WHEP, outside session
if m := reWHIPWHEPNoID.FindStringSubmatch(ctx.Request.URL.Path); m != nil {
switch ctx.Request.Method {
case http.MethodOptions:
s.onWHIPOptions(ctx, m[1], m[2] == "whip")
case http.MethodPost:
s.onWHIPPost(ctx, m[1], m[2] == "whip")
case http.MethodGet, http.MethodHead, http.MethodPut:
// RFC draft-ietf-whip-09
// The WHIP endpoints MUST return an "405 Method Not Allowed" response
// for any HTTP GET, HEAD or PUT requests
writeError(ctx, http.StatusMethodNotAllowed, fmt.Errorf("method not allowed"))
}
return
}
// WHIP/WHEP, inside session
if m := reWHIPWHEPWithID.FindStringSubmatch(ctx.Request.URL.Path); m != nil {
switch ctx.Request.Method {
case http.MethodPatch:
s.onWHIPPatch(ctx, m[1], m[3])
case http.MethodDelete:
s.onWHIPDelete(ctx, m[1], m[3])
}
return
}
// static resources
if ctx.Request.Method == http.MethodGet {
switch {
case ctx.Request.URL.Path == "/favicon.ico":
case len(ctx.Request.URL.Path) >= 2:
switch {
case len(ctx.Request.URL.Path) > len("/publish") && strings.HasSuffix(ctx.Request.URL.Path, "/publish"):
s.onPage(ctx, ctx.Request.URL.Path[1:len(ctx.Request.URL.Path)-len("/publish")], true)
case ctx.Request.URL.Path[len(ctx.Request.URL.Path)-1] != '/':
ctx.Header("Location", mergePathAndQuery(ctx.Request.URL.Path+"/", ctx.Request.URL.RawQuery))
ctx.Writer.WriteHeader(http.StatusMovedPermanently)
default:
s.onPage(ctx, ctx.Request.URL.Path[1:len(ctx.Request.URL.Path)-1], false)
}
}
return
}
}
================================================
FILE: internal/servers/webrtc/publish_index.html
================================================
================================================
FILE: internal/servers/webrtc/publisher.js
================================================
'use strict';
/**
* @callback OnError
* @param {string} err - error.
*/
/**
* @callback OnConnected
*/
/**
* @typedef Conf
* @type {object}
* @property {string} url - absolute URL of the WHIP endpoint.
* @property {string} user - username.
* @property {string} pass - password.
* @property {string} token - token.
* @property {MediaStream} stream - stream that contains outgoing tracks.
* @property {string} videoCodec - outgoing video codec.
* @property {number} videoBitrate - outgoing video bitrate.
* @property {string} audioCodec - outgoing audio bitrate.
* @property {number} audioBitrate - outgoing audio bitrate.
* @property {boolean} audioVoice - whether audio is voice.
* @property {OnError} onError - called when there's an error.
* @property {OnConnected} onConnected - called when connected.
*/
/** WebRTC/WHIP publisher. */
class MediaMTXWebRTCPublisher {
/**
* Create a MediaMTXWebRTCPublisher.
* @param {Conf} conf - configuration.
*/
constructor(conf) {
this.retryPause = 2000;
this.conf = conf;
this.state = 'running';
this.restartTimeout = null;
this.pc = null;
this.offerData = null;
this.sessionUrl = null;
this.queuedCandidates = [];
this.#start();
}
/**
* Close the publisher and all its resources.
*/
close = () => {
this.state = 'closed';
if (this.pc !== null) {
this.pc.close();
}
if (this.restartTimeout !== null) {
clearTimeout(this.restartTimeout);
}
};
static #unquoteCredential(v) {
return JSON.parse(`"${v}"`);
}
static #linkToIceServers(links) {
return (links !== null) ? links.split(', ').map((link) => {
const m = link.match(/^<(.+?)>; rel="ice-server"(; username="(.*?)"; credential="(.*?)"; credential-type="password")?/i);
const ret = {
urls: [m[1]],
};
if (m[3] !== undefined) {
ret.username = this.#unquoteCredential(m[3]);
ret.credential = this.#unquoteCredential(m[4]);
ret.credentialType = 'password';
}
return ret;
}) : [];
}
static #parseOffer(offer) {
const ret = {
iceUfrag: '',
icePwd: '',
medias: [],
};
for (const line of offer.split('\r\n')) {
if (line.startsWith('m=')) {
ret.medias.push(line.slice('m='.length));
} else if (ret.iceUfrag === '' && line.startsWith('a=ice-ufrag:')) {
ret.iceUfrag = line.slice('a=ice-ufrag:'.length);
} else if (ret.icePwd === '' && line.startsWith('a=ice-pwd:')) {
ret.icePwd = line.slice('a=ice-pwd:'.length);
}
}
return ret;
}
static #generateSdpFragment(od, candidates) {
const candidatesByMedia = {};
for (const candidate of candidates) {
const mid = candidate.sdpMLineIndex;
if (candidatesByMedia[mid] === undefined) {
candidatesByMedia[mid] = [];
}
candidatesByMedia[mid].push(candidate);
}
let frag = 'a=ice-ufrag:' + od.iceUfrag + '\r\n'
+ 'a=ice-pwd:' + od.icePwd + '\r\n';
let mid = 0;
for (const media of od.medias) {
if (candidatesByMedia[mid] !== undefined) {
frag += 'm=' + media + '\r\n'
+ 'a=mid:' + mid + '\r\n';
for (const candidate of candidatesByMedia[mid]) {
frag += 'a=' + candidate.candidate + '\r\n';
}
}
mid++;
}
return frag;
}
static #setCodec(section, codec) {
const lines = section.split('\r\n');
const lines2 = [];
const payloadFormats = [];
for (const line of lines) {
if (!line.startsWith('a=rtpmap:')) {
lines2.push(line);
} else {
if (line.toLowerCase().includes(codec)) {
payloadFormats.push(line.slice('a=rtpmap:'.length).split(' ')[0]);
lines2.push(line);
}
}
}
const lines3 = [];
let firstLine = true;
for (const line of lines2) {
if (firstLine) {
firstLine = false;
lines3.push(line.split(' ').slice(0, 3).concat(payloadFormats).join(' '));
} else if (line.startsWith('a=fmtp:')) {
if (payloadFormats.includes(line.slice('a=fmtp:'.length).split(' ')[0])) {
lines3.push(line);
}
} else if (line.startsWith('a=rtcp-fb:')) {
if (payloadFormats.includes(line.slice('a=rtcp-fb:'.length).split(' ')[0])) {
lines3.push(line);
}
} else {
lines3.push(line);
}
}
return lines3.join('\r\n');
}
static #setVideoBitrate(section, bitrate) {
let lines = section.split('\r\n');
for (let i = 0; i < lines.length; i++) {
if (lines[i].startsWith('c=')) {
lines = [...lines.slice(0, i+1), 'b=TIAS:' + (parseInt(bitrate) * 1024).toString(), ...lines.slice(i+1)];
break
}
}
return lines.join('\r\n');
}
static #setAudioBitrate(section, bitrate, voice) {
let opusPayloadFormat = '';
let lines = section.split('\r\n');
for (let i = 0; i < lines.length; i++) {
if (lines[i].startsWith('a=rtpmap:') && lines[i].toLowerCase().includes('opus/')) {
opusPayloadFormat = lines[i].slice('a=rtpmap:'.length).split(' ')[0];
break;
}
}
if (opusPayloadFormat === '') {
return section;
}
for (let i = 0; i < lines.length; i++) {
if (lines[i].startsWith('a=fmtp:' + opusPayloadFormat + ' ')) {
if (voice) {
lines[i] = 'a=fmtp:' + opusPayloadFormat + ' minptime=10;useinbandfec=1;maxaveragebitrate='
+ (parseInt(bitrate) * 1024).toString();
} else {
lines[i] = 'a=fmtp:' + opusPayloadFormat + ' maxplaybackrate=48000;stereo=1;sprop-stereo=1;maxaveragebitrate='
+ (parseInt(bitrate) * 1024).toString();
}
}
}
return lines.join('\r\n');
}
static #editOffer(sdp, videoCodec, audioCodec, audioBitrate, audioVoice) {
const sections = sdp.split('m=');
for (let i = 0; i < sections.length; i++) {
if (sections[i].startsWith('video')) {
sections[i] = this.#setCodec(sections[i], videoCodec);
} else if (sections[i].startsWith('audio')) {
sections[i] = this.#setAudioBitrate(this.#setCodec(sections[i], audioCodec), audioBitrate, audioVoice);
}
}
return sections.join('m=');
}
static #editAnswer(sdp, videoBitrate) {
const sections = sdp.split('m=');
for (let i = 0; i < sections.length; i++) {
if (sections[i].startsWith('video')) {
sections[i] = this.#setVideoBitrate(sections[i], videoBitrate);
}
}
return sections.join('m=');
}
#start() {
this.#requestICEServers()
.then((iceServers) => this.#setupPeerConnection(iceServers))
.then((offer) => this.#sendOffer(offer))
.then((answer) => this.#setAnswer(answer))
.catch((err) => {
this.#handleError(err.toString());
});
}
#handleError(err) {
if (this.state === 'running') {
if (this.pc !== null) {
this.pc.close();
this.pc = null;
}
this.offerData = null;
if (this.sessionUrl !== null) {
fetch(this.sessionUrl, {
method: 'DELETE',
});
this.sessionUrl = null;
}
this.queuedCandidates = [];
this.state = 'restarting';
this.restartTimeout = window.setTimeout(() => {
this.restartTimeout = null;
this.state = 'running';
this.#start();
}, this.retryPause);
if (this.conf.onError !== undefined) {
this.conf.onError(`${err}, retrying in some seconds`);
}
}
}
#authHeader() {
if (this.conf.user !== undefined && this.conf.user !== '') {
const credentials = btoa(`${this.conf.user}:${this.conf.pass}`);
return {'Authorization': `Basic ${credentials}`};
}
if (this.conf.token !== undefined && this.conf.token !== '') {
return {'Authorization': `Bearer ${this.conf.token}`};
}
return {};
}
#requestICEServers() {
return fetch(this.conf.url, {
method: 'OPTIONS',
headers: {
...this.#authHeader(),
},
})
.then((res) => MediaMTXWebRTCPublisher.#linkToIceServers(res.headers.get('Link')));
}
#setupPeerConnection(iceServers) {
if (this.state !== 'running') {
throw new Error('closed');
}
this.pc = new RTCPeerConnection({
iceServers,
// https://webrtc.org/getting-started/unified-plan-transition-guide
sdpSemantics: 'unified-plan',
});
this.pc.onicecandidate = (evt) => this.#onLocalCandidate(evt);
this.pc.onconnectionstatechange = () => this.#onConnectionState();
this.conf.stream.getTracks().forEach((track) => {
this.pc.addTrack(track, this.conf.stream);
});
return this.pc.createOffer()
.then((offer) => {
this.offerData = MediaMTXWebRTCPublisher.#parseOffer(offer.sdp);
return this.pc.setLocalDescription(offer)
.then(() => offer.sdp);
});
}
#sendOffer(offer) {
if (this.state !== 'running') {
throw new Error('closed');
}
offer = MediaMTXWebRTCPublisher.#editOffer(
offer,
this.conf.videoCodec,
this.conf.audioCodec,
this.conf.audioBitrate,
this.conf.audioVoice);
return fetch(this.conf.url, {
method: 'POST',
headers: {
...this.#authHeader(),
'Content-Type': 'application/sdp',
},
body: offer,
})
.then((res) => {
switch (res.status) {
case 201:
break;
case 400:
return res.json().then((e) => { throw new Error(e.error); });
default:
throw new Error(`bad status code ${res.status}`);
}
this.sessionUrl = new URL(res.headers.get('location'), this.conf.url).toString();
return res.text();
});
}
#setAnswer(answer) {
if (this.state !== 'running') {
throw new Error('closed');
}
answer = MediaMTXWebRTCPublisher.#editAnswer(answer, this.conf.videoBitrate);
return this.pc.setRemoteDescription(new RTCSessionDescription({
type: 'answer',
sdp: answer,
}))
.then(() => {
if (this.state !== 'running') {
return;
}
if (this.queuedCandidates.length !== 0) {
this.#sendLocalCandidates(this.queuedCandidates);
this.queuedCandidates = [];
}
});
}
#onLocalCandidate(evt) {
if (this.state !== 'running') {
return;
}
if (evt.candidate !== null) {
if (this.sessionUrl === null) {
this.queuedCandidates.push(evt.candidate);
} else {
this.#sendLocalCandidates([evt.candidate]);
}
}
}
#sendLocalCandidates(candidates) {
fetch(this.sessionUrl, {
method: 'PATCH',
headers: {
'Content-Type': 'application/trickle-ice-sdpfrag',
'If-Match': '*',
},
body: MediaMTXWebRTCPublisher.#generateSdpFragment(this.offerData, candidates),
})
.then((res) => {
switch (res.status) {
case 204:
break;
case 404:
throw new Error('stream not found');
default:
throw new Error(`bad status code ${res.status}`);
}
})
.catch((err) => {
this.#handleError(err.toString());
});
}
#onConnectionState() {
if (this.state !== 'running') {
return;
}
// "closed" can arrive before "failed" and without
// the close() method being called at all.
// It happens when the other peer sends a termination
// message like a DTLS CloseNotify.
if (this.pc.connectionState === 'failed'
|| this.pc.connectionState === 'closed'
) {
this.#handleError('peer connection closed');
} else if (this.pc.connectionState === 'connected') {
if (this.conf.onConnected !== undefined) {
this.conf.onConnected();
}
}
}
}
window.MediaMTXWebRTCPublisher = MediaMTXWebRTCPublisher;
================================================
FILE: internal/servers/webrtc/read_index.html
================================================
================================================
FILE: internal/servers/webrtc/reader.js
================================================
'use strict';
/**
* @callback OnError
* @param {string} err - error.
*/
/**
* @callback OnTrack
* @param {RTCTrackEvent} evt - track event.
*/
/**
* @callback OnDataChannel
* @param {RTCDataChannelEvent} evt - data channel event.
*/
/**
* @typedef Conf
* @type {object}
* @property {string} url - absolute URL of the WHEP endpoint.
* @property {string} user - username.
* @property {string} pass - password.
* @property {string} token - token.
* @property {OnError} onError - called when there's an error.
* @property {OnTrack} onTrack - called when there's a track available.
* @property {OnDataChannel} onDataChannel - called when there's a data channel available.
*/
/** WebRTC/WHEP reader. */
class MediaMTXWebRTCReader {
/**
* Create a MediaMTXWebRTCReader.
* @param {Conf} conf - configuration.
*/
constructor(conf) {
this.retryPause = 2000;
this.conf = conf;
this.state = 'getting_codecs';
this.restartTimeout = null;
this.pc = null;
this.offerData = null;
this.sessionUrl = null;
this.queuedCandidates = [];
this.#getNonAdvertisedCodecs();
}
/**
* Close the reader and all its resources.
*/
close() {
this.state = 'closed';
if (this.pc !== null) {
this.pc.close();
}
if (this.restartTimeout !== null) {
clearTimeout(this.restartTimeout);
}
}
static #supportsNonAdvertisedCodec(codec, fmtp) {
return new Promise((resolve) => {
const pc = new RTCPeerConnection({ iceServers: [] });
const mediaType = 'audio';
let payloadType = '';
pc.addTransceiver(mediaType, { direction: 'recvonly' });
pc.createOffer()
.then((offer) => {
if (offer.sdp === undefined) {
throw new Error('SDP not present');
}
if (offer.sdp.includes(` ${codec}`)) { // codec is advertised, there's no need to add it manually
throw new Error('already present');
}
const sections = offer.sdp.split(`m=${mediaType}`);
const payloadTypes = sections.slice(1)
.map((s) => s.split('\r\n')[0].split(' ').slice(3))
.reduce((prev, cur) => [...prev, ...cur], []);
payloadType = this.#reservePayloadType(payloadTypes);
const lines = sections[1].split('\r\n');
lines[0] += ` ${payloadType}`;
lines.splice(lines.length - 1, 0, `a=rtpmap:${payloadType} ${codec}`);
if (fmtp !== undefined) {
lines.splice(lines.length - 1, 0, `a=fmtp:${payloadType} ${fmtp}`);
}
sections[1] = lines.join('\r\n');
offer.sdp = sections.join(`m=${mediaType}`);
return pc.setLocalDescription(offer);
})
.then(() => (
pc.setRemoteDescription(new RTCSessionDescription({
type: 'answer',
sdp: 'v=0\r\n'
+ 'o=- 6539324223450680508 0 IN IP4 0.0.0.0\r\n'
+ 's=-\r\n'
+ 't=0 0\r\n'
+ 'a=fingerprint:sha-256 0D:9F:78:15:42:B5:4B:E6:E2:94:3E:5B:37:78:E1:4B:54:59:A3:36:3A:E5:05:EB:27:EE:8F:D2:2D:41:29:25\r\n'
+ `m=${mediaType} 9 UDP/TLS/RTP/SAVPF ${payloadType}\r\n`
+ 'c=IN IP4 0.0.0.0\r\n'
+ 'a=ice-pwd:7c3bf4770007e7432ee4ea4d697db675\r\n'
+ 'a=ice-ufrag:29e036dc\r\n'
+ 'a=sendonly\r\n'
+ 'a=rtcp-mux\r\n'
+ `a=rtpmap:${payloadType} ${codec}\r\n`
+ ((fmtp !== undefined) ? `a=fmtp:${payloadType} ${fmtp}\r\n` : ''),
}))
))
.then(() => {
resolve(true);
})
.catch(() => {
resolve(false);
})
.finally(() => {
pc.close();
});
});
}
static #unquoteCredential(v) {
return JSON.parse(`"${v}"`);
}
static #linkToIceServers(links) {
return (links !== null) ? links.split(', ').map((link) => {
const m = link.match(/^<(.+?)>; rel="ice-server"(; username="(.*?)"; credential="(.*?)"; credential-type="password")?/i);
const ret = {
urls: [m[1]],
};
if (m[3] !== undefined) {
ret.username = this.#unquoteCredential(m[3]);
ret.credential = this.#unquoteCredential(m[4]);
ret.credentialType = 'password';
}
return ret;
}) : [];
}
static #parseOffer(sdp) {
const ret = {
iceUfrag: '',
icePwd: '',
medias: [],
};
for (const line of sdp.split('\r\n')) {
if (line.startsWith('m=')) {
ret.medias.push(line.slice('m='.length));
} else if (ret.iceUfrag === '' && line.startsWith('a=ice-ufrag:')) {
ret.iceUfrag = line.slice('a=ice-ufrag:'.length);
} else if (ret.icePwd === '' && line.startsWith('a=ice-pwd:')) {
ret.icePwd = line.slice('a=ice-pwd:'.length);
}
}
return ret;
}
static #reservePayloadType(payloadTypes) {
// everything is valid between 30 and 127, except for interval between 64 and 95
// https://chromium.googlesource.com/external/webrtc/+/refs/heads/master/call/payload_type.h#29
for (let i = 30; i <= 127; i++) {
if ((i <= 63 || i >= 96) && !payloadTypes.includes(i.toString())) {
const pl = i.toString();
payloadTypes.push(pl);
return pl;
}
}
throw Error('unable to find a free payload type');
}
static #enableStereoPcmau(payloadTypes, section) {
const lines = section.split('\r\n');
let payloadType = this.#reservePayloadType(payloadTypes);
lines[0] += ` ${payloadType}`;
lines.splice(lines.length - 1, 0, `a=rtpmap:${payloadType} PCMU/8000/2`);
lines.splice(lines.length - 1, 0, `a=rtcp-fb:${payloadType} transport-cc`);
payloadType = this.#reservePayloadType(payloadTypes);
lines[0] += ` ${payloadType}`;
lines.splice(lines.length - 1, 0, `a=rtpmap:${payloadType} PCMA/8000/2`);
lines.splice(lines.length - 1, 0, `a=rtcp-fb:${payloadType} transport-cc`);
return lines.join('\r\n');
}
static #enableMultichannelOpus(payloadTypes, section) {
const lines = section.split('\r\n');
let payloadType = this.#reservePayloadType(payloadTypes);
lines[0] += ` ${payloadType}`;
lines.splice(lines.length - 1, 0, `a=rtpmap:${payloadType} multiopus/48000/3`);
lines.splice(lines.length - 1, 0, `a=fmtp:${payloadType} channel_mapping=0,2,1;num_streams=2;coupled_streams=1`);
lines.splice(lines.length - 1, 0, `a=rtcp-fb:${payloadType} transport-cc`);
payloadType = this.#reservePayloadType(payloadTypes);
lines[0] += ` ${payloadType}`;
lines.splice(lines.length - 1, 0, `a=rtpmap:${payloadType} multiopus/48000/4`);
lines.splice(lines.length - 1, 0, `a=fmtp:${payloadType} channel_mapping=0,1,2,3;num_streams=2;coupled_streams=2`);
lines.splice(lines.length - 1, 0, `a=rtcp-fb:${payloadType} transport-cc`);
payloadType = this.#reservePayloadType(payloadTypes);
lines[0] += ` ${payloadType}`;
lines.splice(lines.length - 1, 0, `a=rtpmap:${payloadType} multiopus/48000/5`);
lines.splice(lines.length - 1, 0, `a=fmtp:${payloadType} channel_mapping=0,4,1,2,3;num_streams=3;coupled_streams=2`);
lines.splice(lines.length - 1, 0, `a=rtcp-fb:${payloadType} transport-cc`);
payloadType = this.#reservePayloadType(payloadTypes);
lines[0] += ` ${payloadType}`;
lines.splice(lines.length - 1, 0, `a=rtpmap:${payloadType} multiopus/48000/6`);
lines.splice(lines.length - 1, 0, `a=fmtp:${payloadType} channel_mapping=0,4,1,2,3,5;num_streams=4;coupled_streams=2`);
lines.splice(lines.length - 1, 0, `a=rtcp-fb:${payloadType} transport-cc`);
payloadType = this.#reservePayloadType(payloadTypes);
lines[0] += ` ${payloadType}`;
lines.splice(lines.length - 1, 0, `a=rtpmap:${payloadType} multiopus/48000/7`);
lines.splice(lines.length - 1, 0, `a=fmtp:${payloadType} channel_mapping=0,4,1,2,3,5,6;num_streams=4;coupled_streams=4`);
lines.splice(lines.length - 1, 0, `a=rtcp-fb:${payloadType} transport-cc`);
payloadType = this.#reservePayloadType(payloadTypes);
lines[0] += ` ${payloadType}`;
lines.splice(lines.length - 1, 0, `a=rtpmap:${payloadType} multiopus/48000/8`);
lines.splice(lines.length - 1, 0, `a=fmtp:${payloadType} channel_mapping=0,6,1,4,5,2,3,7;num_streams=5;coupled_streams=4`);
lines.splice(lines.length - 1, 0, `a=rtcp-fb:${payloadType} transport-cc`);
return lines.join('\r\n');
}
static #enableL16(payloadTypes, section) {
const lines = section.split('\r\n');
let payloadType = this.#reservePayloadType(payloadTypes);
lines[0] += ` ${payloadType}`;
lines.splice(lines.length - 1, 0, `a=rtpmap:${payloadType} L16/8000/2`);
lines.splice(lines.length - 1, 0, `a=rtcp-fb:${payloadType} transport-cc`);
payloadType = this.#reservePayloadType(payloadTypes);
lines[0] += ` ${payloadType}`;
lines.splice(lines.length - 1, 0, `a=rtpmap:${payloadType} L16/16000/2`);
lines.splice(lines.length - 1, 0, `a=rtcp-fb:${payloadType} transport-cc`);
payloadType = this.#reservePayloadType(payloadTypes);
lines[0] += ` ${payloadType}`;
lines.splice(lines.length - 1, 0, `a=rtpmap:${payloadType} L16/48000/2`);
lines.splice(lines.length - 1, 0, `a=rtcp-fb:${payloadType} transport-cc`);
return lines.join('\r\n');
}
static #enableStereoOpus(section) {
let opusPayloadFormat = '';
const lines = section.split('\r\n');
for (let i = 0; i < lines.length; i++) {
if (lines[i].startsWith('a=rtpmap:') && lines[i].toLowerCase().includes('opus/')) {
opusPayloadFormat = lines[i].slice('a=rtpmap:'.length).split(' ')[0];
break;
}
}
if (opusPayloadFormat === '') {
return section;
}
for (let i = 0; i < lines.length; i++) {
if (lines[i].startsWith(`a=fmtp:${opusPayloadFormat} `)) {
if (!lines[i].includes('stereo')) {
lines[i] += ';stereo=1';
}
if (!lines[i].includes('sprop-stereo')) {
lines[i] += ';sprop-stereo=1';
}
}
}
return lines.join('\r\n');
}
static #editOffer(sdp, nonAdvertisedCodecs) {
const sections = sdp.split('m=');
const payloadTypes = sections.slice(1)
.map((s) => s.split('\r\n')[0].split(' ').slice(3))
.reduce((prev, cur) => [...prev, ...cur], []);
for (let i = 1; i < sections.length; i++) {
if (sections[i].startsWith('audio')) {
sections[i] = this.#enableStereoOpus(sections[i]);
if (nonAdvertisedCodecs.includes('pcma/8000/2')) {
sections[i] = this.#enableStereoPcmau(payloadTypes, sections[i]);
}
if (nonAdvertisedCodecs.includes('multiopus/48000/6')) {
sections[i] = this.#enableMultichannelOpus(payloadTypes, sections[i]);
}
if (nonAdvertisedCodecs.includes('L16/48000/2')) {
sections[i] = this.#enableL16(payloadTypes, sections[i]);
}
break;
}
}
return sections.join('m=');
}
static #generateSdpFragment(od, candidates) {
const candidatesByMedia = {};
for (const candidate of candidates) {
const mid = candidate.sdpMLineIndex;
if (candidatesByMedia[mid] === undefined) {
candidatesByMedia[mid] = [];
}
candidatesByMedia[mid].push(candidate);
}
let frag = `a=ice-ufrag:${od.iceUfrag}\r\n`
+ `a=ice-pwd:${od.icePwd}\r\n`;
let mid = 0;
for (const media of od.medias) {
if (candidatesByMedia[mid] !== undefined) {
frag += `m=${media}\r\n`
+ `a=mid:${mid}\r\n`;
for (const candidate of candidatesByMedia[mid]) {
frag += `a=${candidate.candidate}\r\n`;
}
}
mid++;
}
return frag;
}
#handleError(err) {
if (this.state === 'running') {
if (this.pc !== null) {
this.pc.close();
this.pc = null;
}
this.offerData = null;
if (this.sessionUrl !== null) {
fetch(this.sessionUrl, {
method: 'DELETE',
});
this.sessionUrl = null;
}
this.queuedCandidates = [];
this.state = 'restarting';
this.restartTimeout = window.setTimeout(() => {
this.restartTimeout = null;
this.state = 'running';
this.#start();
}, this.retryPause);
if (this.conf.onError !== undefined) {
this.conf.onError(`${err}, retrying in some seconds`);
}
} else if (this.state === 'getting_codecs') {
this.state = 'failed';
if (this.conf.onError !== undefined) {
this.conf.onError(err);
}
}
}
#getNonAdvertisedCodecs() {
Promise.all([
['pcma/8000/2'],
['multiopus/48000/6', 'channel_mapping=0,4,1,2,3,5;num_streams=4;coupled_streams=2'],
['L16/48000/2'],
]
.map((c) => MediaMTXWebRTCReader.#supportsNonAdvertisedCodec(c[0], c[1]).then((r) => ((r) ? c[0] : false))))
.then((c) => c.filter((e) => e !== false))
.then((codecs) => {
if (this.state !== 'getting_codecs') {
throw new Error('closed');
}
this.nonAdvertisedCodecs = codecs;
this.state = 'running';
this.#start();
})
.catch((err) => {
this.#handleError(err);
});
}
#start() {
this.#requestICEServers()
.then((iceServers) => this.#setupPeerConnection(iceServers))
.then((offer) => this.#sendOffer(offer))
.then((answer) => this.#setAnswer(answer))
.catch((err) => {
this.#handleError(err.toString());
});
}
#authHeader() {
if (this.conf.user !== undefined && this.conf.user !== '') {
const credentials = btoa(`${this.conf.user}:${this.conf.pass}`);
return {'Authorization': `Basic ${credentials}`};
}
if (this.conf.token !== undefined && this.conf.token !== '') {
return {'Authorization': `Bearer ${this.conf.token}`};
}
return {};
}
#requestICEServers() {
return fetch(this.conf.url, {
method: 'OPTIONS',
headers: {
...this.#authHeader(),
},
})
.then((res) => MediaMTXWebRTCReader.#linkToIceServers(res.headers.get('Link')));
}
#setupPeerConnection(iceServers) {
if (this.state !== 'running') {
throw new Error('closed');
}
this.pc = new RTCPeerConnection({
iceServers,
// https://webrtc.org/getting-started/unified-plan-transition-guide
sdpSemantics: 'unified-plan',
});
const direction = 'recvonly';
this.pc.addTransceiver('video', { direction });
this.pc.addTransceiver('audio', { direction });
// using data channels requires creating a data channel locally
this.pc.createDataChannel('');
this.pc.onicecandidate = (evt) => this.#onLocalCandidate(evt);
this.pc.onconnectionstatechange = () => this.#onConnectionState();
this.pc.ontrack = (evt) => this.#onTrack(evt);
this.pc.ondatachannel = (evt) => this.#onDataChannel(evt);
return this.pc.createOffer()
.then((offer) => {
offer.sdp = MediaMTXWebRTCReader.#editOffer(offer.sdp, this.nonAdvertisedCodecs);
this.offerData = MediaMTXWebRTCReader.#parseOffer(offer.sdp);
return this.pc.setLocalDescription(offer)
.then(() => offer.sdp);
});
}
#sendOffer(offer) {
if (this.state !== 'running') {
throw new Error('closed');
}
return fetch(this.conf.url, {
method: 'POST',
headers: {
...this.#authHeader(),
'Content-Type': 'application/sdp',
},
body: offer,
})
.then((res) => {
switch (res.status) {
case 201:
break;
case 404:
throw new Error('stream not found');
case 400:
return res.json().then((e) => { throw new Error(e.error); });
default:
throw new Error(`bad status code ${res.status}`);
}
this.sessionUrl = new URL(res.headers.get('location'), this.conf.url).toString();
return res.text();
});
}
#setAnswer(answer) {
if (this.state !== 'running') {
throw new Error('closed');
}
return this.pc.setRemoteDescription(new RTCSessionDescription({
type: 'answer',
sdp: answer,
}))
.then(() => {
if (this.state !== 'running') {
return;
}
if (this.queuedCandidates.length !== 0) {
this.#sendLocalCandidates(this.queuedCandidates);
this.queuedCandidates = [];
}
});
}
#onLocalCandidate(evt) {
if (this.state !== 'running') {
return;
}
if (evt.candidate !== null) {
if (this.sessionUrl === null) {
this.queuedCandidates.push(evt.candidate);
} else {
this.#sendLocalCandidates([evt.candidate]);
}
}
}
#sendLocalCandidates(candidates) {
fetch(this.sessionUrl, {
method: 'PATCH',
headers: {
'Content-Type': 'application/trickle-ice-sdpfrag',
'If-Match': '*',
},
body: MediaMTXWebRTCReader.#generateSdpFragment(this.offerData, candidates),
})
.then((res) => {
switch (res.status) {
case 204:
break;
case 404:
throw new Error('stream not found');
default:
throw new Error(`bad status code ${res.status}`);
}
})
.catch((err) => {
this.#handleError(err.toString());
});
}
#onConnectionState() {
if (this.state !== 'running') {
return;
}
// "closed" can arrive before "failed" and without
// the close() method being called at all.
// It happens when the other peer sends a termination
// message like a DTLS CloseNotify.
if (this.pc.connectionState === 'failed'
|| this.pc.connectionState === 'closed'
) {
this.#handleError('peer connection closed');
}
}
#onTrack(evt) {
if (this.conf.onTrack !== undefined) {
this.conf.onTrack(evt);
}
}
#onDataChannel(evt) {
if (this.conf.onDataChannel !== undefined) {
this.conf.onDataChannel(evt);
}
}
}
window.MediaMTXWebRTCReader = MediaMTXWebRTCReader;
================================================
FILE: internal/servers/webrtc/server.go
================================================
// Package webrtc contains a WebRTC server.
package webrtc
import (
"context"
"crypto/hmac"
"crypto/rand"
"crypto/sha1"
"encoding/base64"
"errors"
"fmt"
"net"
"net/http"
"reflect"
"sort"
"strconv"
"sync"
"time"
"github.com/google/uuid"
"github.com/pion/ice/v4"
"github.com/pion/logging"
pwebrtc "github.com/pion/webrtc/v4"
"github.com/bluenviron/gortsplib/v5/pkg/readbuffer"
"github.com/bluenviron/mediamtx/internal/conf"
"github.com/bluenviron/mediamtx/internal/defs"
"github.com/bluenviron/mediamtx/internal/externalcmd"
"github.com/bluenviron/mediamtx/internal/logger"
"github.com/bluenviron/mediamtx/internal/protocols/webrtc"
"github.com/bluenviron/mediamtx/internal/restrictnetwork"
)
const (
webrtcTurnSecretExpiration = 24 * time.Hour
)
// ErrSessionNotFound is returned when a session is not found.
var ErrSessionNotFound = errors.New("session not found")
func interfaceIsEmpty(i any) bool {
return reflect.ValueOf(i).Kind() != reflect.Pointer || reflect.ValueOf(i).IsNil()
}
type nilWriter struct{}
func (nilWriter) Write(p []byte) (int, error) {
return len(p), nil
}
var webrtcNilLogger = logging.NewDefaultLeveledLoggerForScope("", 0, &nilWriter{})
func randInt63() (int64, error) {
var b [8]byte
_, err := rand.Read(b[:])
if err != nil {
return 0, err
}
return int64(uint64(b[0]&0b01111111)<<56 | uint64(b[1])<<48 | uint64(b[2])<<40 | uint64(b[3])<<32 |
uint64(b[4])<<24 | uint64(b[5])<<16 | uint64(b[6])<<8 | uint64(b[7])), nil
}
// https://cs.opensource.google/go/go/+/refs/tags/go1.20.4:src/math/rand/rand.go;l=119
func randInt63n(n int64) (int64, error) {
if n&(n-1) == 0 { // n is power of two, can mask
r, err := randInt63()
if err != nil {
return 0, err
}
return r & (n - 1), nil
}
maxVal := int64((1 << 63) - 1 - (1<<63)%uint64(n))
v, err := randInt63()
if err != nil {
return 0, err
}
for v > maxVal {
v, err = randInt63()
if err != nil {
return 0, err
}
}
return v % n, nil
}
func randomTurnUser() (string, error) {
const charset = "abcdefghijklmnopqrstuvwxyz1234567890"
b := make([]byte, 20)
for i := range b {
j, err := randInt63n(int64(len(charset)))
if err != nil {
return "", err
}
b[i] = charset[int(j)]
}
return string(b), nil
}
type serverAPISessionsListRes struct {
data *defs.APIWebRTCSessionList
err error
}
type serverAPISessionsListReq struct {
res chan serverAPISessionsListRes
}
type serverAPISessionsGetRes struct {
data *defs.APIWebRTCSession
err error
}
type serverAPISessionsGetReq struct {
uuid uuid.UUID
res chan serverAPISessionsGetRes
}
type serverAPISessionsKickRes struct {
err error
}
type serverAPISessionsKickReq struct {
uuid uuid.UUID
res chan serverAPISessionsKickRes
}
type webRTCNewSessionRes struct {
sx *session
answer []byte
errStatusCode int
err error
}
type webRTCNewSessionReq struct {
pathName string
remoteAddr string
offer []byte
publish bool
httpRequest *http.Request
res chan webRTCNewSessionRes
}
type webRTCAddSessionCandidatesRes struct {
sx *session
err error
}
type webRTCAddSessionCandidatesReq struct {
pathName string
secret uuid.UUID
candidates []*pwebrtc.ICECandidateInit
res chan webRTCAddSessionCandidatesRes
}
type webRTCDeleteSessionRes struct {
err error
}
type webRTCDeleteSessionReq struct {
pathName string
secret uuid.UUID
res chan webRTCDeleteSessionRes
}
type serverMetrics interface {
SetWebRTCServer(defs.APIWebRTCServer)
}
type serverPathManager interface {
FindPathConf(req defs.PathFindPathConfReq) (*defs.PathFindPathConfRes, error)
AddPublisher(req defs.PathAddPublisherReq) (*defs.PathAddPublisherRes, error)
AddReader(req defs.PathAddReaderReq) (*defs.PathAddReaderRes, error)
}
type serverParent interface {
logger.Writer
}
// Server is a WebRTC server.
type Server struct {
Address string
DumpPackets bool
Encryption bool
ServerKey string
ServerCert string
AllowOrigins []string
TrustedProxies conf.IPNetworks
ReadTimeout conf.Duration
WriteTimeout conf.Duration
UDPReadBufferSize uint
LocalUDPAddress string
LocalTCPAddress string
IPsFromInterfaces bool
IPsFromInterfacesList []string
AdditionalHosts []string
ICEServers []conf.WebRTCICEServer
STUNGatherTimeout conf.Duration
HandshakeTimeout conf.Duration
TrackGatherTimeout conf.Duration
ExternalCmdPool *externalcmd.Pool
Metrics serverMetrics
PathManager serverPathManager
Parent serverParent
ctx context.Context
ctxCancel func()
httpServer *httpServer
udpMuxLn net.PacketConn
tcpMuxLn net.Listener
iceUDPMux ice.UDPMux
iceTCPMux *webrtc.TCPMuxWrapper
sessions map[*session]struct{}
sessionsBySecret map[uuid.UUID]*session
// in
chNewSession chan webRTCNewSessionReq
chCloseSession chan *session
chAddSessionCandidates chan webRTCAddSessionCandidatesReq
chDeleteSession chan webRTCDeleteSessionReq
chAPISessionsList chan serverAPISessionsListReq
chAPISessionsGet chan serverAPISessionsGetReq
chAPIConnsKick chan serverAPISessionsKickReq
// out
done chan struct{}
}
// Initialize initializes the server.
func (s *Server) Initialize() error {
ctx, ctxCancel := context.WithCancel(context.Background())
s.ctx = ctx
s.ctxCancel = ctxCancel
s.sessions = make(map[*session]struct{})
s.sessionsBySecret = make(map[uuid.UUID]*session)
s.chNewSession = make(chan webRTCNewSessionReq)
s.chCloseSession = make(chan *session)
s.chAddSessionCandidates = make(chan webRTCAddSessionCandidatesReq)
s.chDeleteSession = make(chan webRTCDeleteSessionReq)
s.chAPISessionsList = make(chan serverAPISessionsListReq)
s.chAPISessionsGet = make(chan serverAPISessionsGetReq)
s.chAPIConnsKick = make(chan serverAPISessionsKickReq)
s.done = make(chan struct{})
s.httpServer = &httpServer{
address: s.Address,
dumpPackets: s.DumpPackets,
encryption: s.Encryption,
serverKey: s.ServerKey,
serverCert: s.ServerCert,
allowOrigins: s.AllowOrigins,
trustedProxies: s.TrustedProxies,
readTimeout: s.ReadTimeout,
writeTimeout: s.WriteTimeout,
pathManager: s.PathManager,
parent: s,
}
err := s.httpServer.initialize()
if err != nil {
ctxCancel()
return err
}
if s.LocalUDPAddress != "" {
s.udpMuxLn, err = net.ListenPacket(restrictnetwork.Restrict("udp", s.LocalUDPAddress))
if err != nil {
s.httpServer.close()
ctxCancel()
return err
}
if s.UDPReadBufferSize != 0 {
err = readbuffer.SetReadBuffer(s.udpMuxLn.(*net.UDPConn), int(s.UDPReadBufferSize))
if err != nil {
s.udpMuxLn.Close()
s.httpServer.close()
ctxCancel()
return err
}
}
s.iceUDPMux = pwebrtc.NewICEUDPMux(webrtcNilLogger, s.udpMuxLn)
}
if s.LocalTCPAddress != "" {
s.tcpMuxLn, err = net.Listen(restrictnetwork.Restrict("tcp", s.LocalTCPAddress))
if err != nil {
if s.udpMuxLn != nil {
s.udpMuxLn.Close()
}
s.httpServer.close()
ctxCancel()
return err
}
s.iceTCPMux = &webrtc.TCPMuxWrapper{
Mux: pwebrtc.NewICETCPMux(webrtcNilLogger, s.tcpMuxLn, 8),
Ln: s.tcpMuxLn,
}
}
str := "listener opened on " + s.Address + " (HTTP)"
if s.udpMuxLn != nil {
str += ", " + s.LocalUDPAddress + " (ICE/UDP)"
}
if s.tcpMuxLn != nil {
str += ", " + s.LocalTCPAddress + " (ICE/TCP)"
}
s.Log(logger.Info, str)
go s.run()
if !interfaceIsEmpty(s.Metrics) {
s.Metrics.SetWebRTCServer(s)
}
return nil
}
// Log implements logger.Writer.
func (s *Server) Log(level logger.Level, format string, args ...any) {
s.Parent.Log(level, "[WebRTC] "+format, args...)
}
// Close closes the server.
func (s *Server) Close() {
s.Log(logger.Info, "listener is closing")
if !interfaceIsEmpty(s.Metrics) {
s.Metrics.SetWebRTCServer(nil)
}
s.ctxCancel()
<-s.done
}
func (s *Server) run() {
defer close(s.done)
var wg sync.WaitGroup
outer:
for {
select {
case req := <-s.chNewSession:
sx := &session{
udpReadBufferSize: s.UDPReadBufferSize,
parentCtx: s.ctx,
ipsFromInterfaces: s.IPsFromInterfaces,
ipsFromInterfacesList: s.IPsFromInterfacesList,
additionalHosts: s.AdditionalHosts,
iceUDPMux: s.iceUDPMux,
iceTCPMux: s.iceTCPMux,
stunGatherTimeout: s.STUNGatherTimeout,
handshakeTimeout: s.HandshakeTimeout,
trackGatherTimeout: s.TrackGatherTimeout,
req: req,
wg: &wg,
externalCmdPool: s.ExternalCmdPool,
pathManager: s.PathManager,
parent: s,
}
sx.initialize()
s.sessions[sx] = struct{}{}
s.sessionsBySecret[sx.secret] = sx
req.res <- webRTCNewSessionRes{sx: sx}
case sx := <-s.chCloseSession:
delete(s.sessions, sx)
delete(s.sessionsBySecret, sx.secret)
case req := <-s.chAddSessionCandidates:
sx, ok := s.sessionsBySecret[req.secret]
if !ok || sx.req.pathName != req.pathName {
req.res <- webRTCAddSessionCandidatesRes{err: ErrSessionNotFound}
continue
}
req.res <- webRTCAddSessionCandidatesRes{sx: sx}
case req := <-s.chDeleteSession:
sx, ok := s.sessionsBySecret[req.secret]
if !ok || sx.req.pathName != req.pathName {
req.res <- webRTCDeleteSessionRes{err: ErrSessionNotFound}
continue
}
delete(s.sessions, sx)
delete(s.sessionsBySecret, sx.secret)
sx.Close()
req.res <- webRTCDeleteSessionRes{}
case req := <-s.chAPISessionsList:
data := &defs.APIWebRTCSessionList{
Items: []defs.APIWebRTCSession{},
}
for sx := range s.sessions {
data.Items = append(data.Items, *sx.apiItem())
}
sort.Slice(data.Items, func(i, j int) bool {
return data.Items[i].Created.Before(data.Items[j].Created)
})
req.res <- serverAPISessionsListRes{data: data}
case req := <-s.chAPISessionsGet:
sx := s.findSessionByUUID(req.uuid)
if sx == nil {
req.res <- serverAPISessionsGetRes{err: ErrSessionNotFound}
continue
}
req.res <- serverAPISessionsGetRes{data: sx.apiItem()}
case req := <-s.chAPIConnsKick:
sx := s.findSessionByUUID(req.uuid)
if sx == nil {
req.res <- serverAPISessionsKickRes{err: ErrSessionNotFound}
continue
}
delete(s.sessions, sx)
delete(s.sessionsBySecret, sx.secret)
sx.Close()
req.res <- serverAPISessionsKickRes{}
case <-s.ctx.Done():
break outer
}
}
s.ctxCancel()
wg.Wait()
s.httpServer.close()
if s.udpMuxLn != nil {
s.udpMuxLn.Close()
}
if s.tcpMuxLn != nil {
s.tcpMuxLn.Close()
}
}
func (s *Server) findSessionByUUID(uuid uuid.UUID) *session {
for sx := range s.sessions {
if sx.uuid == uuid {
return sx
}
}
return nil
}
func (s *Server) generateICEServers(clientConfig bool) ([]pwebrtc.ICEServer, error) {
ret := make([]pwebrtc.ICEServer, 0, len(s.ICEServers))
for _, server := range s.ICEServers {
if !server.ClientOnly || clientConfig {
if server.Username == "AUTH_SECRET" {
expireDate := time.Now().Add(webrtcTurnSecretExpiration).Unix()
user, err := randomTurnUser()
if err != nil {
return nil, err
}
server.Username = strconv.FormatInt(expireDate, 10) + ":" + user
h := hmac.New(sha1.New, []byte(server.Password))
h.Write([]byte(server.Username))
server.Password = base64.StdEncoding.EncodeToString(h.Sum(nil))
}
ret = append(ret, pwebrtc.ICEServer{
URLs: []string{server.URL},
Username: server.Username,
Credential: server.Password,
})
}
}
return ret, nil
}
// newSession is called by webRTCHTTPServer.
func (s *Server) newSession(req webRTCNewSessionReq) webRTCNewSessionRes {
req.res = make(chan webRTCNewSessionRes)
select {
case s.chNewSession <- req:
res := <-req.res
return res.sx.new(req)
case <-s.ctx.Done():
return webRTCNewSessionRes{
errStatusCode: http.StatusInternalServerError,
err: fmt.Errorf("terminated"),
}
}
}
// closeSession is called by session.
func (s *Server) closeSession(sx *session) {
select {
case s.chCloseSession <- sx:
case <-s.ctx.Done():
}
}
// addSessionCandidates is called by webRTCHTTPServer.
func (s *Server) addSessionCandidates(
req webRTCAddSessionCandidatesReq,
) webRTCAddSessionCandidatesRes {
req.res = make(chan webRTCAddSessionCandidatesRes)
select {
case s.chAddSessionCandidates <- req:
res1 := <-req.res
if res1.err != nil {
return res1
}
return res1.sx.addCandidates(req)
case <-s.ctx.Done():
return webRTCAddSessionCandidatesRes{err: fmt.Errorf("terminated")}
}
}
// deleteSession is called by webRTCHTTPServer.
func (s *Server) deleteSession(req webRTCDeleteSessionReq) error {
req.res = make(chan webRTCDeleteSessionRes)
select {
case s.chDeleteSession <- req:
res := <-req.res
return res.err
case <-s.ctx.Done():
return fmt.Errorf("terminated")
}
}
// APISessionsList is called by api.
func (s *Server) APISessionsList() (*defs.APIWebRTCSessionList, error) {
req := serverAPISessionsListReq{
res: make(chan serverAPISessionsListRes),
}
select {
case s.chAPISessionsList <- req:
res := <-req.res
return res.data, res.err
case <-s.ctx.Done():
return nil, fmt.Errorf("terminated")
}
}
// APISessionsGet is called by api.
func (s *Server) APISessionsGet(uuid uuid.UUID) (*defs.APIWebRTCSession, error) {
req := serverAPISessionsGetReq{
uuid: uuid,
res: make(chan serverAPISessionsGetRes),
}
select {
case s.chAPISessionsGet <- req:
res := <-req.res
return res.data, res.err
case <-s.ctx.Done():
return nil, fmt.Errorf("terminated")
}
}
// APISessionsKick is called by api.
func (s *Server) APISessionsKick(uuid uuid.UUID) error {
req := serverAPISessionsKickReq{
uuid: uuid,
res: make(chan serverAPISessionsKickRes),
}
select {
case s.chAPIConnsKick <- req:
res := <-req.res
return res.err
case <-s.ctx.Done():
return fmt.Errorf("terminated")
}
}
================================================
FILE: internal/servers/webrtc/server_test.go
================================================
package webrtc
import (
"bytes"
"context"
"fmt"
"io"
"net/http"
"net/url"
"reflect"
"regexp"
"testing"
"time"
"github.com/bluenviron/gortsplib/v5/pkg/description"
"github.com/bluenviron/gortsplib/v5/pkg/format"
"github.com/bluenviron/mediamtx/internal/auth"
"github.com/bluenviron/mediamtx/internal/conf"
"github.com/bluenviron/mediamtx/internal/defs"
"github.com/bluenviron/mediamtx/internal/externalcmd"
"github.com/bluenviron/mediamtx/internal/logger"
"github.com/bluenviron/mediamtx/internal/protocols/webrtc"
"github.com/bluenviron/mediamtx/internal/protocols/whip"
"github.com/bluenviron/mediamtx/internal/stream"
"github.com/bluenviron/mediamtx/internal/test"
"github.com/bluenviron/mediamtx/internal/unit"
"github.com/google/uuid"
"github.com/pion/rtp"
pwebrtc "github.com/pion/webrtc/v4"
"github.com/stretchr/testify/require"
)
func ptrOf[T any](v T) *T {
p := new(T)
*p = v
return p
}
func checkClose(t *testing.T, closeFunc func() error) {
require.NoError(t, closeFunc())
}
type dummyPath struct{}
func (p *dummyPath) Name() string {
return "teststream"
}
func (p *dummyPath) SafeConf() *conf.Path {
return &conf.Path{}
}
func (p *dummyPath) ExternalCmdEnv() externalcmd.Environment {
return externalcmd.Environment{}
}
func (p *dummyPath) RemovePublisher(_ defs.PathRemovePublisherReq) {
}
func (p *dummyPath) RemoveReader(_ defs.PathRemoveReaderReq) {
}
func initializeTestServer(t *testing.T) *Server {
pm := &test.PathManager{
FindPathConfImpl: func(req defs.PathFindPathConfReq) (*defs.PathFindPathConfRes, error) {
return &defs.PathFindPathConfRes{Conf: &conf.Path{}, User: req.AccessRequest.Credentials.User}, nil
},
}
s := &Server{
Address: "127.0.0.1:8886",
AllowOrigins: []string{"*"},
TrustedProxies: conf.IPNetworks{},
ReadTimeout: conf.Duration(10 * time.Second),
WriteTimeout: conf.Duration(10 * time.Second),
LocalUDPAddress: "127.0.0.1:8887",
LocalTCPAddress: "127.0.0.1:8887",
IPsFromInterfaces: true,
IPsFromInterfacesList: []string{},
AdditionalHosts: []string{},
ICEServers: []conf.WebRTCICEServer{},
HandshakeTimeout: conf.Duration(10 * time.Second),
TrackGatherTimeout: conf.Duration(2 * time.Second),
STUNGatherTimeout: conf.Duration(5 * time.Second),
PathManager: pm,
Parent: test.NilLogger,
}
err := s.Initialize()
require.NoError(t, err)
return s
}
func TestServerStaticPages(t *testing.T) {
s := initializeTestServer(t)
defer s.Close()
tr := &http.Transport{}
defer tr.CloseIdleConnections()
hc := &http.Client{Transport: tr}
for _, path := range []string{"/stream", "/stream/publish", "/publish"} {
func() {
req, err := http.NewRequest(http.MethodGet, "http://myuser:mypass@localhost:8886"+path, nil)
require.NoError(t, err)
res, err := hc.Do(req)
require.NoError(t, err)
defer res.Body.Close()
require.Equal(t, http.StatusOK, res.StatusCode)
}()
}
}
func TestPreflightRequest(t *testing.T) {
s := initializeTestServer(t)
defer s.Close()
tr := &http.Transport{}
defer tr.CloseIdleConnections()
hc := &http.Client{Transport: tr}
req, err := http.NewRequest(http.MethodOptions, "http://localhost:8886", nil)
require.NoError(t, err)
req.Header.Add("Access-Control-Request-Method", "GET")
res, err := hc.Do(req)
require.NoError(t, err)
defer res.Body.Close()
require.Equal(t, http.StatusNoContent, res.StatusCode)
byts, err := io.ReadAll(res.Body)
require.NoError(t, err)
require.Equal(t, "*", res.Header.Get("Access-Control-Allow-Origin"))
require.Equal(t, "true", res.Header.Get("Access-Control-Allow-Credentials"))
require.Equal(t, "OPTIONS, GET, POST, PATCH, DELETE", res.Header.Get("Access-Control-Allow-Methods"))
require.Equal(t, "Authorization, Content-Type, If-Match", res.Header.Get("Access-Control-Allow-Headers"))
require.Equal(t, byts, []byte{})
}
func TestServerOptionsICEServer(t *testing.T) {
pathManager := &test.PathManager{
FindPathConfImpl: func(req defs.PathFindPathConfReq) (*defs.PathFindPathConfRes, error) {
return &defs.PathFindPathConfRes{Conf: &conf.Path{}, User: req.AccessRequest.Credentials.User}, nil
},
}
s := &Server{
Address: "127.0.0.1:8886",
TrustedProxies: conf.IPNetworks{},
ReadTimeout: conf.Duration(10 * time.Second),
WriteTimeout: conf.Duration(10 * time.Second),
LocalUDPAddress: "127.0.0.1:8887",
LocalTCPAddress: "127.0.0.1:8887",
IPsFromInterfaces: true,
IPsFromInterfacesList: []string{},
AdditionalHosts: []string{},
ICEServers: []conf.WebRTCICEServer{{
URL: "example.com",
Username: "myuser",
Password: "mypass",
}},
STUNGatherTimeout: conf.Duration(5 * time.Second),
HandshakeTimeout: conf.Duration(10 * time.Second),
TrackGatherTimeout: conf.Duration(2 * time.Second),
PathManager: pathManager,
Parent: test.NilLogger,
}
err := s.Initialize()
require.NoError(t, err)
defer s.Close()
tr := &http.Transport{}
defer tr.CloseIdleConnections()
hc := &http.Client{Transport: tr}
req, err := http.NewRequest(http.MethodOptions,
"http://myuser:mypass@localhost:8886/nonexisting/whep", nil)
require.NoError(t, err)
res, err := hc.Do(req)
require.NoError(t, err)
defer res.Body.Close()
require.Equal(t, http.StatusNoContent, res.StatusCode)
iceServers, err := whip.LinkHeaderUnmarshal(res.Header["Link"])
require.NoError(t, err)
require.Equal(t, []pwebrtc.ICEServer{{
URLs: []string{"example.com"},
Username: "myuser",
Credential: "mypass",
}}, iceServers)
}
func TestServerPublish(t *testing.T) {
var strm *stream.Stream
var reader *stream.Reader
defer func() {
strm.RemoveReader(reader)
}()
dataReceived := make(chan struct{})
pathManager := &test.PathManager{
FindPathConfImpl: func(req defs.PathFindPathConfReq) (*defs.PathFindPathConfRes, error) {
require.Equal(t, "teststream", req.AccessRequest.Name)
require.Equal(t, "param=value", req.AccessRequest.Query)
require.Equal(t, "myuser", req.AccessRequest.Credentials.User)
require.Equal(t, "mypass", req.AccessRequest.Credentials.Pass)
return &defs.PathFindPathConfRes{Conf: &conf.Path{}, User: req.AccessRequest.Credentials.User}, nil
},
AddPublisherImpl: func(req defs.PathAddPublisherReq) (*defs.PathAddPublisherRes, error) {
require.Equal(t, "teststream", req.AccessRequest.Name)
require.Equal(t, "param=value", req.AccessRequest.Query)
require.True(t, req.AccessRequest.SkipAuth)
strm = &stream.Stream{
Desc: req.Desc,
WriteQueueSize: 512,
RTPMaxPayloadSize: 1450,
Parent: test.NilLogger,
}
err := strm.Initialize()
require.NoError(t, err)
subStream := &stream.SubStream{
Stream: strm,
UseRTPPackets: true,
}
err = subStream.Initialize()
require.NoError(t, err)
reader = &stream.Reader{Parent: test.NilLogger}
reader.OnData(
strm.Desc.Medias[0],
strm.Desc.Medias[0].Formats[0],
func(u *unit.Unit) error {
/* select {
case <-recv:
return nil
default:
} */
require.Equal(t, unit.PayloadH264{
{1},
}, u.Payload)
close(dataReceived)
return nil
})
strm.AddReader(reader)
return &defs.PathAddPublisherRes{Path: &dummyPath{}, SubStream: subStream}, nil
},
}
s := &Server{
Address: "127.0.0.1:8886",
TrustedProxies: conf.IPNetworks{},
ReadTimeout: conf.Duration(10 * time.Second),
WriteTimeout: conf.Duration(10 * time.Second),
LocalUDPAddress: "127.0.0.1:8887",
LocalTCPAddress: "127.0.0.1:8887",
IPsFromInterfaces: true,
IPsFromInterfacesList: []string{},
AdditionalHosts: []string{},
ICEServers: []conf.WebRTCICEServer{},
STUNGatherTimeout: conf.Duration(5 * time.Second),
HandshakeTimeout: conf.Duration(10 * time.Second),
TrackGatherTimeout: conf.Duration(2 * time.Second),
PathManager: pathManager,
Parent: test.NilLogger,
}
err := s.Initialize()
require.NoError(t, err)
defer s.Close()
tr := &http.Transport{}
defer tr.CloseIdleConnections()
hc := &http.Client{Transport: tr}
su, err := url.Parse("http://myuser:mypass@localhost:8886/teststream/whip?param=value")
require.NoError(t, err)
track := &webrtc.OutgoingTrack{
Caps: pwebrtc.RTPCodecCapability{
MimeType: pwebrtc.MimeTypeH264,
ClockRate: 90000,
SDPFmtpLine: "level-asymmetry-allowed=1;packetization-mode=1;profile-level-id=42e01f",
},
}
wc := &whip.Client{
HTTPClient: hc,
URL: su,
Publish: true,
OutgoingTracks: []*webrtc.OutgoingTrack{track},
Log: test.NilLogger,
}
err = wc.Initialize(context.Background())
require.NoError(t, err)
defer checkClose(t, wc.Close)
err = track.WriteRTP(&rtp.Packet{
Header: rtp.Header{
Version: 2,
Marker: true,
PayloadType: 96,
SequenceNumber: 123,
Timestamp: 45343,
SSRC: 563423,
},
Payload: []byte{1},
})
require.NoError(t, err)
<-dataReceived
list, err := s.APISessionsList()
require.NoError(t, err)
require.Equal(t, &defs.APIWebRTCSessionList{ //nolint:dupl
Items: []defs.APIWebRTCSession{
{
ID: list.Items[0].ID,
Created: list.Items[0].Created,
RemoteAddr: list.Items[0].RemoteAddr,
State: "publish",
Path: "teststream",
Query: "param=value",
User: "myuser",
InboundBytes: list.Items[0].InboundBytes,
InboundRTPPackets: list.Items[0].InboundRTPPackets,
InboundRTPPacketsLost: list.Items[0].InboundRTPPacketsLost,
InboundRTPPacketsJitter: list.Items[0].InboundRTPPacketsJitter,
InboundRTCPPackets: list.Items[0].InboundRTCPPackets,
OutboundBytes: list.Items[0].OutboundBytes,
OutboundRTPPackets: list.Items[0].OutboundRTPPackets,
OutboundRTCPPackets: list.Items[0].OutboundRTCPPackets,
OutboundFramesDiscarded: list.Items[0].OutboundFramesDiscarded,
BytesReceived: list.Items[0].BytesReceived,
BytesSent: list.Items[0].BytesSent,
RTPPacketsReceived: list.Items[0].RTPPacketsReceived,
RTPPacketsSent: list.Items[0].RTPPacketsSent,
RTCPPacketsReceived: list.Items[0].RTCPPacketsReceived,
RTCPPacketsSent: list.Items[0].RTCPPacketsSent,
PeerConnectionEstablished: true,
LocalCandidate: list.Items[0].LocalCandidate,
RemoteCandidate: list.Items[0].RemoteCandidate,
},
},
}, list)
}
func TestServerRead(t *testing.T) {
for _, ca := range []struct {
name string
medias []*description.Media
unit *unit.Unit
outRTPPayload []byte
}{
{
"av1",
[]*description.Media{{
Type: description.MediaTypeVideo,
Formats: []format.Format{&format.AV1{
PayloadTyp: 96,
}},
}},
&unit.Unit{
Payload: unit.PayloadAV1{{1, 2}},
},
[]byte{0x10, 0x01, 0x02},
},
{
"vp9",
[]*description.Media{{
Type: description.MediaTypeVideo,
Formats: []format.Format{&format.VP9{
PayloadTyp: 96,
}},
}},
&unit.Unit{
Payload: unit.PayloadVP9{0x82, 0x49, 0x83, 0x42, 0x0, 0x77, 0xf0, 0x32, 0x34},
},
[]byte{
0x8f, 0xa0, 0xfd, 0x18, 0x07, 0x80, 0x03, 0x24,
0x01, 0x14, 0x01, 0x82, 0x49, 0x83, 0x42, 0x00,
0x77, 0xf0, 0x32, 0x34,
},
},
{
"vp8",
[]*description.Media{{
Type: description.MediaTypeVideo,
Formats: []format.Format{&format.VP8{
PayloadTyp: 96,
}},
}},
&unit.Unit{
Payload: unit.PayloadVP8{1, 2},
},
[]byte{0x10, 1, 2},
},
{
"h264",
[]*description.Media{test.MediaH264},
&unit.Unit{
Payload: unit.PayloadH264{
{5, 1},
},
},
[]byte{
0x18, 0x00, 0x19, 0x67, 0x42, 0xc0, 0x28, 0xd9,
0x00, 0x78, 0x02, 0x27, 0xe5, 0x84, 0x00, 0x00,
0x03, 0x00, 0x04, 0x00, 0x00, 0x03, 0x00, 0xf0,
0x3c, 0x60, 0xc9, 0x20, 0x00, 0x04, 0x08, 0x06,
0x07, 0x08, 0x00, 0x02, 0x05, 0x01,
},
},
{
"opus",
[]*description.Media{{
Type: description.MediaTypeAudio,
Formats: []format.Format{&format.Opus{
PayloadTyp: 96,
ChannelCount: 2,
}},
}},
&unit.Unit{
Payload: unit.PayloadOpus{{1, 2}},
},
[]byte{1, 2},
},
{
"g722",
[]*description.Media{{
Type: description.MediaTypeAudio,
Formats: []format.Format{&format.G722{}},
}},
&unit.Unit{
RTPPackets: []*rtp.Packet{{
Header: rtp.Header{
Version: 2,
Marker: true,
PayloadType: 9,
SequenceNumber: 1123,
Timestamp: 45343,
SSRC: 563423,
},
Payload: []byte{1, 2},
}},
},
[]byte{1, 2},
},
{
"g711 8khz mono",
[]*description.Media{{
Type: description.MediaTypeAudio,
Formats: []format.Format{&format.G711{
MULaw: true,
SampleRate: 8000,
ChannelCount: 1,
}},
}},
&unit.Unit{
Payload: unit.PayloadG711{1, 2, 3},
},
[]byte{1, 2, 3},
},
{
"g711 16khz stereo",
[]*description.Media{{
Type: description.MediaTypeAudio,
Formats: []format.Format{&format.G711{
MULaw: true,
SampleRate: 16000,
ChannelCount: 2,
}},
}},
&unit.Unit{
Payload: unit.PayloadG711{1, 2, 3, 4},
},
[]byte{0x86, 0x84, 0x8a, 0x84, 0x8e, 0x84, 0x92, 0x84},
},
{
"lpcm",
[]*description.Media{{
Type: description.MediaTypeAudio,
Formats: []format.Format{&format.LPCM{
PayloadTyp: 96,
BitDepth: 16,
SampleRate: 48000,
ChannelCount: 2,
}},
}},
&unit.Unit{
Payload: unit.PayloadLPCM{1, 2, 3, 4},
},
[]byte{1, 2, 3, 4},
},
} {
t.Run(ca.name, func(t *testing.T) {
desc := &description.Session{Medias: ca.medias}
strm := &stream.Stream{
Desc: desc,
WriteQueueSize: 512,
RTPMaxPayloadSize: 1450,
Parent: test.NilLogger,
}
err := strm.Initialize()
require.NoError(t, err)
subStream := &stream.SubStream{
Stream: strm,
UseRTPPackets: (ca.unit.Payload == nil),
}
err = subStream.Initialize()
require.NoError(t, err)
pathManager := &test.PathManager{
FindPathConfImpl: func(req defs.PathFindPathConfReq) (*defs.PathFindPathConfRes, error) {
require.Equal(t, "teststream", req.AccessRequest.Name)
require.Equal(t, "param=value", req.AccessRequest.Query)
require.Equal(t, "myuser", req.AccessRequest.Credentials.User)
require.Equal(t, "mypass", req.AccessRequest.Credentials.Pass)
return &defs.PathFindPathConfRes{Conf: &conf.Path{}, User: req.AccessRequest.Credentials.User}, nil
},
AddReaderImpl: func(req defs.PathAddReaderReq) (*defs.PathAddReaderRes, error) {
require.Equal(t, "teststream", req.AccessRequest.Name)
require.Equal(t, "param=value", req.AccessRequest.Query)
require.Equal(t, "myuser", req.AccessRequest.Credentials.User)
require.Equal(t, "mypass", req.AccessRequest.Credentials.Pass)
return &defs.PathAddReaderRes{Path: &dummyPath{}, User: req.AccessRequest.Credentials.User, Stream: strm}, nil
},
}
s := &Server{
Address: "127.0.0.1:8886",
ReadTimeout: conf.Duration(10 * time.Second),
WriteTimeout: conf.Duration(10 * time.Second),
LocalUDPAddress: "127.0.0.1:8887",
LocalTCPAddress: "127.0.0.1:8887",
IPsFromInterfaces: true,
IPsFromInterfacesList: []string{},
AdditionalHosts: []string{},
ICEServers: []conf.WebRTCICEServer{},
STUNGatherTimeout: conf.Duration(5 * time.Second),
HandshakeTimeout: conf.Duration(10 * time.Second),
TrackGatherTimeout: conf.Duration(2 * time.Second),
PathManager: pathManager,
Parent: test.NilLogger,
}
err = s.Initialize()
require.NoError(t, err)
defer s.Close()
u, err := url.Parse("http://myuser:mypass@localhost:8886/teststream/whep?param=value")
require.NoError(t, err)
tr := &http.Transport{}
defer tr.CloseIdleConnections()
hc := &http.Client{Transport: tr}
wc := &whip.Client{
HTTPClient: hc,
URL: u,
Log: test.NilLogger,
}
writerDone := make(chan struct{})
go func() {
defer close(writerDone)
time.Sleep(500 * time.Millisecond)
r := reflect.New(reflect.TypeOf(ca.unit).Elem())
r.Elem().Set(reflect.ValueOf(ca.unit).Elem())
if ca.unit.Payload == nil {
clone := *ca.unit.RTPPackets[0]
subStream.WriteUnit(desc.Medias[0], desc.Medias[0].Formats[0], &unit.Unit{
PTS: 0,
NTP: time.Time{},
RTPPackets: []*rtp.Packet{&clone},
})
} else {
subStream.WriteUnit(desc.Medias[0], desc.Medias[0].Formats[0], r.Interface().(*unit.Unit))
}
}()
err = wc.Initialize(context.Background())
require.NoError(t, err)
defer checkClose(t, wc.Close)
done := make(chan struct{})
wc.IncomingTracks()[0].OnPacketRTP = func(pkt *rtp.Packet) {
select {
case <-done:
default:
require.Equal(t, ca.outRTPPayload, pkt.Payload)
close(done)
}
}
wc.StartReading()
<-writerDone
<-done
list, err := s.APISessionsList()
require.NoError(t, err)
require.Equal(t, &defs.APIWebRTCSessionList{ //nolint:dupl
Items: []defs.APIWebRTCSession{
{
ID: list.Items[0].ID,
Created: list.Items[0].Created,
RemoteAddr: list.Items[0].RemoteAddr,
State: "read",
Path: "teststream",
Query: "param=value",
User: "myuser",
InboundBytes: list.Items[0].InboundBytes,
InboundRTPPackets: list.Items[0].InboundRTPPackets,
InboundRTPPacketsLost: list.Items[0].InboundRTPPacketsLost,
InboundRTPPacketsJitter: list.Items[0].InboundRTPPacketsJitter,
InboundRTCPPackets: list.Items[0].InboundRTCPPackets,
OutboundBytes: list.Items[0].OutboundBytes,
OutboundRTPPackets: list.Items[0].OutboundRTPPackets,
OutboundRTCPPackets: list.Items[0].OutboundRTCPPackets,
OutboundFramesDiscarded: list.Items[0].OutboundFramesDiscarded,
BytesReceived: list.Items[0].BytesReceived,
BytesSent: list.Items[0].BytesSent,
RTPPacketsReceived: list.Items[0].RTPPacketsReceived,
RTPPacketsSent: list.Items[0].RTPPacketsSent,
RTCPPacketsReceived: list.Items[0].RTCPPacketsReceived,
RTCPPacketsSent: list.Items[0].RTCPPacketsSent,
PeerConnectionEstablished: true,
LocalCandidate: list.Items[0].LocalCandidate,
RemoteCandidate: list.Items[0].RemoteCandidate,
},
},
}, list)
})
}
}
func TestServerReadNotFound(t *testing.T) {
pm := &test.PathManager{
FindPathConfImpl: func(req defs.PathFindPathConfReq) (*defs.PathFindPathConfRes, error) {
return &defs.PathFindPathConfRes{Conf: &conf.Path{}, User: req.AccessRequest.Credentials.User}, nil
},
AddReaderImpl: func(_ defs.PathAddReaderReq) (*defs.PathAddReaderRes, error) {
return nil, defs.PathNoStreamAvailableError{}
},
}
s := &Server{
Address: "127.0.0.1:8886",
TrustedProxies: conf.IPNetworks{},
ReadTimeout: conf.Duration(10 * time.Second),
WriteTimeout: conf.Duration(10 * time.Second),
LocalUDPAddress: "127.0.0.1:8887",
LocalTCPAddress: "127.0.0.1:8887",
IPsFromInterfaces: true,
IPsFromInterfacesList: []string{},
AdditionalHosts: []string{},
ICEServers: []conf.WebRTCICEServer{},
STUNGatherTimeout: conf.Duration(5 * time.Second),
HandshakeTimeout: conf.Duration(10 * time.Second),
TrackGatherTimeout: conf.Duration(2 * time.Second),
PathManager: pm,
Parent: test.NilLogger,
}
err := s.Initialize()
require.NoError(t, err)
defer s.Close()
tr := &http.Transport{}
defer tr.CloseIdleConnections()
hc := &http.Client{Transport: tr}
pc, err := pwebrtc.NewPeerConnection(pwebrtc.Configuration{})
require.NoError(t, err)
defer pc.GracefulClose() //nolint:errcheck
_, err = pc.AddTransceiverFromKind(pwebrtc.RTPCodecTypeVideo)
require.NoError(t, err)
offer, err := pc.CreateOffer(nil)
require.NoError(t, err)
req, err := http.NewRequest(http.MethodPost,
"http://myuser:mypass@localhost:8886/nonexisting/whep", bytes.NewReader([]byte(offer.SDP)))
require.NoError(t, err)
req.Header.Set("Content-Type", "application/sdp")
res, err := hc.Do(req)
require.NoError(t, err)
defer res.Body.Close()
require.Equal(t, http.StatusNotFound, res.StatusCode)
}
func TestServerPatchNotFound(t *testing.T) {
s := initializeTestServer(t)
defer s.Close()
tr := &http.Transport{}
defer tr.CloseIdleConnections()
hc := &http.Client{Transport: tr}
pc, err := pwebrtc.NewPeerConnection(pwebrtc.Configuration{})
require.NoError(t, err)
defer pc.GracefulClose() //nolint:errcheck
_, err = pc.AddTransceiverFromKind(pwebrtc.RTPCodecTypeVideo)
require.NoError(t, err)
offer, err := pc.CreateOffer(nil)
require.NoError(t, err)
frag, err := whip.ICEFragmentMarshal(offer.SDP, []*pwebrtc.ICECandidateInit{{
Candidate: "mycandidate",
SDPMLineIndex: ptrOf(uint16(0)),
}})
require.NoError(t, err)
req, err := http.NewRequest(http.MethodPatch,
"http://localhost:8886/nonexisting/whep/"+uuid.UUID{}.String(), bytes.NewReader(frag))
require.NoError(t, err)
req.Header.Set("Content-Type", "application/trickle-ice-sdpfrag")
res, err := hc.Do(req)
require.NoError(t, err)
defer res.Body.Close()
require.Equal(t, http.StatusNotFound, res.StatusCode)
}
func TestServerDeleteNotFound(t *testing.T) {
s := initializeTestServer(t)
defer s.Close()
tr := &http.Transport{}
defer tr.CloseIdleConnections()
hc := &http.Client{Transport: tr}
req, err := http.NewRequest(http.MethodDelete,
"http://localhost:8886/nonexisting/whep/"+uuid.UUID{}.String(), nil)
require.NoError(t, err)
res, err := hc.Do(req)
require.NoError(t, err)
defer res.Body.Close()
require.Equal(t, http.StatusNotFound, res.StatusCode)
}
func TestICEServerNoClientOnly(t *testing.T) {
s := &Server{
ICEServers: []conf.WebRTCICEServer{
{
URL: "turn:turn.example.com:1234",
Username: "user",
Password: "passwrd",
},
},
}
clientICEServers, err := s.generateICEServers(true)
require.NoError(t, err)
require.Equal(t, len(s.ICEServers), len(clientICEServers))
serverICEServers, err := s.generateICEServers(false)
require.NoError(t, err)
require.Equal(t, len(s.ICEServers), len(serverICEServers))
}
func TestICEServerClientOnly(t *testing.T) {
s := &Server{
ICEServers: []conf.WebRTCICEServer{
{
URL: "turn:turn.example.com:1234",
Username: "user",
Password: "passwrd",
ClientOnly: true,
},
},
}
clientICEServers, err := s.generateICEServers(true)
require.NoError(t, err)
require.Equal(t, len(s.ICEServers), len(clientICEServers))
serverICEServers, err := s.generateICEServers(false)
require.NoError(t, err)
require.Empty(t, serverICEServers)
}
func TestAuthError(t *testing.T) {
for _, ca := range []string{
"publish page",
"whip options",
"whip post",
} {
t.Run(ca, func(t *testing.T) {
authFailed := false
s := &Server{
Address: "127.0.0.1:8886",
ReadTimeout: conf.Duration(10 * time.Second),
WriteTimeout: conf.Duration(10 * time.Second),
PathManager: &test.PathManager{
FindPathConfImpl: func(req defs.PathFindPathConfReq) (*defs.PathFindPathConfRes, error) {
if req.AccessRequest.Credentials.User == "" && req.AccessRequest.Credentials.Pass == "" {
return nil, &auth.Error{AskCredentials: true, Wrapped: fmt.Errorf("auth error")}
}
return nil, &auth.Error{Wrapped: fmt.Errorf("auth error")}
},
},
Parent: test.Logger(func(l logger.Level, s string, i ...any) {
if l == logger.Info {
if regexp.MustCompile("failed to authenticate: auth error$").MatchString(fmt.Sprintf(s, i...)) {
authFailed = true
}
}
}),
}
err := s.Initialize()
require.NoError(t, err)
defer s.Close()
var req *http.Request
switch ca {
case "publish page":
req, err = http.NewRequest(http.MethodGet, "http://127.0.0.1:8886/stream/publish", nil)
case "whip options":
req, err = http.NewRequest(http.MethodOptions, "http://127.0.0.1:8886/teststream/whip", nil)
case "whip post":
var pc *pwebrtc.PeerConnection
pc, err = pwebrtc.NewPeerConnection(pwebrtc.Configuration{})
require.NoError(t, err)
defer pc.GracefulClose() //nolint:errcheck
_, err = pc.AddTransceiverFromKind(pwebrtc.RTPCodecTypeVideo)
require.NoError(t, err)
var offer pwebrtc.SessionDescription
offer, err = pc.CreateOffer(nil)
require.NoError(t, err)
req, err = http.NewRequest(http.MethodPost, "http://127.0.0.1:8886/teststream/whip",
bytes.NewReader([]byte(offer.SDP)))
req.Header.Set("Content-Type", "application/sdp")
}
require.NoError(t, err)
res, err := http.DefaultClient.Do(req)
require.NoError(t, err)
defer res.Body.Close()
require.Equal(t, http.StatusUnauthorized, res.StatusCode)
require.Equal(t, `Basic realm="mediamtx"`, res.Header.Get("WWW-Authenticate"))
switch ca {
case "publish page":
req, err = http.NewRequest(http.MethodGet, "http://myuser:mypass@127.0.0.1:8886/stream/publish", nil)
case "whip options":
req, err = http.NewRequest(http.MethodOptions, "http://myuser:mypass@127.0.0.1:8886/teststream/whip", nil)
case "whip post":
var pc *pwebrtc.PeerConnection
pc, err = pwebrtc.NewPeerConnection(pwebrtc.Configuration{})
require.NoError(t, err)
defer pc.GracefulClose() //nolint:errcheck
_, err = pc.AddTransceiverFromKind(pwebrtc.RTPCodecTypeVideo)
require.NoError(t, err)
var offer pwebrtc.SessionDescription
offer, err = pc.CreateOffer(nil)
require.NoError(t, err)
req, err = http.NewRequest(http.MethodPost, "http://myuser:mypass@127.0.0.1:8886/teststream/whip",
bytes.NewReader([]byte(offer.SDP)))
req.Header.Set("Content-Type", "application/sdp")
}
require.NoError(t, err)
start := time.Now()
res, err = http.DefaultClient.Do(req)
require.NoError(t, err)
defer res.Body.Close()
require.Greater(t, time.Since(start), 2*time.Second)
require.Equal(t, http.StatusUnauthorized, res.StatusCode)
require.True(t, authFailed)
})
}
}
================================================
FILE: internal/servers/webrtc/session.go
================================================
package webrtc
import (
"context"
"encoding/hex"
"errors"
"fmt"
"net"
"net/http"
"sync"
"time"
"github.com/bluenviron/gortsplib/v5/pkg/description"
"github.com/google/uuid"
"github.com/pion/ice/v4"
"github.com/pion/sdp/v3"
pwebrtc "github.com/pion/webrtc/v4"
"github.com/bluenviron/mediamtx/internal/auth"
"github.com/bluenviron/mediamtx/internal/conf"
"github.com/bluenviron/mediamtx/internal/defs"
"github.com/bluenviron/mediamtx/internal/externalcmd"
"github.com/bluenviron/mediamtx/internal/hooks"
"github.com/bluenviron/mediamtx/internal/logger"
"github.com/bluenviron/mediamtx/internal/protocols/httpp"
"github.com/bluenviron/mediamtx/internal/protocols/webrtc"
"github.com/bluenviron/mediamtx/internal/stream"
)
func whipOffer(body []byte) *pwebrtc.SessionDescription {
return &pwebrtc.SessionDescription{
Type: pwebrtc.SDPTypeOffer,
SDP: string(body),
}
}
type sessionParent interface {
closeSession(sx *session)
generateICEServers(clientConfig bool) ([]pwebrtc.ICEServer, error)
logger.Writer
}
type session struct {
udpReadBufferSize uint
parentCtx context.Context
ipsFromInterfaces bool
ipsFromInterfacesList []string
additionalHosts []string
iceUDPMux ice.UDPMux
iceTCPMux *webrtc.TCPMuxWrapper
stunGatherTimeout conf.Duration
handshakeTimeout conf.Duration
trackGatherTimeout conf.Duration
req webRTCNewSessionReq
wg *sync.WaitGroup
externalCmdPool *externalcmd.Pool
pathManager serverPathManager
parent sessionParent
ctx context.Context
ctxCancel func()
created time.Time
uuid uuid.UUID
secret uuid.UUID
mutex sync.RWMutex
reader *stream.Reader
pc *webrtc.PeerConnection
user string
chNew chan webRTCNewSessionReq
chAddCandidates chan webRTCAddSessionCandidatesReq
}
func (s *session) initialize() {
ctx, ctxCancel := context.WithCancel(s.parentCtx)
s.ctx = ctx
s.ctxCancel = ctxCancel
s.created = time.Now()
s.uuid = uuid.New()
s.secret = uuid.New()
s.chNew = make(chan webRTCNewSessionReq)
s.chAddCandidates = make(chan webRTCAddSessionCandidatesReq)
s.Log(logger.Info, "created by %s", s.req.remoteAddr)
s.wg.Add(1)
go s.run()
}
// Log implements logger.Writer.
func (s *session) Log(level logger.Level, format string, args ...any) {
id := hex.EncodeToString(s.uuid[:4])
s.parent.Log(level, "[session %v] "+format, append([]any{id}, args...)...)
}
func (s *session) Close() {
s.ctxCancel()
}
func (s *session) run() {
defer s.wg.Done()
err := s.runInner()
s.ctxCancel()
s.parent.closeSession(s)
s.Log(logger.Info, "closed: %v", err)
}
func (s *session) runInner() error {
select {
case <-s.chNew:
case <-s.ctx.Done():
return fmt.Errorf("terminated")
}
errStatusCode, err := s.runInner2()
if errStatusCode != 0 {
s.req.res <- webRTCNewSessionRes{
errStatusCode: errStatusCode,
err: err,
}
}
return err
}
func (s *session) runInner2() (int, error) {
if s.req.publish {
return s.runPublish()
}
return s.runRead()
}
func (s *session) runPublish() (int, error) {
ip, _, _ := net.SplitHostPort(s.req.remoteAddr)
res1, err := s.pathManager.FindPathConf(defs.PathFindPathConfReq{
AccessRequest: defs.PathAccessRequest{
Name: s.req.pathName,
Query: s.req.httpRequest.URL.RawQuery,
Publish: true,
Proto: auth.ProtocolWebRTC,
ID: &s.uuid,
Credentials: httpp.Credentials(s.req.httpRequest),
IP: net.ParseIP(ip),
},
})
if err != nil {
return http.StatusBadRequest, err
}
s.mutex.Lock()
s.user = res1.User
s.mutex.Unlock()
iceServers, err := s.parent.generateICEServers(false)
if err != nil {
return http.StatusInternalServerError, err
}
pc := &webrtc.PeerConnection{
UDPReadBufferSize: s.udpReadBufferSize,
ICEUDPMux: s.iceUDPMux,
ICETCPMux: s.iceTCPMux,
ICEServers: iceServers,
IPsFromInterfaces: s.ipsFromInterfaces,
IPsFromInterfacesList: s.ipsFromInterfacesList,
AdditionalHosts: s.additionalHosts,
STUNGatherTimeout: time.Duration(s.stunGatherTimeout),
Publish: false,
Log: s,
}
err = pc.Start()
if err != nil {
return http.StatusBadRequest, err
}
terminatorDone := make(chan struct{})
defer func() { <-terminatorDone }()
terminatorRun := make(chan struct{})
defer close(terminatorRun)
go func() {
defer close(terminatorDone)
select {
case <-s.ctx.Done():
case <-terminatorRun:
}
pc.Close()
}()
offer := whipOffer(s.req.offer)
var sdp sdp.SessionDescription
err = sdp.Unmarshal([]byte(offer.SDP))
if err != nil {
return http.StatusBadRequest, err
}
err = webrtc.TracksAreValid(sdp.MediaDescriptions)
if err != nil {
// RFC draft-ietf-wish-whip
// if the number of audio and or video
// tracks or number streams is not supported by the WHIP Endpoint, it
// MUST reject the HTTP POST request with a "406 Not Acceptable" error
// response.
return http.StatusNotAcceptable, err
}
answer, err := pc.CreateFullAnswer(offer)
if err != nil {
return http.StatusBadRequest, err
}
s.writeAnswer(answer)
go s.readRemoteCandidates(pc)
err = pc.WaitUntilConnected(time.Duration(s.handshakeTimeout))
if err != nil {
return 0, err
}
s.mutex.Lock()
s.pc = pc
s.mutex.Unlock()
err = pc.GatherIncomingTracks(time.Duration(s.trackGatherTimeout))
if err != nil {
return 0, err
}
var subStream *stream.SubStream
medias, err := webrtc.ToStream(pc, res1.Conf, &subStream, s)
if err != nil {
return 0, err
}
res2, err := s.pathManager.AddPublisher(defs.PathAddPublisherReq{
Author: s,
Desc: &description.Session{Medias: medias},
UseRTPPackets: true,
ReplaceNTP: !res1.Conf.UseAbsoluteTimestamp,
ConfToCompare: res1.Conf,
AccessRequest: defs.PathAccessRequest{
Name: s.req.pathName,
Query: s.req.httpRequest.URL.RawQuery,
Publish: true,
SkipAuth: true,
},
})
if err != nil {
return 0, err
}
defer res2.Path.RemovePublisher(defs.PathRemovePublisherReq{Author: s})
subStream = res2.SubStream
pc.StartReading()
select {
case <-pc.Failed():
return 0, fmt.Errorf("peer connection closed")
case <-s.ctx.Done():
return 0, fmt.Errorf("terminated")
}
}
func (s *session) runRead() (int, error) {
ip, _, _ := net.SplitHostPort(s.req.remoteAddr)
req := defs.PathAccessRequest{
Name: s.req.pathName,
Query: s.req.httpRequest.URL.RawQuery,
Proto: auth.ProtocolWebRTC,
ID: &s.uuid,
Credentials: httpp.Credentials(s.req.httpRequest),
IP: net.ParseIP(ip),
}
res, err := s.pathManager.AddReader(defs.PathAddReaderReq{
Author: s,
AccessRequest: req,
})
if err != nil {
var terr2 defs.PathNoStreamAvailableError
if errors.As(err, &terr2) {
return http.StatusNotFound, err
}
return http.StatusBadRequest, err
}
defer res.Path.RemoveReader(defs.PathRemoveReaderReq{Author: s})
s.mutex.Lock()
s.user = res.User
s.mutex.Unlock()
iceServers, err := s.parent.generateICEServers(false)
if err != nil {
return http.StatusInternalServerError, err
}
pc := &webrtc.PeerConnection{
UDPReadBufferSize: s.udpReadBufferSize,
ICEUDPMux: s.iceUDPMux,
ICETCPMux: s.iceTCPMux,
ICEServers: iceServers,
IPsFromInterfaces: s.ipsFromInterfaces,
IPsFromInterfacesList: s.ipsFromInterfacesList,
AdditionalHosts: s.additionalHosts,
STUNGatherTimeout: time.Duration(s.stunGatherTimeout),
Publish: true,
Log: s,
}
r := &stream.Reader{Parent: s}
err = webrtc.FromStream(res.Stream.Desc, r, pc)
if err != nil {
return http.StatusBadRequest, err
}
err = pc.Start()
if err != nil {
return http.StatusBadRequest, err
}
terminatorDone := make(chan struct{})
defer func() { <-terminatorDone }()
terminatorRun := make(chan struct{})
defer close(terminatorRun)
go func() {
defer close(terminatorDone)
select {
case <-s.ctx.Done():
case <-terminatorRun:
}
pc.Close()
}()
offer := whipOffer(s.req.offer)
answer, err := pc.CreateFullAnswer(offer)
if err != nil {
return http.StatusBadRequest, err
}
s.writeAnswer(answer)
go s.readRemoteCandidates(pc)
err = pc.WaitUntilConnected(time.Duration(s.handshakeTimeout))
if err != nil {
return 0, err
}
s.mutex.Lock()
s.pc = pc
s.mutex.Unlock()
s.Log(logger.Info, "is reading from path '%s', %s",
res.Path.Name(), defs.FormatsInfo(r.Formats()))
onUnreadHook := hooks.OnRead(hooks.OnReadParams{
Logger: s,
ExternalCmdPool: s.externalCmdPool,
Conf: res.Path.SafeConf(),
ExternalCmdEnv: res.Path.ExternalCmdEnv(),
Reader: *s.APIReaderDescribe(),
Query: s.req.httpRequest.URL.RawQuery,
})
defer onUnreadHook()
res.Stream.AddReader(r)
defer res.Stream.RemoveReader(r)
s.mutex.Lock()
s.reader = r
s.mutex.Unlock()
select {
case <-pc.Failed():
return 0, fmt.Errorf("peer connection closed")
case err = <-r.Error():
return 0, err
case <-s.ctx.Done():
return 0, fmt.Errorf("terminated")
}
}
func (s *session) writeAnswer(answer *pwebrtc.SessionDescription) {
s.req.res <- webRTCNewSessionRes{
sx: s,
answer: []byte(answer.SDP),
}
}
func (s *session) readRemoteCandidates(pc *webrtc.PeerConnection) {
for {
select {
case req := <-s.chAddCandidates:
for _, candidate := range req.candidates {
err := pc.AddRemoteCandidate(candidate)
if err != nil {
req.res <- webRTCAddSessionCandidatesRes{err: err}
}
}
req.res <- webRTCAddSessionCandidatesRes{}
case <-s.ctx.Done():
return
}
}
}
// new is called by webRTCHTTPServer through Server.
func (s *session) new(req webRTCNewSessionReq) webRTCNewSessionRes {
select {
case s.chNew <- req:
return <-req.res
case <-s.ctx.Done():
return webRTCNewSessionRes{err: fmt.Errorf("terminated"), errStatusCode: http.StatusInternalServerError}
}
}
// addCandidates is called by webRTCHTTPServer through Server.
func (s *session) addCandidates(
req webRTCAddSessionCandidatesReq,
) webRTCAddSessionCandidatesRes {
select {
case s.chAddCandidates <- req:
return <-req.res
case <-s.ctx.Done():
return webRTCAddSessionCandidatesRes{err: fmt.Errorf("terminated")}
}
}
// APIReaderDescribe implements reader.
func (s *session) APIReaderDescribe() *defs.APIPathReader {
return &defs.APIPathReader{
Type: defs.APIPathReaderTypeWebRTCSession,
ID: s.uuid.String(),
}
}
// APISourceDescribe implements source.
func (s *session) APISourceDescribe() *defs.APIPathSource {
return &defs.APIPathSource{
Type: defs.APIPathSourceTypeWebRTCSession,
ID: s.uuid.String(),
}
}
func (s *session) apiItem() *defs.APIWebRTCSession {
s.mutex.RLock()
defer s.mutex.RUnlock()
peerConnectionEstablished := false
localCandidate := ""
remoteCandidate := ""
bytesReceived := uint64(0)
bytesSent := uint64(0)
rtpPacketsReceived := uint64(0)
rtpPacketsSent := uint64(0)
rtpPacketsLost := uint64(0)
rtpPacketsJitter := float64(0)
rtcpPacketsReceived := uint64(0)
rtcpPacketsSent := uint64(0)
outboundFramesDiscarded := uint64(0)
if s.pc != nil {
peerConnectionEstablished = true
localCandidate = s.pc.LocalCandidate()
remoteCandidate = s.pc.RemoteCandidate()
stats := s.pc.Stats()
bytesReceived = stats.BytesReceived
bytesSent = stats.BytesSent
rtpPacketsReceived = stats.RTPPacketsReceived
rtpPacketsSent = stats.RTPPacketsSent
rtpPacketsLost = stats.RTPPacketsLost
rtpPacketsJitter = stats.RTPPacketsJitter
rtcpPacketsReceived = stats.RTCPPacketsReceived
rtcpPacketsSent = stats.RTCPPacketsSent
}
if s.reader != nil {
outboundFramesDiscarded = s.reader.OutboundFramesDiscarded()
}
return &defs.APIWebRTCSession{
ID: s.uuid,
Created: s.created,
RemoteAddr: s.req.remoteAddr,
PeerConnectionEstablished: peerConnectionEstablished,
LocalCandidate: localCandidate,
RemoteCandidate: remoteCandidate,
State: func() defs.APIWebRTCSessionState {
if s.req.publish {
return defs.APIWebRTCSessionStatePublish
}
return defs.APIWebRTCSessionStateRead
}(),
Path: s.req.pathName,
Query: s.req.httpRequest.URL.RawQuery,
User: s.user,
InboundBytes: bytesReceived,
InboundRTPPackets: rtpPacketsReceived,
InboundRTPPacketsLost: rtpPacketsLost,
InboundRTPPacketsJitter: rtpPacketsJitter,
InboundRTCPPackets: rtcpPacketsReceived,
OutboundBytes: bytesSent,
OutboundRTPPackets: rtpPacketsSent,
OutboundRTCPPackets: rtcpPacketsSent,
OutboundFramesDiscarded: outboundFramesDiscarded,
BytesReceived: bytesReceived,
BytesSent: bytesSent,
RTPPacketsReceived: rtpPacketsReceived,
RTPPacketsSent: rtpPacketsSent,
RTPPacketsLost: rtpPacketsLost,
RTPPacketsJitter: rtpPacketsJitter,
RTCPPacketsReceived: rtcpPacketsReceived,
RTCPPacketsSent: rtcpPacketsSent,
}
}
================================================
FILE: internal/staticsources/handler.go
================================================
// Package staticsources contains static source implementations.
package staticsources
import (
"context"
"fmt"
"strconv"
"strings"
"time"
"github.com/bluenviron/mediamtx/internal/conf"
"github.com/bluenviron/mediamtx/internal/defs"
"github.com/bluenviron/mediamtx/internal/logger"
sshls "github.com/bluenviron/mediamtx/internal/staticsources/hls"
ssmpegts "github.com/bluenviron/mediamtx/internal/staticsources/mpegts"
ssrpicamera "github.com/bluenviron/mediamtx/internal/staticsources/rpicamera"
ssrtmp "github.com/bluenviron/mediamtx/internal/staticsources/rtmp"
ssrtp "github.com/bluenviron/mediamtx/internal/staticsources/rtp"
ssrtsp "github.com/bluenviron/mediamtx/internal/staticsources/rtsp"
sssrt "github.com/bluenviron/mediamtx/internal/staticsources/srt"
sswebrtc "github.com/bluenviron/mediamtx/internal/staticsources/webrtc"
)
const (
retryPause = 5 * time.Second
)
func emptyTimer() *time.Timer {
t := time.NewTimer(0)
<-t.C
return t
}
func resolveSource(s string, matches []string, query string) string {
if len(matches) > 1 {
for i, ma := range matches[1:] {
s = strings.ReplaceAll(s, "$G"+strconv.FormatInt(int64(i+1), 10), ma)
}
}
s = strings.ReplaceAll(s, "$MTX_QUERY", query)
return s
}
type staticSource interface {
logger.Writer
Run(defs.StaticSourceRunParams) error
APISourceDescribe() *defs.APIPathSource
}
type handlerPathManager interface {
AddReader(req defs.PathAddReaderReq) (*defs.PathAddReaderRes, error)
}
type handlerParent interface {
logger.Writer
StaticSourceHandlerSetReady(context.Context, defs.PathSourceStaticSetReadyReq)
StaticSourceHandlerSetNotReady(context.Context, defs.PathSourceStaticSetNotReadyReq)
}
// Handler is a static source handler.
type Handler struct {
Conf *conf.Path
LogLevel conf.LogLevel
DumpPackets bool
ReadTimeout conf.Duration
WriteTimeout conf.Duration
WriteQueueSize int
UDPReadBufferSize uint
RTPMaxPayloadSize int
Matches []string
PathManager handlerPathManager
Parent handlerParent
ctx context.Context
ctxCancel func()
instance staticSource
running bool
query string
// in
chReloadConf chan *conf.Path
chInstanceSetReady chan defs.PathSourceStaticSetReadyReq
chInstanceSetNotReady chan defs.PathSourceStaticSetNotReadyReq
// out
done chan struct{}
}
// Initialize initializes Handler.
func (s *Handler) Initialize() {
s.chReloadConf = make(chan *conf.Path)
s.chInstanceSetReady = make(chan defs.PathSourceStaticSetReadyReq)
s.chInstanceSetNotReady = make(chan defs.PathSourceStaticSetNotReadyReq)
switch {
case strings.HasPrefix(s.Conf.Source, "rtsp://") ||
strings.HasPrefix(s.Conf.Source, "rtsps://") ||
strings.HasPrefix(s.Conf.Source, "rtsp+http://") ||
strings.HasPrefix(s.Conf.Source, "rtsps+http://") ||
strings.HasPrefix(s.Conf.Source, "rtsp+ws://") ||
strings.HasPrefix(s.Conf.Source, "rtsps+ws://"):
s.instance = &ssrtsp.Source{
DumpPackets: s.DumpPackets,
ReadTimeout: s.ReadTimeout,
WriteTimeout: s.WriteTimeout,
WriteQueueSize: s.WriteQueueSize,
UDPReadBufferSize: s.UDPReadBufferSize,
Parent: s,
}
case strings.HasPrefix(s.Conf.Source, "rtmp://") ||
strings.HasPrefix(s.Conf.Source, "rtmps://"):
s.instance = &ssrtmp.Source{
DumpPackets: s.DumpPackets,
ReadTimeout: s.ReadTimeout,
WriteTimeout: s.WriteTimeout,
Parent: s,
}
case strings.HasPrefix(s.Conf.Source, "http://") ||
strings.HasPrefix(s.Conf.Source, "https://"):
s.instance = &sshls.Source{
DumpPackets: s.DumpPackets,
ReadTimeout: s.ReadTimeout,
Parent: s,
}
case strings.HasPrefix(s.Conf.Source, "udp://") ||
strings.HasPrefix(s.Conf.Source, "udp+mpegts://") ||
strings.HasPrefix(s.Conf.Source, "unix+mpegts://"):
s.instance = &ssmpegts.Source{
DumpPackets: s.DumpPackets,
ReadTimeout: s.ReadTimeout,
UDPReadBufferSize: s.UDPReadBufferSize,
Parent: s,
}
case strings.HasPrefix(s.Conf.Source, "srt://"):
s.instance = &sssrt.Source{
ReadTimeout: s.ReadTimeout,
Parent: s,
}
case strings.HasPrefix(s.Conf.Source, "whep://") ||
strings.HasPrefix(s.Conf.Source, "wheps://"):
s.instance = &sswebrtc.Source{
DumpPackets: s.DumpPackets,
ReadTimeout: s.ReadTimeout,
UDPReadBufferSize: s.UDPReadBufferSize,
Parent: s,
}
case strings.HasPrefix(s.Conf.Source, "udp+rtp://") ||
strings.HasPrefix(s.Conf.Source, "unix+rtp://"):
s.instance = &ssrtp.Source{
DumpPackets: s.DumpPackets,
ReadTimeout: s.ReadTimeout,
UDPReadBufferSize: s.UDPReadBufferSize,
Parent: s,
}
case s.Conf.Source == "rpiCamera":
s.instance = &ssrpicamera.Source{
RTPMaxPayloadSize: s.RTPMaxPayloadSize,
LogLevel: s.LogLevel,
Parent: s,
}
default:
panic("should not happen")
}
}
// Close closes Handler.
func (s *Handler) Close(reason string) {
s.Stop(reason)
}
// Start starts Handler.
func (s *Handler) Start(onDemand bool, query string) {
if s.running {
panic("should not happen")
}
s.running = true
s.query = query
s.ctx, s.ctxCancel = context.WithCancel(context.Background())
s.done = make(chan struct{})
s.instance.Log(logger.Info, "started%s",
func() string {
if onDemand {
return " on demand"
}
return ""
}())
go s.run()
}
// Stop stops Handler.
func (s *Handler) Stop(reason string) {
if !s.running {
panic("should not happen")
}
s.running = false
s.instance.Log(logger.Info, "stopped: %s", reason)
s.ctxCancel()
// we must wait since s.ctx is not thread safe
<-s.done
}
// Log implements logger.Writer.
func (s *Handler) Log(level logger.Level, format string, args ...any) {
s.Parent.Log(level, format, args...)
}
func (s *Handler) run() {
defer close(s.done)
var runCtx context.Context
var runCtxCancel func()
runErr := make(chan error)
runReloadConf := make(chan *conf.Path)
recreate := func() {
resolvedSource := resolveSource(s.Conf.Source, s.Matches, s.query)
runCtx, runCtxCancel = context.WithCancel(context.Background())
go func() {
runErr <- s.instance.Run(defs.StaticSourceRunParams{
Context: runCtx,
ResolvedSource: resolvedSource,
Conf: s.Conf,
ReloadConf: runReloadConf,
})
}()
}
recreate()
recreating := false
recreateTimer := emptyTimer()
for {
select {
case err := <-runErr:
runCtxCancel()
s.instance.Log(logger.Error, err.Error())
recreating = true
recreateTimer = time.NewTimer(retryPause)
case req := <-s.chInstanceSetReady:
s.Parent.StaticSourceHandlerSetReady(s.ctx, req)
case req := <-s.chInstanceSetNotReady:
s.Parent.StaticSourceHandlerSetNotReady(s.ctx, req)
case newConf := <-s.chReloadConf:
s.Conf = newConf
if !recreating {
cReloadConf := runReloadConf
cInnerCtx := runCtx
go func() {
select {
case cReloadConf <- newConf:
case <-cInnerCtx.Done():
}
}()
}
case <-recreateTimer.C:
recreate()
recreating = false
case <-s.ctx.Done():
if !recreating {
runCtxCancel()
<-runErr
}
return
}
}
}
// ReloadConf is called by path.
func (s *Handler) ReloadConf(newConf *conf.Path) {
ctx := s.ctx
if !s.running {
return
}
go func() {
select {
case s.chReloadConf <- newConf:
case <-ctx.Done():
}
}()
}
// APISourceDescribe instanceements source.
func (s *Handler) APISourceDescribe() *defs.APIPathSource {
return s.instance.APISourceDescribe()
}
// SetReady is called by a staticSource.
func (s *Handler) SetReady(req defs.PathSourceStaticSetReadyReq) defs.PathSourceStaticSetReadyRes {
req.Res = make(chan defs.PathSourceStaticSetReadyRes)
select {
case s.chInstanceSetReady <- req:
return <-req.Res
case <-s.ctx.Done():
return defs.PathSourceStaticSetReadyRes{Err: fmt.Errorf("terminated")}
}
}
// SetNotReady is called by a staticSource.
func (s *Handler) SetNotReady(req defs.PathSourceStaticSetNotReadyReq) {
req.Res = make(chan struct{})
select {
case s.chInstanceSetNotReady <- req:
<-req.Res
case <-s.ctx.Done():
}
}
// AddReader is called by a staticSource.
func (s *Handler) AddReader(req defs.PathAddReaderReq) (*defs.PathAddReaderRes, error) {
return s.PathManager.AddReader(req)
}
================================================
FILE: internal/staticsources/hls/source.go
================================================
// Package hls contains the HLS static source.
package hls
import (
"net"
"net/http"
"net/http/cookiejar"
"net/url"
"time"
"github.com/bluenviron/gohlslib/v2"
"github.com/bluenviron/gortsplib/v5/pkg/description"
"github.com/bluenviron/mediamtx/internal/conf"
"github.com/bluenviron/mediamtx/internal/defs"
"github.com/bluenviron/mediamtx/internal/errordumper"
"github.com/bluenviron/mediamtx/internal/logger"
"github.com/bluenviron/mediamtx/internal/packetdumper"
"github.com/bluenviron/mediamtx/internal/protocols/hls"
"github.com/bluenviron/mediamtx/internal/protocols/tls"
"github.com/bluenviron/mediamtx/internal/stream"
)
type parent interface {
logger.Writer
SetReady(req defs.PathSourceStaticSetReadyReq) defs.PathSourceStaticSetReadyRes
SetNotReady(req defs.PathSourceStaticSetNotReadyReq)
}
// Source is a HLS static source.
type Source struct {
DumpPackets bool
ReadTimeout conf.Duration
Parent parent
}
// Log implements logger.Writer.
func (s *Source) Log(level logger.Level, format string, args ...any) {
s.Parent.Log(level, "[HLS source] "+format, args...)
}
// Run implements StaticSource.
func (s *Source) Run(params defs.StaticSourceRunParams) error {
var subStream *stream.SubStream
defer func() {
if subStream != nil {
s.Parent.SetNotReady(defs.PathSourceStaticSetNotReadyReq{})
}
}()
decodeErrors := &errordumper.Dumper{
OnReport: func(val uint64, last error) {
if val == 1 {
s.Log(logger.Warn, "decode error: %v", last)
} else {
s.Log(logger.Warn, "%d decode errors, last was: %v", val, last)
}
},
}
decodeErrors.Start()
defer decodeErrors.Stop()
u, err := url.Parse(params.ResolvedSource)
if err != nil {
return err
}
dialContext := (&net.Dialer{}).DialContext
if s.DumpPackets {
dialContext = (&packetdumper.DialContext{
Prefix: "hls_source_conn",
DialContext: dialContext,
}).Do
}
tr := &http.Transport{
DialContext: dialContext,
TLSClientConfig: tls.MakeConfig(u.Hostname(), params.Conf.SourceFingerprint),
}
defer tr.CloseIdleConnections()
jar, _ := cookiejar.New(nil)
var c *gohlslib.Client
c = &gohlslib.Client{
URI: params.ResolvedSource,
HTTPClient: &http.Client{
Timeout: time.Duration(s.ReadTimeout),
Transport: tr,
Jar: jar,
},
OnDownloadPrimaryPlaylist: func(u string) {
s.Log(logger.Debug, "downloading primary playlist %v", u)
},
OnDownloadStreamPlaylist: func(u string) {
s.Log(logger.Debug, "downloading stream playlist %v", u)
},
OnDownloadSegment: func(u string) {
s.Log(logger.Debug, "downloading segment %v", u)
},
OnDownloadPart: func(u string) {
s.Log(logger.Debug, "downloading part %v", u)
},
OnDecodeError: func(err error) {
decodeErrors.Add(err)
},
OnTracks: func(tracks []*gohlslib.Track) error {
medias, err2 := hls.ToStream(c, tracks, params.Conf, &subStream)
if err2 != nil {
return err2
}
res := s.Parent.SetReady(defs.PathSourceStaticSetReadyReq{
Desc: &description.Session{Medias: medias},
UseRTPPackets: false,
ReplaceNTP: false,
})
if res.Err != nil {
return res.Err
}
subStream = res.SubStream
return nil
},
}
err = c.Start()
if err != nil {
return err
}
waitErr := make(chan error)
go func() {
waitErr <- c.Wait2()
}()
for {
select {
case err = <-waitErr:
c.Close()
return err
case <-params.ReloadConf:
case <-params.Context.Done():
c.Close()
<-waitErr
return nil
}
}
}
// APISourceDescribe implements StaticSource.
func (*Source) APISourceDescribe() *defs.APIPathSource {
return &defs.APIPathSource{
Type: defs.APIPathSourceTypeHLSSource,
ID: "",
}
}
================================================
FILE: internal/staticsources/hls/source_test.go
================================================
package hls
import (
"context"
"net"
"net/http"
"testing"
"github.com/bluenviron/mediacommon/v2/pkg/codecs/mpeg4audio"
"github.com/bluenviron/mediacommon/v2/pkg/formats/mpegts"
tscodecs "github.com/bluenviron/mediacommon/v2/pkg/formats/mpegts/codecs"
"github.com/stretchr/testify/require"
"github.com/bluenviron/mediamtx/internal/conf"
"github.com/bluenviron/mediamtx/internal/defs"
"github.com/bluenviron/mediamtx/internal/test"
)
func TestSource(t *testing.T) {
track1 := &mpegts.Track{
Codec: &tscodecs.H264{},
}
track2 := &mpegts.Track{
Codec: &tscodecs.MPEG4Audio{
Config: mpeg4audio.AudioSpecificConfig{
Type: 2,
SampleRate: 44100,
ChannelCount: 2,
},
},
}
tracks := []*mpegts.Track{
track1,
track2,
}
s := &http.Server{
Handler: http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
switch {
case r.Method == http.MethodGet && r.URL.Path == "/stream.m3u8":
w.Header().Set("Content-Type", `application/vnd.apple.mpegurl`)
w.Write([]byte("#EXTM3U\n" +
"#EXT-X-VERSION:3\n" +
"#EXT-X-ALLOW-CACHE:NO\n" +
"#EXT-X-TARGETDURATION:2\n" +
"#EXT-X-MEDIA-SEQUENCE:0\n" +
"#EXTINF:2,\n" +
"segment1.ts\n" +
"#EXTINF:2,\n" +
"segment2.ts\n" +
"#EXTINF:2,\n" +
"segment2.ts\n" +
"#EXT-X-ENDLIST\n"))
case r.Method == http.MethodGet && r.URL.Path == "/segment1.ts":
w.Header().Set("Content-Type", `video/MP2T`)
w := &mpegts.Writer{W: w, Tracks: tracks}
err := w.Initialize()
require.NoError(t, err)
err = w.WriteMPEG4Audio(track2, 1*90000, [][]byte{{1, 2, 3, 4}})
require.NoError(t, err)
err = w.WriteH264(track1, 2*90000, 2*90000, [][]byte{
{7, 1, 2, 3}, // SPS
{8}, // PPS
})
require.NoError(t, err)
case r.Method == http.MethodGet && r.URL.Path == "/segment2.ts":
w.Header().Set("Content-Type", `video/MP2T`)
w := &mpegts.Writer{W: w, Tracks: tracks}
err := w.Initialize()
require.NoError(t, err)
err = w.WriteMPEG4Audio(track2, 3*90000, [][]byte{{1, 2, 3, 4}})
require.NoError(t, err)
}
}),
}
ln, err := net.Listen("tcp", "localhost:5780")
require.NoError(t, err)
go s.Serve(ln)
defer s.Shutdown(context.Background())
p := &test.StaticSourceParent{}
p.Initialize()
defer p.Close()
so := &Source{
Parent: p,
}
done := make(chan struct{})
defer func() { <-done }()
ctx, ctxCancel := context.WithCancel(context.Background())
defer ctxCancel()
reloadConf := make(chan *conf.Path)
go func() {
so.Run(defs.StaticSourceRunParams{ //nolint:errcheck
Context: ctx,
ResolvedSource: "http://localhost:5780/stream.m3u8",
Conf: &conf.Path{},
ReloadConf: reloadConf,
})
close(done)
}()
<-p.Unit
// the source must be listening on ReloadConf
reloadConf <- nil
}
func TestSourceCookie(t *testing.T) {
track1 := &mpegts.Track{
Codec: &tscodecs.H264{},
}
tracks := []*mpegts.Track{track1}
s := &http.Server{
Handler: http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
switch {
case r.Method == http.MethodGet && r.URL.Path == "/stream.m3u8":
w.Header().Set("Set-Cookie", "testcookie=123456; Path=/; Max-Age=3600")
w.Header().Set("Content-Type", `application/vnd.apple.mpegurl`)
w.Write([]byte("#EXTM3U\n" +
"#EXT-X-VERSION:3\n" +
"#EXT-X-ALLOW-CACHE:NO\n" +
"#EXT-X-TARGETDURATION:2\n" +
"#EXT-X-MEDIA-SEQUENCE:0\n" +
"#EXTINF:2,\n" +
"segment1.ts\n" +
"#EXTINF:2,\n" +
"segment2.ts\n" +
"#EXTINF:2,\n" +
"segment2.ts\n" +
"#EXT-X-ENDLIST\n"))
case r.Method == http.MethodGet && r.URL.Path == "/segment1.ts":
require.Equal(t, "testcookie=123456", r.Header.Get("Cookie"))
w.Header().Set("Content-Type", `video/MP2T`)
w := &mpegts.Writer{W: w, Tracks: tracks}
err := w.Initialize()
require.NoError(t, err)
err = w.WriteH264(track1, 2*90000, 2*90000, [][]byte{
{7, 1, 2, 3}, // SPS
{8}, // PPS
})
require.NoError(t, err)
case r.Method == http.MethodGet && r.URL.Path == "/segment2.ts":
w.Header().Set("Content-Type", `video/MP2T`)
w := &mpegts.Writer{W: w, Tracks: tracks}
err := w.Initialize()
require.NoError(t, err)
}
}),
}
ln, err := net.Listen("tcp", "localhost:5780")
require.NoError(t, err)
go s.Serve(ln)
defer s.Shutdown(context.Background())
p := &test.StaticSourceParent{}
p.Initialize()
defer p.Close()
so := &Source{
Parent: p,
}
done := make(chan struct{})
defer func() { <-done }()
ctx, ctxCancel := context.WithCancel(context.Background())
defer ctxCancel()
go func() {
so.Run(defs.StaticSourceRunParams{ //nolint:errcheck
Context: ctx,
ResolvedSource: "http://localhost:5780/stream.m3u8",
Conf: &conf.Path{},
})
close(done)
}()
<-p.Unit
}
================================================
FILE: internal/staticsources/mpegts/source.go
================================================
// Package mpegts contains the MPEG-TS static source.
package mpegts
import (
"fmt"
"net"
"net/url"
"time"
"github.com/bluenviron/gortsplib/v5/pkg/description"
"github.com/bluenviron/mediamtx/internal/conf"
"github.com/bluenviron/mediamtx/internal/defs"
"github.com/bluenviron/mediamtx/internal/errordumper"
"github.com/bluenviron/mediamtx/internal/logger"
"github.com/bluenviron/mediamtx/internal/packetdumper"
"github.com/bluenviron/mediamtx/internal/protocols/mpegts"
"github.com/bluenviron/mediamtx/internal/protocols/udp"
"github.com/bluenviron/mediamtx/internal/protocols/unix"
"github.com/bluenviron/mediamtx/internal/stream"
)
type parent interface {
logger.Writer
SetReady(req defs.PathSourceStaticSetReadyReq) defs.PathSourceStaticSetReadyRes
SetNotReady(req defs.PathSourceStaticSetNotReadyReq)
}
// Source is a MPEG-TS static source.
type Source struct {
DumpPackets bool
ReadTimeout conf.Duration
UDPReadBufferSize uint
Parent parent
}
// Log implements logger.Writer.
func (s *Source) Log(level logger.Level, format string, args ...any) {
s.Parent.Log(level, "[MPEG-TS source] "+format, args...)
}
// Run implements StaticSource.
func (s *Source) Run(params defs.StaticSourceRunParams) error {
s.Log(logger.Debug, "connecting")
u, err := url.Parse(params.ResolvedSource)
if err != nil {
return err
}
var nc net.Conn
switch u.Scheme {
case "unix+mpegts":
params := unix.URLToParams(u)
l := &unix.Listener{
Path: params.Path,
}
err = l.Initialize()
if err != nil {
return err
}
nc = l
default:
udpReadBufferSize := s.UDPReadBufferSize
if params.Conf.MPEGTSUDPReadBufferSize != nil {
udpReadBufferSize = *params.Conf.MPEGTSUDPReadBufferSize
}
listenPacket := net.ListenPacket
if s.DumpPackets {
listenPacket = func(network, address string) (net.PacketConn, error) {
pc, err2 := net.ListenPacket(network, address)
if err2 != nil {
return nil, err2
}
d := &packetdumper.PacketConn{
Prefix: "mpegts_source_packetconn",
PacketConn: pc,
}
err2 = d.Initialize()
if err2 != nil {
return nil, err2
}
return d, nil
}
}
params := udp.URLToParams(u)
l := &udp.Listener{
Address: params.Address,
Source: params.Source,
IntfName: params.IntfName,
UDPReadBufferSize: int(udpReadBufferSize),
ListenPacket: listenPacket,
}
err = l.Initialize()
if err != nil {
return err
}
nc = l
}
readerErr := make(chan error)
go func() {
readerErr <- s.runReader(nc)
}()
for {
select {
case err = <-readerErr:
nc.Close()
return err
case <-params.ReloadConf:
case <-params.Context.Done():
nc.Close()
<-readerErr
return fmt.Errorf("terminated")
}
}
}
func (s *Source) runReader(nc net.Conn) error {
nc.SetReadDeadline(time.Now().Add(time.Duration(s.ReadTimeout)))
mr := &mpegts.EnhancedReader{R: nc}
err := mr.Initialize()
if err != nil {
return err
}
decodeErrors := &errordumper.Dumper{
OnReport: func(val uint64, last error) {
if val == 1 {
s.Log(logger.Warn, "decode error: %v", last)
} else {
s.Log(logger.Warn, "%d decode errors, last was: %v", val, last)
}
},
}
decodeErrors.Start()
defer decodeErrors.Stop()
mr.OnDecodeError(func(err error) {
decodeErrors.Add(err)
})
var subStream *stream.SubStream
medias, err := mpegts.ToStream(mr, &subStream, s)
if err != nil {
return err
}
res := s.Parent.SetReady(defs.PathSourceStaticSetReadyReq{
Desc: &description.Session{Medias: medias},
UseRTPPackets: false,
ReplaceNTP: true,
})
if res.Err != nil {
return res.Err
}
defer s.Parent.SetNotReady(defs.PathSourceStaticSetNotReadyReq{})
subStream = res.SubStream
for {
nc.SetReadDeadline(time.Now().Add(time.Duration(s.ReadTimeout)))
err = mr.Read()
if err != nil {
return err
}
}
}
// APISourceDescribe implements StaticSource.
func (*Source) APISourceDescribe() *defs.APIPathSource {
return &defs.APIPathSource{
Type: defs.APIPathSourceTypeMPEGTSSource,
ID: "",
}
}
================================================
FILE: internal/staticsources/mpegts/source_test.go
================================================
package mpegts
import (
"bufio"
"context"
"net"
"os"
"path/filepath"
"testing"
"time"
"github.com/bluenviron/mediacommon/v2/pkg/formats/mpegts"
tscodecs "github.com/bluenviron/mediacommon/v2/pkg/formats/mpegts/codecs"
"github.com/stretchr/testify/require"
"github.com/bluenviron/mediamtx/internal/conf"
"github.com/bluenviron/mediamtx/internal/defs"
"github.com/bluenviron/mediamtx/internal/test"
)
func multicastCapableInterface(t *testing.T) string {
intfs, err := net.Interfaces()
require.NoError(t, err)
for _, intf := range intfs {
if (intf.Flags & net.FlagMulticast) != 0 {
return intf.Name
}
}
t.Errorf("unable to find a multicast IP")
return ""
}
func TestSourceUDP(t *testing.T) {
for _, ca := range []string{
"unicast",
"multicast",
"multicast with interface",
"unicast with source",
} {
t.Run(ca, func(t *testing.T) {
var src string
switch ca {
case "unicast":
src = "udp+mpegts://127.0.0.1:9001"
case "multicast":
src = "udp+mpegts://238.0.0.1:9001"
case "multicast with interface":
src = "udp+mpegts://238.0.0.1:9001?interface=" + multicastCapableInterface(t)
case "unicast with source":
src = "udp+mpegts://127.0.0.1:9001?source=127.0.1.1"
}
p := &test.StaticSourceParent{}
p.Initialize()
defer p.Close()
so := &Source{
ReadTimeout: conf.Duration(10 * time.Second),
Parent: p,
}
done := make(chan struct{})
defer func() { <-done }()
ctx, ctxCancel := context.WithCancel(context.Background())
defer ctxCancel()
reloadConf := make(chan *conf.Path)
go func() {
so.Run(defs.StaticSourceRunParams{ //nolint:errcheck
Context: ctx,
ResolvedSource: src,
Conf: &conf.Path{},
ReloadConf: reloadConf,
})
close(done)
}()
time.Sleep(50 * time.Millisecond)
var dest string
switch ca {
case "unicast":
dest = "127.0.0.1:9001"
case "multicast":
dest = "238.0.0.1:9001"
case "multicast with interface":
dest = "238.0.0.1:9001"
case "unicast with source":
dest = "127.0.0.1:9001"
}
udest, err := net.ResolveUDPAddr("udp", dest)
require.NoError(t, err)
var usrc *net.UDPAddr
if ca == "unicast with source" {
usrc, err = net.ResolveUDPAddr("udp", "127.0.1.1:9022")
require.NoError(t, err)
}
conn, err := net.DialUDP("udp", usrc, udest)
require.NoError(t, err)
defer conn.Close() //nolint:errcheck
track := &mpegts.Track{
Codec: &tscodecs.H264{},
}
bw := bufio.NewWriter(conn)
w := &mpegts.Writer{W: bw, Tracks: []*mpegts.Track{track}}
err = w.Initialize()
require.NoError(t, err)
err = w.WriteH264(track, 0, 0, [][]byte{{ // IDR
5, 1,
}})
require.NoError(t, err)
err = bw.Flush()
require.NoError(t, err)
err = w.WriteH264(track, 0, 0, [][]byte{{ // non-IDR
5, 2,
}})
require.NoError(t, err)
err = bw.Flush()
require.NoError(t, err)
<-p.Unit
// the source must be listening on ReloadConf
reloadConf <- nil
})
}
}
func TestSourceUnixSocket(t *testing.T) {
for _, ca := range []string{
"relative",
"absolute",
} {
t.Run(ca, func(t *testing.T) {
var pa string
if ca == "relative" {
pa = "test_mpegts.sock"
} else {
pa = filepath.Join(os.TempDir(), "test_mpegts.sock")
}
func() {
p := &test.StaticSourceParent{}
p.Initialize()
defer p.Close()
so := &Source{
ReadTimeout: conf.Duration(10 * time.Second),
Parent: p,
}
done := make(chan struct{})
defer func() { <-done }()
ctx, ctxCancel := context.WithCancel(context.Background())
defer ctxCancel()
go func() {
so.Run(defs.StaticSourceRunParams{ //nolint:errcheck
Context: ctx,
ResolvedSource: "unix+mpegts://" + pa,
Conf: &conf.Path{},
})
close(done)
}()
time.Sleep(50 * time.Millisecond)
_, err := os.Stat(pa)
require.NoError(t, err)
conn, err := net.Dial("unix", pa)
require.NoError(t, err)
track := &mpegts.Track{
Codec: &tscodecs.H264{},
}
bw := bufio.NewWriter(conn)
w := &mpegts.Writer{W: bw, Tracks: []*mpegts.Track{track}}
err = w.Initialize()
require.NoError(t, err)
err = w.WriteH264(track, 0, 0, [][]byte{{ // IDR
5, 1,
}})
require.NoError(t, err)
err = bw.Flush()
require.NoError(t, err)
conn.Close() // trigger a flush
<-p.Unit
}()
_, err := os.Stat(pa)
require.Error(t, err)
})
}
}
================================================
FILE: internal/staticsources/rpicamera/camera_arm32_.go
================================================
//go:build linux && arm
package rpicamera
import (
"embed"
)
//go:embed mtxrpicam_32/*
var mtxrpicam embed.FS
================================================
FILE: internal/staticsources/rpicamera/camera_arm64_.go
================================================
//go:build linux && arm64
package rpicamera
import (
"embed"
)
//go:embed mtxrpicam_64/*
var mtxrpicam embed.FS
================================================
FILE: internal/staticsources/rpicamera/camera_arm_.go
================================================
//go:build (linux && arm) || (linux && arm64)
package rpicamera
import (
"debug/elf"
"fmt"
"os"
"os/exec"
"path/filepath"
"runtime"
"strconv"
"strings"
"sync"
"syscall"
"time"
"unsafe"
"github.com/bluenviron/mediacommon/v2/pkg/codecs/h264"
)
const (
libraryToCheckArchitecture = "libc.so.6"
dumpPrefix = "/dev/shm/mediamtx-rpicamera-"
executableName = "mtxrpicam"
)
var (
dumpMutex sync.Mutex
dumpCount = 0
dumpPath = ""
)
func ntpTime() syscall.Timespec {
var t syscall.Timespec
syscall.Syscall(syscall.SYS_CLOCK_GETTIME, 0, uintptr(unsafe.Pointer(&t)), 0)
return t
}
func monotonicTime() syscall.Timespec {
var t syscall.Timespec
syscall.Syscall(syscall.SYS_CLOCK_GETTIME, 1, uintptr(unsafe.Pointer(&t)), 0)
return t
}
func multiplyAndDivide(v, m, d int64) int64 {
secs := v / d
dec := v % d
return (secs*m + dec*m/d)
}
func getArchitecture(libPath string) (bool, error) {
f, err := os.Open(libPath)
if err != nil {
return false, err
}
defer f.Close()
ef, err := elf.NewFile(f)
if err != nil {
return false, err
}
defer ef.Close()
return (ef.FileHeader.Class == elf.ELFCLASS64), nil
}
func checkArchitecture() error {
byts, err := exec.Command("/sbin/ldconfig", "-p").Output()
if err != nil {
return fmt.Errorf("ldconfig failed: %w", err)
}
for _, line := range strings.Split(string(byts), "\n") {
f := strings.Split(line, " => ")
if len(f) == 2 && strings.Contains(f[1], libraryToCheckArchitecture) {
is64, err := getArchitecture(f[1])
if err != nil {
return err
}
if runtime.GOARCH == "arm" {
if !is64 {
return nil
}
} else {
if is64 {
return nil
}
}
}
}
if runtime.GOARCH == "arm" {
return fmt.Errorf("the operating system is 64-bit, you need the 64-bit server version")
}
return fmt.Errorf("the operating system is 32-bit, you need the 32-bit server version")
}
func dumpEmbedFSRecursive(src string, dest string) error {
files, err := mtxrpicam.ReadDir(src)
if err != nil {
return err
}
for _, f := range files {
if f.IsDir() {
err = os.Mkdir(filepath.Join(dest, f.Name()), 0o755)
if err != nil {
return err
}
err = dumpEmbedFSRecursive(filepath.Join(src, f.Name()), filepath.Join(dest, f.Name()))
if err != nil {
return err
}
} else {
buf, err := mtxrpicam.ReadFile(filepath.Join(src, f.Name()))
if err != nil {
return err
}
err = os.WriteFile(filepath.Join(dest, f.Name()), buf, 0o644)
if err != nil {
return err
}
}
}
return nil
}
func dumpComponent() error {
dumpMutex.Lock()
defer dumpMutex.Unlock()
if dumpCount > 0 {
dumpCount++
return nil
}
err := checkArchitecture()
if err != nil {
return err
}
dumpPath = dumpPrefix + strconv.FormatInt(time.Now().UnixNano(), 10)
err = os.Mkdir(dumpPath, 0o755)
if err != nil {
return err
}
files, err := mtxrpicam.ReadDir(".")
if err != nil {
os.RemoveAll(dumpPath)
return err
}
err = dumpEmbedFSRecursive(files[0].Name(), dumpPath)
if err != nil {
os.RemoveAll(dumpPath)
return err
}
err = os.Chmod(filepath.Join(dumpPath, executableName), 0o755)
if err != nil {
os.RemoveAll(dumpPath)
return err
}
dumpCount++
return nil
}
func freeComponent() {
dumpMutex.Lock()
defer dumpMutex.Unlock()
dumpCount--
if dumpCount == 0 {
os.RemoveAll(dumpPath)
}
}
type camera struct {
params params
onData func(int64, time.Time, [][]byte)
onDataSecondary func(int64, time.Time, []byte)
cmd *exec.Cmd
pipeOut *pipe
pipeIn *pipe
finalErr error
terminate chan struct{}
done chan struct{}
}
func (c *camera) initialize() error {
err := dumpComponent()
if err != nil {
return err
}
c.pipeOut, err = newPipe()
if err != nil {
freeComponent()
return err
}
c.pipeIn, err = newPipe()
if err != nil {
c.pipeOut.close()
freeComponent()
return err
}
env := []string{
"PIPE_CONF_FD=" + strconv.FormatInt(int64(c.pipeOut.readFD), 10),
"PIPE_VIDEO_FD=" + strconv.FormatInt(int64(c.pipeIn.writeFD), 10),
"LD_LIBRARY_PATH=" + dumpPath,
}
c.cmd = exec.Command(filepath.Join(dumpPath, executableName))
c.cmd.Stdout = os.Stdout
c.cmd.Stderr = os.Stderr
c.cmd.Env = env
c.cmd.Dir = dumpPath
// prevent the subprocess from receiving signals (in particular SIGINT and SIGTERM)
// from the parent process.
c.cmd.SysProcAttr = &syscall.SysProcAttr{
Setpgid: true,
}
err = c.cmd.Start()
if err != nil {
c.pipeOut.close()
c.pipeIn.close()
freeComponent()
return err
}
c.terminate = make(chan struct{})
c.done = make(chan struct{})
go c.run()
c.pipeOut.write(append([]byte{'c'}, c.params.serialize()...))
return nil
}
func (c *camera) close() {
close(c.terminate)
<-c.done
freeComponent()
}
func (c *camera) run() {
defer close(c.done)
c.finalErr = c.runInner()
}
func (c *camera) runInner() error {
cmdDone := make(chan error)
go func() {
cmdDone <- c.cmd.Wait()
}()
readDone := make(chan error)
go func() {
readDone <- c.runReader()
}()
for {
select {
case err := <-cmdDone:
c.pipeIn.close()
c.pipeOut.close()
<-readDone
return err
case err := <-readDone:
c.pipeOut.write([]byte{'e'})
<-cmdDone
c.pipeIn.close()
c.pipeOut.close()
return err
case <-c.terminate:
c.pipeOut.write([]byte{'e'})
<-cmdDone
c.pipeOut.close()
c.pipeIn.close()
<-readDone
return fmt.Errorf("terminated")
}
}
}
func (c *camera) runReader() error {
outer:
for {
buf, err := c.pipeIn.read()
if err != nil {
return err
}
switch buf[0] {
case 'e':
return fmt.Errorf(string(buf[1:]))
case 'r':
break outer
default:
return fmt.Errorf("unexpected data from pipe: '0x%.2x'", buf[0])
}
}
for {
buf, err := c.pipeIn.read()
if err != nil {
return err
}
switch buf[0] {
case 'e':
return fmt.Errorf(string(buf[1:]))
case 'd':
dts := int64(buf[8])<<56 | int64(buf[7])<<48 | int64(buf[6])<<40 | int64(buf[5])<<32 |
int64(buf[4])<<24 | int64(buf[3])<<16 | int64(buf[2])<<8 | int64(buf[1])
var nalus h264.AnnexB
err = nalus.Unmarshal(buf[9:])
if err != nil {
return err
}
unixNTP := ntpTime()
unixMono := monotonicTime()
// subtract from NTP the delay from now to the moment the frame was taken
ntp := time.Unix(int64(unixNTP.Sec), int64(unixNTP.Nsec))
deltaT := time.Duration(unixMono.Nano()-dts*1e3) * time.Nanosecond
ntp = ntp.Add(-deltaT)
c.onData(
multiplyAndDivide(dts, 90000, 1e6),
ntp,
nalus)
case 's':
dts := int64(buf[8])<<56 | int64(buf[7])<<48 | int64(buf[6])<<40 | int64(buf[5])<<32 |
int64(buf[4])<<24 | int64(buf[3])<<16 | int64(buf[2])<<8 | int64(buf[1])
unixNTP := ntpTime()
unixMono := monotonicTime()
// subtract from NTP the delay from now to the moment the frame was taken
ntp := time.Unix(int64(unixNTP.Sec), int64(unixNTP.Nsec))
deltaT := time.Duration(unixMono.Nano()-dts*1e3) * time.Nanosecond
ntp = ntp.Add(-deltaT)
c.onDataSecondary(
multiplyAndDivide(dts, 90000, 1e6),
ntp,
buf[9:])
default:
return fmt.Errorf("unexpected data from pipe: '0x%.2x'", buf[0])
}
}
}
func (c *camera) reloadParams(params params) {
c.pipeOut.write(append([]byte{'c'}, params.serialize()...))
}
func (c *camera) wait() error {
<-c.done
return c.finalErr
}
================================================
FILE: internal/staticsources/rpicamera/camera_other.go
================================================
//go:build !linux || (!arm && !arm64)
package rpicamera
import (
"fmt"
"time"
)
type camera struct {
params params
onData func(int64, time.Time, [][]byte)
onDataSecondary func(int64, time.Time, []byte)
}
func (c *camera) initialize() error {
return fmt.Errorf("server was compiled without support for the Raspberry Pi Camera")
}
func (c *camera) close() {
}
func (c *camera) reloadParams(_ params) {
}
func (c *camera) wait() error {
return nil
}
================================================
FILE: internal/staticsources/rpicamera/downloader.go
================================================
package rpicamera
//go:generate go run ./mtxrpicamdownloader
================================================
FILE: internal/staticsources/rpicamera/mtxrpicamdownloader/HASH_MTXRPICAM_32_TAR_GZ
================================================
f16657475469a8330f7fd5a801c1931d58be2c7e8f93cad318d298f2fbaff429
================================================
FILE: internal/staticsources/rpicamera/mtxrpicamdownloader/HASH_MTXRPICAM_64_TAR_GZ
================================================
c8ed15cc06b6b8604d6757ae01031809f75749f67a1e7b27d14dd161b75d71c2
================================================
FILE: internal/staticsources/rpicamera/mtxrpicamdownloader/VERSION
================================================
v2.5.4
================================================
FILE: internal/staticsources/rpicamera/mtxrpicamdownloader/main.go
================================================
// Package main contains an utility to download hls.js
package main
import (
"archive/tar"
"bytes"
"compress/gzip"
"crypto/sha256"
"encoding/hex"
"errors"
"fmt"
"io"
"log"
"net/http"
"os"
"strings"
)
func dumpTar(src io.Reader) error {
uncompressed, err := gzip.NewReader(src)
if err != nil {
return err
}
tr := tar.NewReader(uncompressed)
for {
var header *tar.Header
header, err = tr.Next()
if err != nil {
if errors.Is(err, io.EOF) {
break
}
return err
}
switch header.Typeflag {
case tar.TypeDir:
err = os.Mkdir(header.Name, header.FileInfo().Mode())
if err != nil {
return err
}
case tar.TypeReg:
var f *os.File
f, err = os.OpenFile(header.Name, os.O_WRONLY|os.O_CREATE, header.FileInfo().Mode())
if err != nil {
return err
}
defer f.Close()
_, err = io.Copy(f, tr)
if err != nil {
return err
}
}
}
return nil
}
func doSingle(version string, f string) error {
err := os.RemoveAll(strings.TrimSuffix(f, ".tar.gz"))
if err != nil {
return err
}
res, err := http.Get("https://github.com/bluenviron/mediamtx-rpicamera/releases/download/" + version + "/" + f)
if err != nil {
return err
}
defer res.Body.Close()
if res.StatusCode != http.StatusOK {
return fmt.Errorf("bad status code: %v", res.StatusCode)
}
buf, err := io.ReadAll(res.Body)
if err != nil {
return err
}
hashBuf, err := os.ReadFile("./mtxrpicamdownloader/HASH_" + strings.ToUpper(strings.ReplaceAll(f, ".", "_")))
if err != nil {
return err
}
str := strings.TrimSpace(string(hashBuf))
hash, err := hex.DecodeString(str)
if err != nil {
return err
}
if sum := sha256.Sum256(buf); !bytes.Equal(sum[:], hash) {
return fmt.Errorf("hash mismatch")
}
return dumpTar(bytes.NewReader(buf))
}
func do() error {
buf, err := os.ReadFile("./mtxrpicamdownloader/VERSION")
if err != nil {
return err
}
version := strings.TrimSpace(string(buf))
log.Printf("downloading mediamtx-rpicamera %s...", version)
for _, f := range []string{"mtxrpicam_32.tar.gz", "mtxrpicam_64.tar.gz"} {
err = doSingle(version, f)
if err != nil {
return err
}
}
log.Println("ok")
return nil
}
func main() {
err := do()
if err != nil {
log.Printf("ERR: %v", err)
os.Exit(1)
}
}
================================================
FILE: internal/staticsources/rpicamera/params.go
================================================
package rpicamera
type params struct {
LogLevel string
CameraID uint32
Width uint32
Height uint32
HFlip bool
VFlip bool
Brightness float32
Contrast float32
Saturation float32
Sharpness float32
Exposure string
AWB string
AWBGainRed float32
AWBGainBlue float32
Denoise string
Shutter uint32
Metering string
Gain float32
EV float32
ROI string
HDR bool
TuningFile string
Mode string
FPS float32
AfMode string
AfRange string
AfSpeed string
LensPosition float32
AfWindow string
FlickerPeriod uint32
TextOverlayEnable bool
TextOverlay string
Codec string
IDRPeriod uint32
Bitrate uint32
HardwareH264Profile string
HardwareH264Level string
SoftwareH264Profile string
SoftwareH264Level string
SecondaryWidth uint32
SecondaryHeight uint32
SecondaryFPS float32
SecondaryMJPEGQuality uint32
}
================================================
FILE: internal/staticsources/rpicamera/params_serialize.go
================================================
//go:build (linux && arm) || (linux && arm64)
package rpicamera
import (
"encoding/base64"
"reflect"
"strconv"
"strings"
)
func (p params) serialize() []byte {
rv := reflect.ValueOf(p)
rt := rv.Type()
nf := rv.NumField()
ret := make([]string, nf)
for i := range nf {
entry := rt.Field(i).Name + ":"
f := rv.Field(i)
v := f.Interface()
switch v := v.(type) {
case uint32:
entry += strconv.FormatUint(uint64(v), 10)
case float32:
entry += strconv.FormatFloat(float64(v), 'f', -1, 64)
case string:
entry += base64.StdEncoding.EncodeToString([]byte(v))
case bool:
if f.Bool() {
entry += "1"
} else {
entry += "0"
}
default:
panic("unhandled type")
}
ret[i] = entry
}
return []byte(strings.Join(ret, " "))
}
================================================
FILE: internal/staticsources/rpicamera/pipe.go
================================================
//go:build (linux && arm) || (linux && arm64)
package rpicamera
import (
"syscall"
)
func syscallReadAll(fd int, buf []byte) error {
size := len(buf)
read := 0
for {
n, err := syscall.Read(fd, buf[read:size])
if err != nil {
return err
}
read += n
if read >= size {
break
}
}
return nil
}
type pipe struct {
readFD int
writeFD int
}
func newPipe() (*pipe, error) {
fds := make([]int, 2)
err := syscall.Pipe(fds)
if err != nil {
return nil, err
}
return &pipe{
readFD: fds[0],
writeFD: fds[1],
}, nil
}
func (p *pipe) close() {
syscall.Close(p.readFD)
syscall.Close(p.writeFD)
}
func (p *pipe) read() ([]byte, error) {
buf := make([]byte, 4)
err := syscallReadAll(p.readFD, buf)
if err != nil {
return nil, err
}
le := int(buf[3])<<24 | int(buf[2])<<16 | int(buf[1])<<8 | int(buf[0])
buf = make([]byte, le)
err = syscallReadAll(p.readFD, buf)
if err != nil {
return nil, err
}
return buf, nil
}
func (p *pipe) write(byts []byte) error {
le := len(byts)
_, err := syscall.Write(p.writeFD, []byte{byte(le), byte(le >> 8), byte(le >> 16), byte(le >> 24)})
if err != nil {
return err
}
_, err = syscall.Write(p.writeFD, byts)
return err
}
================================================
FILE: internal/staticsources/rpicamera/source.go
================================================
// Package rpicamera contains the Raspberry Pi Camera static source.
package rpicamera
import (
"context"
"errors"
"fmt"
"time"
"github.com/bluenviron/gortsplib/v5/pkg/description"
"github.com/bluenviron/gortsplib/v5/pkg/format"
"github.com/bluenviron/gortsplib/v5/pkg/format/rtph264"
"github.com/bluenviron/gortsplib/v5/pkg/format/rtpmjpeg"
"github.com/pion/rtp"
"github.com/bluenviron/mediamtx/internal/conf"
"github.com/bluenviron/mediamtx/internal/defs"
"github.com/bluenviron/mediamtx/internal/logger"
"github.com/bluenviron/mediamtx/internal/stream"
"github.com/bluenviron/mediamtx/internal/unit"
)
const (
pauseBetweenErrors = 1 * time.Second
)
func paramsFromConf(logLevel conf.LogLevel, cnf *conf.Path) params {
return params{
LogLevel: func() string {
switch logLevel {
case conf.LogLevel(logger.Debug):
return "debug"
case conf.LogLevel(logger.Info):
return "info"
case conf.LogLevel(logger.Warn):
return "warn"
}
return "error"
}(),
CameraID: uint32(cnf.RPICameraCamID),
Width: uint32(cnf.RPICameraWidth),
Height: uint32(cnf.RPICameraHeight),
HFlip: cnf.RPICameraHFlip,
VFlip: cnf.RPICameraVFlip,
Brightness: float32(cnf.RPICameraBrightness),
Contrast: float32(cnf.RPICameraContrast),
Saturation: float32(cnf.RPICameraSaturation),
Sharpness: float32(cnf.RPICameraSharpness),
Exposure: cnf.RPICameraExposure,
AWB: cnf.RPICameraAWB,
AWBGainRed: float32(cnf.RPICameraAWBGains[0]),
AWBGainBlue: float32(cnf.RPICameraAWBGains[1]),
Denoise: cnf.RPICameraDenoise,
Shutter: uint32(cnf.RPICameraShutter),
Metering: cnf.RPICameraMetering,
Gain: float32(cnf.RPICameraGain),
EV: float32(cnf.RPICameraEV),
ROI: cnf.RPICameraROI,
HDR: cnf.RPICameraHDR,
TuningFile: cnf.RPICameraTuningFile,
Mode: cnf.RPICameraMode,
FPS: float32(cnf.RPICameraFPS),
AfMode: cnf.RPICameraAfMode,
AfRange: cnf.RPICameraAfRange,
AfSpeed: cnf.RPICameraAfSpeed,
LensPosition: float32(cnf.RPICameraLensPosition),
AfWindow: cnf.RPICameraAfWindow,
FlickerPeriod: uint32(cnf.RPICameraFlickerPeriod),
TextOverlayEnable: cnf.RPICameraTextOverlayEnable,
TextOverlay: cnf.RPICameraTextOverlay,
Codec: cnf.RPICameraCodec,
IDRPeriod: uint32(cnf.RPICameraIDRPeriod),
Bitrate: uint32(cnf.RPICameraBitrate),
HardwareH264Profile: cnf.RPICameraHardwareH264Profile,
HardwareH264Level: cnf.RPICameraHardwareH264Level,
SoftwareH264Profile: cnf.RPICameraSoftwareH264Profile,
SoftwareH264Level: cnf.RPICameraSoftwareH264Level,
SecondaryWidth: uint32(cnf.RPICameraSecondaryWidth),
SecondaryHeight: uint32(cnf.RPICameraSecondaryHeight),
SecondaryFPS: float32(cnf.RPICameraSecondaryFPS),
SecondaryMJPEGQuality: uint32(cnf.RPICameraSecondaryMJPEGQuality),
}
}
type secondaryReader struct {
ctx context.Context
ctxCancel func()
}
// Close implements reader.
func (r *secondaryReader) Close() {
r.ctxCancel()
}
// APIReaderDescribe implements reader.
func (*secondaryReader) APIReaderDescribe() *defs.APIPathReader {
return &defs.APIPathReader{
Type: defs.APIPathReaderTypeRPICameraSecondary,
ID: "",
}
}
type parent interface {
logger.Writer
SetReady(req defs.PathSourceStaticSetReadyReq) defs.PathSourceStaticSetReadyRes
SetNotReady(req defs.PathSourceStaticSetNotReadyReq)
AddReader(req defs.PathAddReaderReq) (*defs.PathAddReaderRes, error)
}
// Source is a Raspberry Pi Camera static source.
type Source struct {
RTPMaxPayloadSize int
LogLevel conf.LogLevel
Parent parent
}
// Log implements logger.Writer.
func (s *Source) Log(level logger.Level, format string, args ...any) {
s.Parent.Log(level, "[RPI Camera source] "+format, args...)
}
// Run implements StaticSource.
func (s *Source) Run(params defs.StaticSourceRunParams) error {
if !params.Conf.RPICameraSecondary {
return s.runPrimary(params)
}
return s.runSecondary(params)
}
func (s *Source) runPrimary(params defs.StaticSourceRunParams) error {
var medias []*description.Media
medi := &description.Media{
Type: description.MediaTypeVideo,
Formats: []format.Format{&format.H264{
PayloadTyp: 96,
PacketizationMode: 1,
}},
}
medias = append(medias, medi)
var mediaSecondary *description.Media
if params.Conf.RPICameraSecondaryWidth != 0 {
mediaSecondary = &description.Media{
Type: description.MediaTypeApplication,
Formats: []format.Format{&format.Generic{
PayloadTyp: 96,
RTPMa: "rpicamera_secondary/90000",
ClockRat: 90000,
}},
}
medias = append(medias, mediaSecondary)
}
var subStream *stream.SubStream
initializeStream := func() {
if subStream == nil {
res := s.Parent.SetReady(defs.PathSourceStaticSetReadyReq{
Desc: &description.Session{Medias: medias},
UseRTPPackets: true,
ReplaceNTP: false,
})
if res.Err != nil {
panic("should not happen")
}
subStream = res.SubStream
}
}
encH264 := &rtph264.Encoder{
PayloadType: 96,
PayloadMaxSize: s.RTPMaxPayloadSize,
}
err := encH264.Init()
if err != nil {
return err
}
onData := func(pts int64, ntp time.Time, au [][]byte) {
initializeStream()
pkts, err2 := encH264.Encode(au)
if err2 != nil {
s.Log(logger.Error, err2.Error())
return
}
for _, pkt := range pkts {
pkt.Timestamp = uint32(pts)
subStream.WriteUnit(medi, medi.Formats[0], &unit.Unit{
PTS: pts,
NTP: ntp,
RTPPackets: []*rtp.Packet{pkt},
})
}
}
var onDataSecondary func(pts int64, ntp time.Time, au []byte)
if params.Conf.RPICameraSecondaryWidth != 0 {
encJpeg := &rtpmjpeg.Encoder{
PayloadMaxSize: s.RTPMaxPayloadSize,
}
err = encJpeg.Init()
if err != nil {
panic(err)
}
onDataSecondary = func(pts int64, ntp time.Time, au []byte) {
initializeStream()
pkts, err2 := encJpeg.Encode(au)
if err2 != nil {
s.Log(logger.Error, err2.Error())
return
}
for _, pkt := range pkts {
pkt.Timestamp = uint32(pts)
pkt.PayloadType = 96
subStream.WriteUnit(mediaSecondary, mediaSecondary.Formats[0], &unit.Unit{
PTS: pts,
NTP: ntp,
RTPPackets: []*rtp.Packet{pkt},
})
}
}
}
defer func() {
if subStream != nil {
s.Parent.SetNotReady(defs.PathSourceStaticSetNotReadyReq{})
}
}()
cam := &camera{
params: paramsFromConf(s.LogLevel, params.Conf),
onData: onData,
onDataSecondary: onDataSecondary,
}
err = cam.initialize() //nolint:staticcheck
if err != nil { //nolint:staticcheck
return err
}
defer cam.close()
cameraErr := make(chan error)
go func() {
cameraErr <- cam.wait()
}()
for {
select {
case err = <-cameraErr:
return err
case cnf := <-params.ReloadConf:
cam.reloadParams(paramsFromConf(s.LogLevel, cnf))
case <-params.Context.Done():
return nil
}
}
}
func (s *Source) runSecondary(params defs.StaticSourceRunParams) error {
r := &secondaryReader{}
r.ctx, r.ctxCancel = context.WithCancel(context.Background())
defer r.ctxCancel()
path, primaryStream, err := s.waitForPrimary(r, params)
if err != nil {
return err
}
defer path.RemoveReader(defs.PathRemoveReaderReq{Author: r})
media := &description.Media{
Type: description.MediaTypeVideo,
Formats: []format.Format{&format.MJPEG{}},
}
res := s.Parent.SetReady(defs.PathSourceStaticSetReadyReq{
Desc: &description.Session{Medias: []*description.Media{media}},
UseRTPPackets: true,
})
if res.Err != nil {
return res.Err
}
rdr := &stream.Reader{Parent: s}
rdr.OnData(
primaryStream.Desc.Medias[1],
primaryStream.Desc.Medias[1].Formats[0],
func(u *unit.Unit) error {
pkt := u.RTPPackets[0]
newPkt := &rtp.Packet{
Header: pkt.Header,
Payload: pkt.Payload,
}
newPkt.PayloadType = 26
res.SubStream.WriteUnit(media, media.Formats[0], &unit.Unit{
PTS: u.PTS,
NTP: u.NTP,
RTPPackets: []*rtp.Packet{newPkt},
})
return nil
})
primaryStream.AddReader(rdr)
defer primaryStream.RemoveReader(rdr)
select {
case err = <-rdr.Error():
return err
case <-r.ctx.Done():
return fmt.Errorf("primary stream closed")
case <-params.Context.Done():
return fmt.Errorf("terminated")
}
}
func (s *Source) waitForPrimary(
r *secondaryReader,
params defs.StaticSourceRunParams,
) (defs.Path, *stream.Stream, error) {
for {
res, err := s.Parent.AddReader(defs.PathAddReaderReq{
Author: r,
AccessRequest: defs.PathAccessRequest{
Name: params.Conf.RPICameraPrimaryName,
SkipAuth: true,
},
})
if err != nil {
var err2 defs.PathNoStreamAvailableError
if errors.As(err, &err2) {
select {
case <-time.After(pauseBetweenErrors):
case <-params.Context.Done():
return nil, nil, fmt.Errorf("terminated")
}
continue
}
return nil, nil, err
}
return res.Path, res.Stream, nil
}
}
// APISourceDescribe implements StaticSource.
func (*Source) APISourceDescribe() *defs.APIPathSource {
return &defs.APIPathSource{
Type: defs.APIPathSourceTypeRPICameraSource,
ID: "",
}
}
================================================
FILE: internal/staticsources/rtmp/source.go
================================================
// Package rtmp contains the RTMP static source.
package rtmp
import (
"context"
"fmt"
"net"
"net/url"
"time"
"github.com/bluenviron/gortmplib"
"github.com/bluenviron/gortsplib/v5/pkg/description"
"github.com/bluenviron/mediamtx/internal/conf"
"github.com/bluenviron/mediamtx/internal/defs"
"github.com/bluenviron/mediamtx/internal/logger"
"github.com/bluenviron/mediamtx/internal/packetdumper"
"github.com/bluenviron/mediamtx/internal/protocols/rtmp"
"github.com/bluenviron/mediamtx/internal/protocols/tls"
"github.com/bluenviron/mediamtx/internal/stream"
)
type parent interface {
logger.Writer
SetReady(req defs.PathSourceStaticSetReadyReq) defs.PathSourceStaticSetReadyRes
SetNotReady(req defs.PathSourceStaticSetNotReadyReq)
}
// Source is a RTMP static source.
type Source struct {
DumpPackets bool
ReadTimeout conf.Duration
WriteTimeout conf.Duration
Parent parent
}
// Log implements logger.Writer.
func (s *Source) Log(level logger.Level, format string, args ...any) {
s.Parent.Log(level, "[RTMP source] "+format, args...)
}
// Run implements StaticSource.
func (s *Source) Run(params defs.StaticSourceRunParams) error {
s.Log(logger.Debug, "connecting")
u, err := url.Parse(params.ResolvedSource)
if err != nil {
return err
}
// add default port
_, _, err = net.SplitHostPort(u.Host)
if err != nil {
if u.Scheme == "rtmp" {
u.Host = net.JoinHostPort(u.Host, "1935")
} else {
u.Host = net.JoinHostPort(u.Host, "1936")
}
}
dialContext := (&net.Dialer{}).DialContext
if s.DumpPackets {
dialContext = (&packetdumper.DialContext{
Prefix: "rtmp_source_conn",
DialContext: dialContext,
}).Do
}
connectCtx, connectCtxCancel := context.WithTimeout(params.Context, time.Duration(s.ReadTimeout))
conn := &gortmplib.Client{
URL: u,
TLSConfig: tls.MakeConfig(u.Hostname(), params.Conf.SourceFingerprint),
Publish: false,
DialContext: dialContext,
}
err = conn.Initialize(connectCtx)
connectCtxCancel()
if err != nil {
return err
}
readDone := make(chan error)
go func() {
readDone <- s.runReader(conn)
}()
for {
select {
case err = <-readDone:
conn.Close()
return err
case <-params.ReloadConf:
case <-params.Context.Done():
conn.Close()
<-readDone
return nil
}
}
}
func (s *Source) runReader(conn *gortmplib.Client) error {
conn.NetConn().SetReadDeadline(time.Now().Add(time.Duration(s.ReadTimeout)))
conn.NetConn().SetWriteDeadline(time.Now().Add(time.Duration(s.WriteTimeout)))
r := &gortmplib.Reader{
Conn: conn,
}
err := r.Initialize()
if err != nil {
return err
}
var subStream *stream.SubStream
medias, err := rtmp.ToStream(r, &subStream)
if err != nil {
return err
}
if len(medias) == 0 {
return fmt.Errorf("no supported tracks found")
}
res := s.Parent.SetReady(defs.PathSourceStaticSetReadyReq{
Desc: &description.Session{Medias: medias},
UseRTPPackets: false,
ReplaceNTP: true,
})
if res.Err != nil {
return res.Err
}
defer s.Parent.SetNotReady(defs.PathSourceStaticSetNotReadyReq{})
subStream = res.SubStream
conn.NetConn().SetWriteDeadline(time.Time{})
for {
conn.NetConn().SetReadDeadline(time.Now().Add(time.Duration(s.ReadTimeout)))
err = r.Read()
if err != nil {
return err
}
}
}
// APISourceDescribe implements StaticSource.
func (*Source) APISourceDescribe() *defs.APIPathSource {
return &defs.APIPathSource{
Type: defs.APIPathSourceTypeRTMPSource,
ID: "",
}
}
================================================
FILE: internal/staticsources/rtmp/source_test.go
================================================
package rtmp
import (
"context"
"crypto/tls"
"net"
"os"
"testing"
"time"
"github.com/stretchr/testify/require"
"github.com/bluenviron/gortmplib"
"github.com/bluenviron/gortmplib/pkg/codecs"
"github.com/bluenviron/mediamtx/internal/conf"
"github.com/bluenviron/mediamtx/internal/defs"
"github.com/bluenviron/mediamtx/internal/test"
)
func TestSource(t *testing.T) {
for _, encryption := range []string{
"plain",
"tls",
} {
for _, auth := range []string{
"no auth",
"auth",
} {
t.Run(encryption+"_"+auth, func(t *testing.T) {
var ln net.Listener
if encryption == "plain" {
var err error
ln, err = net.Listen("tcp", "127.0.0.1:1935")
require.NoError(t, err)
} else {
serverCertFpath, err := test.CreateTempFile(test.TLSCertPub)
require.NoError(t, err)
defer os.Remove(serverCertFpath)
serverKeyFpath, err := test.CreateTempFile(test.TLSCertKey)
require.NoError(t, err)
defer os.Remove(serverKeyFpath)
var cert tls.Certificate
cert, err = tls.LoadX509KeyPair(serverCertFpath, serverKeyFpath)
require.NoError(t, err)
ln, err = tls.Listen("tcp", "127.0.0.1:1936", &tls.Config{Certificates: []tls.Certificate{cert}})
require.NoError(t, err)
}
defer ln.Close()
var source string
if encryption == "plain" {
source = "rtmp://"
} else {
source = "rtmps://"
}
if auth == "auth" {
source += "myuser:mypass@"
}
source += "localhost/teststream"
p := &test.StaticSourceParent{}
p.Initialize()
defer p.Close()
so := &Source{
ReadTimeout: conf.Duration(10 * time.Second),
WriteTimeout: conf.Duration(10 * time.Second),
Parent: p,
}
done := make(chan struct{})
defer func() { <-done }()
ctx, ctxCancel := context.WithCancel(context.Background())
defer ctxCancel()
reloadConf := make(chan *conf.Path)
go func() {
so.Run(defs.StaticSourceRunParams{ //nolint:errcheck
Context: ctx,
ResolvedSource: source,
Conf: &conf.Path{
SourceFingerprint: "33949E05FFFB5FF3E8AA16F8213A6251B4D9363804BA53233C4DA9A46D6F2739",
},
ReloadConf: reloadConf,
})
close(done)
}()
for {
nconn, err := ln.Accept()
require.NoError(t, err)
defer nconn.Close()
conn := &gortmplib.ServerConn{
RW: nconn,
}
err = conn.Initialize()
require.NoError(t, err)
if auth == "auth" {
err = conn.CheckCredentials("myuser", "mypass")
if err != nil {
continue
}
}
err = conn.Accept()
require.NoError(t, err)
w := &gortmplib.Writer{
Conn: conn,
Tracks: []*gortmplib.Track{
{Codec: &codecs.H264{
SPS: test.FormatH264.SPS,
PPS: test.FormatH264.PPS,
}},
{Codec: &codecs.MPEG4Audio{
Config: test.FormatMPEG4Audio.Config,
}},
},
}
err = w.Initialize()
require.NoError(t, err)
err = w.WriteMPEG4Audio(w.Tracks[1], 2*time.Second, []byte{5, 2, 3, 4})
require.NoError(t, err)
break
}
<-p.Unit
// the source must be listening on ReloadConf
reloadConf <- nil
})
}
}
}
================================================
FILE: internal/staticsources/rtp/format.go
================================================
package rtp
import (
"time"
"github.com/bluenviron/gortsplib/v5/pkg/format"
"github.com/bluenviron/gortsplib/v5/pkg/rtpreceiver"
"github.com/pion/rtcp"
)
type rtpFormat struct {
desc format.Format
rtpReceiver *rtpreceiver.Receiver
}
func (f *rtpFormat) initialize() {
f.rtpReceiver = &rtpreceiver.Receiver{
ClockRate: f.desc.ClockRate(),
UnrealiableTransport: true,
Period: 10 * time.Second,
WritePacketRTCP: func(_ rtcp.Packet) {
},
}
}
================================================
FILE: internal/staticsources/rtp/media.go
================================================
package rtp
import "github.com/bluenviron/gortsplib/v5/pkg/description"
type rtpMedia struct {
desc *description.Media
}
================================================
FILE: internal/staticsources/rtp/source.go
================================================
// Package rtp contains the RTP static source.
package rtp
import (
"fmt"
"net"
"net/url"
"time"
"github.com/bluenviron/gortsplib/v5/pkg/description"
"github.com/bluenviron/gortsplib/v5/pkg/rtptime"
"github.com/bluenviron/gortsplib/v5/pkg/sdp"
"github.com/bluenviron/mediamtx/internal/conf"
"github.com/bluenviron/mediamtx/internal/counterdumper"
"github.com/bluenviron/mediamtx/internal/defs"
"github.com/bluenviron/mediamtx/internal/errordumper"
"github.com/bluenviron/mediamtx/internal/logger"
"github.com/bluenviron/mediamtx/internal/packetdumper"
"github.com/bluenviron/mediamtx/internal/protocols/udp"
"github.com/bluenviron/mediamtx/internal/protocols/unix"
"github.com/bluenviron/mediamtx/internal/stream"
"github.com/bluenviron/mediamtx/internal/unit"
"github.com/pion/rtp"
)
type parent interface {
logger.Writer
SetReady(req defs.PathSourceStaticSetReadyReq) defs.PathSourceStaticSetReadyRes
SetNotReady(req defs.PathSourceStaticSetNotReadyReq)
}
// Source is a RTP static source.
type Source struct {
DumpPackets bool
ReadTimeout conf.Duration
UDPReadBufferSize uint
Parent parent
}
// Log implements logger.Writer.
func (s *Source) Log(level logger.Level, format string, args ...any) {
s.Parent.Log(level, "[RTP source] "+format, args...)
}
// Run implements StaticSource.
func (s *Source) Run(params defs.StaticSourceRunParams) error {
var sd sdp.SessionDescription
err := sd.Unmarshal([]byte(params.Conf.RTPSDP))
if err != nil {
return err
}
var desc description.Session
err = desc.Unmarshal(&sd)
if err != nil {
return err
}
s.Log(logger.Debug, "connecting")
u, err := url.Parse(params.ResolvedSource)
if err != nil {
return err
}
var nc net.Conn
switch u.Scheme {
case "unix+rtp":
params := unix.URLToParams(u)
l := &unix.Listener{
Path: params.Path,
}
err = l.Initialize()
if err != nil {
return err
}
nc = l
default:
udpReadBufferSize := s.UDPReadBufferSize
if params.Conf.RTPUDPReadBufferSize != nil {
udpReadBufferSize = *params.Conf.RTPUDPReadBufferSize
}
listenPacket := net.ListenPacket
if s.DumpPackets {
listenPacket = func(network, address string) (net.PacketConn, error) {
pc, err2 := net.ListenPacket(network, address)
if err2 != nil {
return nil, err2
}
d := &packetdumper.PacketConn{
Prefix: "rtp_source_packetconn",
PacketConn: pc,
}
err2 = d.Initialize()
if err2 != nil {
return nil, err2
}
return d, nil
}
}
params := udp.URLToParams(u)
l := &udp.Listener{
Address: params.Address,
Source: params.Source,
IntfName: params.IntfName,
UDPReadBufferSize: int(udpReadBufferSize),
ListenPacket: listenPacket,
}
err = l.Initialize()
if err != nil {
return err
}
nc = l
}
readerErr := make(chan error)
go func() {
readerErr <- s.runReader(&desc, nc)
}()
for {
select {
case err = <-readerErr:
nc.Close()
return err
case <-params.ReloadConf:
case <-params.Context.Done():
nc.Close()
<-readerErr
return fmt.Errorf("terminated")
}
}
}
func (s *Source) runReader(desc *description.Session, nc net.Conn) error {
packetsLost := &counterdumper.Dumper{
OnReport: func(val uint64) {
s.Log(logger.Warn, "%d RTP %s lost",
val,
func() string {
if val == 1 {
return "packet"
}
return "packets"
}())
},
}
packetsLost.Start()
defer packetsLost.Stop()
decodeErrors := &errordumper.Dumper{
OnReport: func(val uint64, last error) {
if val == 1 {
s.Log(logger.Warn, "decode error: %v", last)
} else {
s.Log(logger.Warn, "%d decode errors, last was: %v", val, last)
}
},
}
decodeErrors.Start()
defer decodeErrors.Stop()
var subStream *stream.SubStream
timeDecoder := &rtptime.GlobalDecoder{}
timeDecoder.Initialize()
mediasByPayloadType := make(map[uint8]*rtpMedia)
formatsByPayloadType := make(map[uint8]*rtpFormat)
for _, descMedia := range desc.Medias {
rtpMedia := &rtpMedia{
desc: descMedia,
}
for _, descFormat := range descMedia.Formats {
rtpFormat := &rtpFormat{
desc: descFormat,
}
rtpFormat.initialize()
mediasByPayloadType[descFormat.PayloadType()] = rtpMedia
formatsByPayloadType[descFormat.PayloadType()] = rtpFormat
}
}
for {
buf := make([]byte, 1500)
nc.SetReadDeadline(time.Now().Add(time.Duration(s.ReadTimeout)))
n, err := nc.Read(buf)
if err != nil {
return err
}
var pkt rtp.Packet
err = pkt.Unmarshal(buf[:n])
if err != nil {
if subStream != nil {
decodeErrors.Add(err)
continue
}
return err
}
if subStream == nil {
res := s.Parent.SetReady(defs.PathSourceStaticSetReadyReq{
Desc: desc,
UseRTPPackets: true,
ReplaceNTP: true,
})
if res.Err != nil {
return res.Err
}
defer s.Parent.SetNotReady(defs.PathSourceStaticSetNotReadyReq{})
subStream = res.SubStream
}
media, ok := mediasByPayloadType[pkt.PayloadType]
if !ok {
continue
}
forma := formatsByPayloadType[pkt.PayloadType]
pkts, lost := forma.rtpReceiver.ProcessPacket2(&pkt, time.Now(), forma.desc.PTSEqualsDTS(&pkt))
if lost != 0 {
packetsLost.Add(lost)
}
for _, pkt := range pkts {
pts, ok2 := timeDecoder.Decode(forma.desc, pkt)
if !ok2 {
continue
}
subStream.WriteUnit(media.desc, forma.desc, &unit.Unit{
PTS: pts,
RTPPackets: []*rtp.Packet{pkt},
})
}
}
}
// APISourceDescribe implements StaticSource.
func (*Source) APISourceDescribe() *defs.APIPathSource {
return &defs.APIPathSource{
Type: defs.APIPathSourceTypeRTPSource,
ID: "",
}
}
================================================
FILE: internal/staticsources/rtp/source_test.go
================================================
package rtp
import (
"context"
"net"
"os"
"path/filepath"
"testing"
"time"
"github.com/bluenviron/gortsplib/v5/pkg/format/rtph264"
"github.com/stretchr/testify/require"
"github.com/bluenviron/mediamtx/internal/conf"
"github.com/bluenviron/mediamtx/internal/defs"
"github.com/bluenviron/mediamtx/internal/test"
)
func multicastCapableInterface(t *testing.T) string {
intfs, err := net.Interfaces()
require.NoError(t, err)
for _, intf := range intfs {
if (intf.Flags & net.FlagMulticast) != 0 {
return intf.Name
}
}
t.Errorf("unable to find a multicast IP")
return ""
}
func TestSourceUDP(t *testing.T) {
for _, ca := range []string{
"unicast",
"multicast",
"multicast with interface",
"unicast with source",
} {
t.Run(ca, func(t *testing.T) {
var src string
switch ca {
case "unicast":
src = "udp+rtp://127.0.0.1:9004"
case "multicast":
src = "udp+rtp://238.0.0.1:9004"
case "multicast with interface":
src = "udp+rtp://238.0.0.1:9004?interface=" + multicastCapableInterface(t)
case "unicast with source":
src = "udp+rtp://127.0.0.1:9004?source=127.0.1.1"
}
p := &test.StaticSourceParent{}
p.Initialize()
defer p.Close()
so := &Source{
ReadTimeout: conf.Duration(10 * time.Second),
Parent: p,
}
done := make(chan struct{})
defer func() { <-done }()
ctx, ctxCancel := context.WithCancel(context.Background())
defer ctxCancel()
reloadConf := make(chan *conf.Path)
go func() {
so.Run(defs.StaticSourceRunParams{ //nolint:errcheck
Context: ctx,
ResolvedSource: src,
Conf: &conf.Path{
RTPSDP: "v=0\n" +
"o=- 123456789 123456789 IN IP4 192.168.1.100\n" +
"s=H264 Video Stream\n" +
"c=IN IP4 192.168.1.100\n" +
"t=0 0\n" +
"m=video 5004 RTP/AVP 96\n" +
"a=rtpmap:96 H264/90000\n" +
"a=fmtp:96 profile-level-id=42e01e;packetization-mode=1\n",
},
ReloadConf: reloadConf,
})
close(done)
}()
time.Sleep(50 * time.Millisecond)
var dest string
switch ca {
case "unicast":
dest = "127.0.0.1:9004"
case "multicast":
dest = "238.0.0.1:9004"
case "multicast with interface":
dest = "238.0.0.1:9004"
case "unicast with source":
dest = "127.0.0.1:9004"
}
udest, err := net.ResolveUDPAddr("udp", dest)
require.NoError(t, err)
var usrc *net.UDPAddr
if ca == "unicast with source" {
usrc, err = net.ResolveUDPAddr("udp", "127.0.1.1:9020")
require.NoError(t, err)
}
conn, err := net.DialUDP("udp", usrc, udest)
require.NoError(t, err)
defer conn.Close() //nolint:errcheck
enc := &rtph264.Encoder{
PayloadType: 96,
}
err = enc.Init()
require.NoError(t, err)
pkts, err := enc.Encode([][]byte{
{5, 1},
})
require.NoError(t, err)
for _, pkt := range pkts {
var buf []byte
buf, err = pkt.Marshal()
require.NoError(t, err)
_, err = conn.Write(buf)
require.NoError(t, err)
}
<-p.Unit
// the source must be listening on ReloadConf
reloadConf <- nil
})
}
}
func TestSourceUnixSocket(t *testing.T) {
for _, ca := range []string{
"relative",
"absolute",
} {
t.Run(ca, func(t *testing.T) {
var pa string
if ca == "relative" {
pa = "test_rtp.sock"
} else {
pa = filepath.Join(os.TempDir(), "test_rtp.sock")
}
func() {
p := &test.StaticSourceParent{}
p.Initialize()
defer p.Close()
so := &Source{
ReadTimeout: conf.Duration(10 * time.Second),
Parent: p,
}
done := make(chan struct{})
defer func() { <-done }()
ctx, ctxCancel := context.WithCancel(context.Background())
defer ctxCancel()
go func() {
so.Run(defs.StaticSourceRunParams{ //nolint:errcheck
Context: ctx,
ResolvedSource: "unix+rtp://" + pa,
Conf: &conf.Path{
RTPSDP: "v=0\n" +
"o=- 123456789 123456789 IN IP4 192.168.1.100\n" +
"s=H264 Video Stream\n" +
"c=IN IP4 192.168.1.100\n" +
"t=0 0\n" +
"m=video 5004 RTP/AVP 96\n" +
"a=rtpmap:96 H264/90000\n" +
"a=fmtp:96 profile-level-id=42e01e;packetization-mode=1\n",
},
})
close(done)
}()
time.Sleep(50 * time.Millisecond)
_, err := os.Stat(pa)
require.NoError(t, err)
conn, err := net.Dial("unix", pa)
require.NoError(t, err)
defer conn.Close()
enc := &rtph264.Encoder{
PayloadType: 96,
}
err = enc.Init()
require.NoError(t, err)
pkts, err := enc.Encode([][]byte{
{5, 1},
})
require.NoError(t, err)
for _, pkt := range pkts {
var buf []byte
buf, err = pkt.Marshal()
require.NoError(t, err)
_, err = conn.Write(buf)
require.NoError(t, err)
}
<-p.Unit
}()
_, err := os.Stat(pa)
require.Error(t, err)
})
}
}
================================================
FILE: internal/staticsources/rtsp/source.go
================================================
// Package rtsp contains the RTSP static source.
package rtsp
import (
"fmt"
"net"
"net/url"
"time"
"github.com/bluenviron/gortsplib/v5"
"github.com/bluenviron/gortsplib/v5/pkg/base"
"github.com/bluenviron/gortsplib/v5/pkg/description"
"github.com/bluenviron/gortsplib/v5/pkg/headers"
"github.com/bluenviron/mediamtx/internal/conf"
"github.com/bluenviron/mediamtx/internal/counterdumper"
"github.com/bluenviron/mediamtx/internal/defs"
"github.com/bluenviron/mediamtx/internal/errordumper"
"github.com/bluenviron/mediamtx/internal/logger"
"github.com/bluenviron/mediamtx/internal/packetdumper"
"github.com/bluenviron/mediamtx/internal/protocols/rtsp"
"github.com/bluenviron/mediamtx/internal/protocols/tls"
"github.com/bluenviron/mediamtx/internal/stream"
)
func createRangeHeader(cnf *conf.Path) (*headers.Range, error) {
switch cnf.RTSPRangeType {
case conf.RTSPRangeTypeClock:
start, err := time.Parse("20060102T150405Z", cnf.RTSPRangeStart)
if err != nil {
return nil, err
}
return &headers.Range{
Value: &headers.RangeUTC{
Start: start,
},
}, nil
case conf.RTSPRangeTypeNPT:
start, err := time.ParseDuration(cnf.RTSPRangeStart)
if err != nil {
return nil, err
}
return &headers.Range{
Value: &headers.RangeNPT{
Start: start,
},
}, nil
case conf.RTSPRangeTypeSMPTE:
start, err := time.ParseDuration(cnf.RTSPRangeStart)
if err != nil {
return nil, err
}
return &headers.Range{
Value: &headers.RangeSMPTE{
Start: headers.RangeSMPTETime{
Time: start,
},
},
}, nil
default:
return nil, nil
}
}
type parent interface {
logger.Writer
SetReady(req defs.PathSourceStaticSetReadyReq) defs.PathSourceStaticSetReadyRes
SetNotReady(req defs.PathSourceStaticSetNotReadyReq)
}
// Source is a RTSP static source.
type Source struct {
DumpPackets bool
ReadTimeout conf.Duration
WriteTimeout conf.Duration
WriteQueueSize int
UDPReadBufferSize uint
Parent parent
}
// Log implements logger.Writer.
func (s *Source) Log(level logger.Level, format string, args ...any) {
s.Parent.Log(level, "[RTSP source] "+format, args...)
}
// Run implements StaticSource.
func (s *Source) Run(params defs.StaticSourceRunParams) error {
s.Log(logger.Debug, "connecting")
packetsLost := &counterdumper.Dumper{
OnReport: func(val uint64) {
s.Log(logger.Warn, "%d RTP %s lost",
val,
func() string {
if val == 1 {
return "packet"
}
return "packets"
}())
},
}
packetsLost.Start()
defer packetsLost.Stop()
decodeErrors := &errordumper.Dumper{
OnReport: func(val uint64, last error) {
if val == 1 {
s.Log(logger.Warn, "decode error: %v", last)
} else {
s.Log(logger.Warn, "%d decode errors, last was: %v", val, last)
}
},
}
decodeErrors.Start()
defer decodeErrors.Stop()
c := &gortsplib.Client{
Protocol: params.Conf.RTSPTransport.Protocol,
ReadTimeout: time.Duration(s.ReadTimeout),
WriteTimeout: time.Duration(s.WriteTimeout),
UDPReadBufferSize: int(s.UDPReadBufferSize),
WriteQueueSize: s.WriteQueueSize,
AnyPortEnable: params.Conf.RTSPAnyPort,
UDPSourcePortRange: [2]uint16{
uint16(params.Conf.RTSPUDPSourcePortRange[0]),
uint16(params.Conf.RTSPUDPSourcePortRange[1]),
},
OnRequest: func(req *base.Request) {
s.Log(logger.Debug, "[c->s] %v", req)
},
OnResponse: func(res *base.Response) {
s.Log(logger.Debug, "[s->c] %v", res)
},
OnTransportSwitch: func(err error) {
s.Log(logger.Warn, err.Error())
},
OnPacketsLost: func(lost uint64) {
packetsLost.Add(lost)
},
OnDecodeError: func(err error) {
decodeErrors.Add(err)
},
}
u0, err := url.Parse(params.ResolvedSource)
if err != nil {
return err
}
switch u0.Scheme {
case "rtsp+http", "rtsps+http":
c.Tunnel = gortsplib.TunnelHTTP
case "rtsp+ws", "rtsps+ws":
c.Tunnel = gortsplib.TunnelWebSocket
}
switch u0.Scheme {
case "rtsp", "rtsp+http", "rtsp+ws":
u0.Scheme = "rtsp"
default:
u0.Scheme = "rtsps"
c.TLSConfig = tls.MakeConfig(u0.Hostname(), params.Conf.SourceFingerprint)
}
u, err := base.ParseURL(u0.String())
if err != nil {
return err
}
c.Scheme = u.Scheme
c.Host = u.Host
if params.Conf.RTSPUDPReadBufferSize != nil {
s.UDPReadBufferSize = *params.Conf.RTSPUDPReadBufferSize
}
if s.DumpPackets {
c.DialContext = (&packetdumper.DialContext{
Prefix: "rtsp_source_conn",
DialContext: (&net.Dialer{}).DialContext,
}).Do
c.ListenPacket = (&packetdumper.ListenPacket{
Prefix: "rtsp_source_packetconn",
ListenPacket: net.ListenPacket,
}).Do
}
err = c.Start()
if err != nil {
return err
}
defer c.Close()
readErr := make(chan error)
go func() {
readErr <- s.runInner(c, u, params.Conf)
}()
for {
select {
case err = <-readErr:
return err
case <-params.ReloadConf:
case <-params.Context.Done():
c.Close()
<-readErr
return nil
}
}
}
func (s *Source) runInner(c *gortsplib.Client, u *base.URL, pathConf *conf.Path) error {
desc, _, err := c.Describe(u)
if err != nil {
return err
}
var medias []*description.Media
for _, m := range desc.Medias {
if !m.IsBackChannel {
_, err = c.Setup(desc.BaseURL, m, 0, 0)
if err != nil {
return err
}
medias = append(medias, m)
}
}
if medias == nil {
return fmt.Errorf("no medias have been setupped")
}
desc2 := &description.Session{
Title: desc.Title,
Medias: medias,
}
var subStream *stream.SubStream
rtsp.ToStream(
c,
desc2.Medias,
pathConf,
&subStream,
s)
res := s.Parent.SetReady(defs.PathSourceStaticSetReadyReq{
Desc: desc2,
UseRTPPackets: true,
ReplaceNTP: !pathConf.UseAbsoluteTimestamp,
})
if res.Err != nil {
return res.Err
}
defer s.Parent.SetNotReady(defs.PathSourceStaticSetNotReadyReq{})
subStream = res.SubStream
rangeHeader, err := createRangeHeader(pathConf)
if err != nil {
return err
}
_, err = c.Play(rangeHeader)
if err != nil {
return err
}
return c.Wait()
}
// APISourceDescribe implements StaticSource.
func (*Source) APISourceDescribe() *defs.APIPathSource {
return &defs.APIPathSource{
Type: defs.APIPathSourceTypeRTSPSource,
ID: "",
}
}
================================================
FILE: internal/staticsources/rtsp/source_test.go
================================================
package rtsp
import (
"context"
"crypto/tls"
"os"
"testing"
"time"
"github.com/bluenviron/gortsplib/v5"
"github.com/bluenviron/gortsplib/v5/pkg/auth"
"github.com/bluenviron/gortsplib/v5/pkg/base"
"github.com/bluenviron/gortsplib/v5/pkg/description"
"github.com/bluenviron/gortsplib/v5/pkg/format"
"github.com/pion/rtp"
"github.com/stretchr/testify/require"
"github.com/bluenviron/mediamtx/internal/conf"
"github.com/bluenviron/mediamtx/internal/defs"
"github.com/bluenviron/mediamtx/internal/test"
)
func ptrOf[T any](v T) *T {
p := new(T)
*p = v
return p
}
type testServer struct {
onDescribe func(*gortsplib.ServerHandlerOnDescribeCtx) (*base.Response, *gortsplib.ServerStream, error)
onSetup func(*gortsplib.ServerHandlerOnSetupCtx) (*base.Response, *gortsplib.ServerStream, error)
onPlay func(*gortsplib.ServerHandlerOnPlayCtx) (*base.Response, error)
}
func (sh *testServer) OnDescribe(ctx *gortsplib.ServerHandlerOnDescribeCtx,
) (*base.Response, *gortsplib.ServerStream, error) {
return sh.onDescribe(ctx)
}
func (sh *testServer) OnSetup(ctx *gortsplib.ServerHandlerOnSetupCtx) (*base.Response, *gortsplib.ServerStream, error) {
return sh.onSetup(ctx)
}
func (sh *testServer) OnPlay(ctx *gortsplib.ServerHandlerOnPlayCtx) (*base.Response, error) {
return sh.onPlay(ctx)
}
func TestSource(t *testing.T) {
for _, ca := range []string{
"udp",
"tcp",
"rtsps",
"rtsp+http",
"rtsps+http",
"rtsp+ws",
"rtsps+ws",
} {
t.Run(ca, func(t *testing.T) {
var strm *gortsplib.ServerStream
nonce, err := auth.GenerateNonce()
require.NoError(t, err)
media0 := test.UniqueMediaH264()
s := gortsplib.Server{
Handler: &testServer{
onDescribe: func(ctx *gortsplib.ServerHandlerOnDescribeCtx,
) (*base.Response, *gortsplib.ServerStream, error) {
switch ca {
case "rtsp+http", "rtsps+http":
require.Equal(t, gortsplib.TunnelHTTP, ctx.Conn.Transport().Tunnel)
case "rtsp+ws", "rtsps+ws":
require.Equal(t, gortsplib.TunnelWebSocket, ctx.Conn.Transport().Tunnel)
}
switch ca {
case "rtsps", "rtsps+http", "rtsps+ws":
require.Equal(t, "rtsps", ctx.Request.URL.Scheme)
default:
require.Equal(t, "rtsp", ctx.Request.URL.Scheme)
}
err2 := auth.Verify(ctx.Request, "testuser", "testpass", nil, "IPCAM", nonce)
if err2 != nil {
return &base.Response{ //nolint:nilerr
StatusCode: base.StatusUnauthorized,
Header: base.Header{
"WWW-Authenticate": auth.GenerateWWWAuthenticate(nil, "IPCAM", nonce),
},
}, nil, nil
}
return &base.Response{
StatusCode: base.StatusOK,
}, strm, nil
},
onSetup: func(_ *gortsplib.ServerHandlerOnSetupCtx) (*base.Response, *gortsplib.ServerStream, error) {
return &base.Response{
StatusCode: base.StatusOK,
}, strm, nil
},
onPlay: func(_ *gortsplib.ServerHandlerOnPlayCtx) (*base.Response, error) {
go func() {
time.Sleep(100 * time.Millisecond)
err2 := strm.WritePacketRTP(media0, &rtp.Packet{
Header: rtp.Header{
Version: 0x02,
PayloadType: 96,
SequenceNumber: 57899,
Timestamp: 345234345,
SSRC: 978651231,
Marker: true,
},
Payload: []byte{5, 1, 2, 3, 4},
})
require.NoError(t, err2)
}()
return &base.Response{
StatusCode: base.StatusOK,
}, nil
},
},
RTSPAddress: "127.0.0.1:8555",
}
switch ca {
case "udp":
s.UDPRTPAddress = "127.0.0.1:8002"
s.UDPRTCPAddress = "127.0.0.1:8003"
case "rtsps", "rtsps+http", "rtsps+ws":
var serverCertFpath string
serverCertFpath, err = test.CreateTempFile(test.TLSCertPub)
require.NoError(t, err)
defer os.Remove(serverCertFpath)
var serverKeyFpath string
serverKeyFpath, err = test.CreateTempFile(test.TLSCertKey)
require.NoError(t, err)
defer os.Remove(serverKeyFpath)
var cert tls.Certificate
cert, err = tls.LoadX509KeyPair(serverCertFpath, serverKeyFpath)
require.NoError(t, err)
s.TLSConfig = &tls.Config{Certificates: []tls.Certificate{cert}}
}
err = s.Start()
require.NoError(t, err)
defer s.Close()
strm = &gortsplib.ServerStream{
Server: &s,
Desc: &description.Session{Medias: []*description.Media{media0}},
}
err = strm.Initialize()
require.NoError(t, err)
defer strm.Close()
var ur string
cnf := &conf.Path{
RTSPUDPSourcePortRange: []uint{10000, 65535},
}
switch ca {
case "udp", "tcp":
ur = "rtsp://testuser:testpass@localhost:8555/teststream"
var sp conf.RTSPTransport
sp.UnmarshalJSON([]byte(`"` + ca + `"`)) //nolint:errcheck
cnf.RTSPTransport = sp
case "rtsps", "rtsps+http", "rtsps+ws":
ur = ca + "://testuser:testpass@localhost:8555/teststream"
cnf.SourceFingerprint = "33949E05FFFB5FF3E8AA16F8213A6251B4D9363804BA53233C4DA9A46D6F2739"
case "rtsp+http", "rtsp+ws":
ur = ca + "://testuser:testpass@localhost:8555/teststream"
}
p := &test.StaticSourceParent{}
p.Initialize()
defer p.Close()
so := &Source{
ReadTimeout: conf.Duration(10 * time.Second),
WriteTimeout: conf.Duration(10 * time.Second),
WriteQueueSize: 2048,
Parent: p,
}
done := make(chan struct{})
defer func() { <-done }()
ctx, ctxCancel := context.WithCancel(context.Background())
defer ctxCancel()
reloadConf := make(chan *conf.Path)
go func() {
so.Run(defs.StaticSourceRunParams{ //nolint:errcheck
Context: ctx,
ResolvedSource: ur,
Conf: cnf,
ReloadConf: reloadConf,
})
close(done)
}()
<-p.Unit
// the source must be listening on ReloadConf
reloadConf <- nil
})
}
}
func TestNoPassword(t *testing.T) {
var strm *gortsplib.ServerStream
nonce, err := auth.GenerateNonce()
require.NoError(t, err)
media0 := test.UniqueMediaH264()
s := gortsplib.Server{
Handler: &testServer{
onDescribe: func(ctx *gortsplib.ServerHandlerOnDescribeCtx) (*base.Response, *gortsplib.ServerStream, error) {
err2 := auth.Verify(ctx.Request, "testuser", "", nil, "IPCAM", nonce)
if err2 != nil {
return &base.Response{ //nolint:nilerr
StatusCode: base.StatusUnauthorized,
Header: base.Header{
"WWW-Authenticate": auth.GenerateWWWAuthenticate(nil, "IPCAM", nonce),
},
}, nil, nil
}
return &base.Response{
StatusCode: base.StatusOK,
}, strm, nil
},
onSetup: func(_ *gortsplib.ServerHandlerOnSetupCtx) (*base.Response, *gortsplib.ServerStream, error) {
go func() {
time.Sleep(100 * time.Millisecond)
err2 := strm.WritePacketRTP(media0, &rtp.Packet{
Header: rtp.Header{
Version: 0x02,
PayloadType: 96,
SequenceNumber: 57899,
Timestamp: 345234345,
SSRC: 978651231,
Marker: true,
},
Payload: []byte{5, 1, 2, 3, 4},
})
require.NoError(t, err2)
}()
return &base.Response{
StatusCode: base.StatusOK,
}, strm, nil
},
onPlay: func(_ *gortsplib.ServerHandlerOnPlayCtx) (*base.Response, error) {
return &base.Response{
StatusCode: base.StatusOK,
}, nil
},
},
RTSPAddress: "127.0.0.1:8555",
}
err = s.Start()
require.NoError(t, err)
defer s.Close()
strm = &gortsplib.ServerStream{
Server: &s,
Desc: &description.Session{Medias: []*description.Media{media0}},
}
err = strm.Initialize()
require.NoError(t, err)
defer strm.Close()
var sp conf.RTSPTransport
sp.UnmarshalJSON([]byte(`"tcp"`)) //nolint:errcheck
p := &test.StaticSourceParent{}
p.Initialize()
defer p.Close()
so := &Source{
ReadTimeout: conf.Duration(10 * time.Second),
WriteTimeout: conf.Duration(10 * time.Second),
WriteQueueSize: 2048,
Parent: p,
}
done := make(chan struct{})
defer func() { <-done }()
ctx, ctxCancel := context.WithCancel(context.Background())
defer ctxCancel()
go func() {
so.Run(defs.StaticSourceRunParams{ //nolint:errcheck
Context: ctx,
ResolvedSource: "rtsp://testuser:@127.0.0.1:8555/teststream",
Conf: &conf.Path{
RTSPTransport: sp,
RTSPUDPSourcePortRange: []uint{10000, 65535},
},
})
close(done)
}()
<-p.Unit
}
func TestRange(t *testing.T) {
for _, ca := range []string{"clock", "npt", "smpte"} {
t.Run(ca, func(t *testing.T) {
var strm *gortsplib.ServerStream
media0 := test.UniqueMediaH264()
s := gortsplib.Server{
Handler: &testServer{
onDescribe: func(_ *gortsplib.ServerHandlerOnDescribeCtx) (*base.Response, *gortsplib.ServerStream, error) {
return &base.Response{
StatusCode: base.StatusOK,
}, strm, nil
},
onSetup: func(_ *gortsplib.ServerHandlerOnSetupCtx) (*base.Response, *gortsplib.ServerStream, error) {
return &base.Response{
StatusCode: base.StatusOK,
}, strm, nil
},
onPlay: func(ctx *gortsplib.ServerHandlerOnPlayCtx) (*base.Response, error) {
switch ca {
case "clock":
require.Equal(t, base.HeaderValue{"clock=20230812T120000Z-"}, ctx.Request.Header["Range"])
case "npt":
require.Equal(t, base.HeaderValue{"npt=0.35-"}, ctx.Request.Header["Range"])
case "smpte":
require.Equal(t, base.HeaderValue{"smpte=0:02:10-"}, ctx.Request.Header["Range"])
}
go func() {
time.Sleep(100 * time.Millisecond)
err := strm.WritePacketRTP(media0, &rtp.Packet{
Header: rtp.Header{
Version: 0x02,
PayloadType: 96,
SequenceNumber: 57899,
Timestamp: 345234345,
SSRC: 978651231,
Marker: true,
},
Payload: []byte{5, 1, 2, 3, 4},
})
require.NoError(t, err)
}()
return &base.Response{
StatusCode: base.StatusOK,
}, nil
},
},
RTSPAddress: "127.0.0.1:8555",
}
err := s.Start()
require.NoError(t, err)
defer s.Close()
strm = &gortsplib.ServerStream{
Server: &s,
Desc: &description.Session{Medias: []*description.Media{media0}},
}
err = strm.Initialize()
require.NoError(t, err)
defer strm.Close()
cnf := &conf.Path{
RTSPUDPSourcePortRange: []uint{10000, 65535},
}
switch ca {
case "clock":
cnf.RTSPRangeType = conf.RTSPRangeTypeClock
cnf.RTSPRangeStart = "20230812T120000Z"
case "npt":
cnf.RTSPRangeType = conf.RTSPRangeTypeNPT
cnf.RTSPRangeStart = "350ms"
case "smpte":
cnf.RTSPRangeType = conf.RTSPRangeTypeSMPTE
cnf.RTSPRangeStart = "130s"
}
p := &test.StaticSourceParent{}
p.Initialize()
defer p.Close()
so := &Source{
ReadTimeout: conf.Duration(10 * time.Second),
WriteTimeout: conf.Duration(10 * time.Second),
WriteQueueSize: 2048,
Parent: p,
}
done := make(chan struct{})
defer func() { <-done }()
ctx, ctxCancel := context.WithCancel(context.Background())
defer ctxCancel()
go func() {
so.Run(defs.StaticSourceRunParams{ //nolint:errcheck
Context: ctx,
ResolvedSource: "rtsp://127.0.0.1:8555/teststream",
Conf: cnf,
})
close(done)
}()
<-p.Unit
})
}
}
func TestSkipBackChannel(t *testing.T) {
media0 := test.UniqueMediaH264()
media1 := test.UniqueMediaMPEG4Audio()
backChannelMedia := &description.Media{
Type: description.MediaTypeAudio,
Formats: []format.Format{&format.Opus{PayloadTyp: 96, ChannelCount: 2}},
IsBackChannel: true,
}
var strm *gortsplib.ServerStream
setupCount := 0
s := gortsplib.Server{
Handler: &testServer{
onDescribe: func(_ *gortsplib.ServerHandlerOnDescribeCtx) (*base.Response, *gortsplib.ServerStream, error) {
return &base.Response{
StatusCode: base.StatusOK,
}, strm, nil
},
onSetup: func(_ *gortsplib.ServerHandlerOnSetupCtx) (*base.Response, *gortsplib.ServerStream, error) {
setupCount++
return &base.Response{
StatusCode: base.StatusOK,
}, strm, nil
},
onPlay: func(_ *gortsplib.ServerHandlerOnPlayCtx) (*base.Response, error) {
go func() {
time.Sleep(100 * time.Millisecond)
err := strm.WritePacketRTP(media0, &rtp.Packet{
Header: rtp.Header{
Version: 0x02,
PayloadType: 96,
SequenceNumber: 57899,
Timestamp: 345234345,
SSRC: 978651231,
Marker: true,
},
Payload: []byte{5, 1, 2, 3, 4},
})
require.NoError(t, err)
}()
return &base.Response{
StatusCode: base.StatusOK,
}, nil
},
},
RTSPAddress: "127.0.0.1:8555",
}
err := s.Start()
require.NoError(t, err)
defer s.Close()
strm = &gortsplib.ServerStream{
Server: &s,
Desc: &description.Session{Medias: []*description.Media{media0, media1, backChannelMedia}},
}
err = strm.Initialize()
require.NoError(t, err)
defer strm.Close()
var sp conf.RTSPTransport
sp.UnmarshalJSON([]byte(`"tcp"`)) //nolint:errcheck
p := &test.StaticSourceParent{}
p.Initialize()
defer p.Close()
so := &Source{
ReadTimeout: conf.Duration(10 * time.Second),
WriteTimeout: conf.Duration(10 * time.Second),
WriteQueueSize: 2048,
Parent: p,
}
done := make(chan struct{})
defer func() { <-done }()
ctx, ctxCancel := context.WithCancel(context.Background())
defer ctxCancel()
go func() {
so.Run(defs.StaticSourceRunParams{ //nolint:errcheck
Context: ctx,
ResolvedSource: "rtsp://127.0.0.1:8555/teststream",
Conf: &conf.Path{
RTSPTransport: conf.RTSPTransport{Protocol: ptrOf(gortsplib.ProtocolTCP)},
RTSPUDPSourcePortRange: []uint{10000, 65535},
},
})
close(done)
}()
<-p.Unit
require.Equal(t, 2, setupCount)
}
func TestOnlyBackChannelsError(t *testing.T) {
backChannelMedia1 := &description.Media{
Type: description.MediaTypeAudio,
Formats: []format.Format{&format.Opus{PayloadTyp: 96, ChannelCount: 2}},
IsBackChannel: true,
}
backChannelMedia2 := &description.Media{
Type: description.MediaTypeAudio,
Formats: []format.Format{&format.G711{PayloadTyp: 8, SampleRate: 8000, ChannelCount: 1}},
IsBackChannel: true,
}
var strm *gortsplib.ServerStream
s := gortsplib.Server{
Handler: &testServer{
onDescribe: func(_ *gortsplib.ServerHandlerOnDescribeCtx) (*base.Response, *gortsplib.ServerStream, error) {
return &base.Response{
StatusCode: base.StatusOK,
}, strm, nil
},
onSetup: func(_ *gortsplib.ServerHandlerOnSetupCtx) (*base.Response, *gortsplib.ServerStream, error) {
return &base.Response{
StatusCode: base.StatusOK,
}, strm, nil
},
onPlay: func(_ *gortsplib.ServerHandlerOnPlayCtx) (*base.Response, error) {
return &base.Response{
StatusCode: base.StatusOK,
}, nil
},
},
RTSPAddress: "127.0.0.1:8555",
}
err := s.Start()
require.NoError(t, err)
defer s.Close()
strm = &gortsplib.ServerStream{
Server: &s,
Desc: &description.Session{Medias: []*description.Media{backChannelMedia1, backChannelMedia2}},
}
err = strm.Initialize()
require.NoError(t, err)
defer strm.Close()
p := &test.StaticSourceParent{}
p.Initialize()
so := &Source{
ReadTimeout: conf.Duration(10 * time.Second),
WriteTimeout: conf.Duration(10 * time.Second),
WriteQueueSize: 2048,
Parent: p,
}
ctx, ctxCancel := context.WithCancel(context.Background())
defer ctxCancel()
err = so.Run(defs.StaticSourceRunParams{
Context: ctx,
ResolvedSource: "rtsp://127.0.0.1:8555/teststream",
Conf: &conf.Path{
RTSPTransport: conf.RTSPTransport{Protocol: ptrOf(gortsplib.ProtocolTCP)},
RTSPUDPSourcePortRange: []uint{10000, 65535},
},
})
require.Error(t, err)
require.Contains(t, err.Error(), "no media")
}
================================================
FILE: internal/staticsources/srt/source.go
================================================
// Package srt contains the SRT static source.
package srt
import (
"time"
"github.com/bluenviron/gortsplib/v5/pkg/description"
srt "github.com/datarhei/gosrt"
"github.com/bluenviron/mediamtx/internal/conf"
"github.com/bluenviron/mediamtx/internal/defs"
"github.com/bluenviron/mediamtx/internal/errordumper"
"github.com/bluenviron/mediamtx/internal/logger"
"github.com/bluenviron/mediamtx/internal/protocols/mpegts"
"github.com/bluenviron/mediamtx/internal/stream"
)
type parent interface {
logger.Writer
SetReady(req defs.PathSourceStaticSetReadyReq) defs.PathSourceStaticSetReadyRes
SetNotReady(req defs.PathSourceStaticSetNotReadyReq)
}
// Source is a SRT static source.
type Source struct {
ReadTimeout conf.Duration
Parent parent
}
// Log implements logger.Writer.
func (s *Source) Log(level logger.Level, format string, args ...any) {
s.Parent.Log(level, "[SRT source] "+format, args...)
}
// Run implements StaticSource.
func (s *Source) Run(params defs.StaticSourceRunParams) error {
s.Log(logger.Debug, "connecting")
conf := srt.DefaultConfig()
address, err := conf.UnmarshalURL(params.ResolvedSource)
if err != nil {
return err
}
err = conf.Validate()
if err != nil {
return err
}
sconn, err := srt.Dial("srt", address, conf)
if err != nil {
return err
}
readDone := make(chan error)
go func() {
readDone <- s.runReader(sconn)
}()
for {
select {
case err = <-readDone:
sconn.Close()
return err
case <-params.ReloadConf:
case <-params.Context.Done():
sconn.Close()
<-readDone
return nil
}
}
}
func (s *Source) runReader(sconn srt.Conn) error {
sconn.SetReadDeadline(time.Now().Add(time.Duration(s.ReadTimeout)))
r := &mpegts.EnhancedReader{R: sconn}
err := r.Initialize()
if err != nil {
return err
}
decodeErrors := &errordumper.Dumper{
OnReport: func(val uint64, last error) {
if val == 1 {
s.Log(logger.Warn, "decode error: %v", last)
} else {
s.Log(logger.Warn, "%d decode errors, last was: %v", val, last)
}
},
}
decodeErrors.Start()
defer decodeErrors.Stop()
r.OnDecodeError(func(err error) {
decodeErrors.Add(err)
})
var subStream *stream.SubStream
medias, err := mpegts.ToStream(r, &subStream, s)
if err != nil {
return err
}
res := s.Parent.SetReady(defs.PathSourceStaticSetReadyReq{
Desc: &description.Session{Medias: medias},
UseRTPPackets: false,
ReplaceNTP: true,
})
if res.Err != nil {
return res.Err
}
defer s.Parent.SetNotReady(defs.PathSourceStaticSetNotReadyReq{})
subStream = res.SubStream
for {
sconn.SetReadDeadline(time.Now().Add(time.Duration(s.ReadTimeout)))
err = r.Read()
if err != nil {
return err
}
}
}
// APISourceDescribe implements StaticSource.
func (*Source) APISourceDescribe() *defs.APIPathSource {
return &defs.APIPathSource{
Type: defs.APIPathSourceTypeSRTSource,
ID: "",
}
}
================================================
FILE: internal/staticsources/srt/source_test.go
================================================
package srt
import (
"bufio"
"context"
"testing"
"time"
"github.com/bluenviron/mediacommon/v2/pkg/formats/mpegts"
tscodecs "github.com/bluenviron/mediacommon/v2/pkg/formats/mpegts/codecs"
srt "github.com/datarhei/gosrt"
"github.com/stretchr/testify/require"
"github.com/bluenviron/mediamtx/internal/conf"
"github.com/bluenviron/mediamtx/internal/defs"
"github.com/bluenviron/mediamtx/internal/test"
)
func TestSource(t *testing.T) {
ln, err := srt.Listen("srt", "127.0.0.1:9002", srt.DefaultConfig())
require.NoError(t, err)
defer ln.Close()
p := &test.StaticSourceParent{}
p.Initialize()
so := &Source{
ReadTimeout: conf.Duration(10 * time.Second),
Parent: p,
}
done := make(chan struct{})
defer func() { <-done }()
ctx, ctxCancel := context.WithCancel(context.Background())
defer ctxCancel()
reloadConf := make(chan *conf.Path)
go func() {
so.Run(defs.StaticSourceRunParams{ //nolint:errcheck
Context: ctx,
ResolvedSource: "srt://127.0.0.1:9002?streamid=sidname&passphrase=ttest1234567",
Conf: &conf.Path{},
ReloadConf: reloadConf,
})
close(done)
}()
req, err2 := ln.Accept2()
require.NoError(t, err2)
require.Equal(t, "sidname", req.StreamId())
err2 = req.SetPassphrase("ttest1234567")
require.NoError(t, err2)
conn, err2 := req.Accept()
require.NoError(t, err2)
defer conn.Close()
track := &mpegts.Track{Codec: &tscodecs.H264{}}
bw := bufio.NewWriter(conn)
w := &mpegts.Writer{W: bw, Tracks: []*mpegts.Track{track}}
err2 = w.Initialize()
require.NoError(t, err2)
err2 = w.WriteH264(track, 0, 0, [][]byte{{ // IDR
5, 1,
}})
require.NoError(t, err2)
err = bw.Flush()
require.NoError(t, err)
err = w.WriteH264(track, 0, 0, [][]byte{{ // non-IDR
5, 2,
}})
require.NoError(t, err)
err = bw.Flush()
require.NoError(t, err)
<-p.Unit
// the source must be listening on ReloadConf
reloadConf <- nil
// stop test reader before 2nd H264 packet is received to avoid a crash
p.Close()
}
================================================
FILE: internal/staticsources/webrtc/source.go
================================================
// Package webrtc contains the WebRTC static source.
package webrtc
import (
"fmt"
"net"
"net/http"
"net/url"
"strings"
"time"
"github.com/bluenviron/gortsplib/v5/pkg/description"
"github.com/bluenviron/mediamtx/internal/conf"
"github.com/bluenviron/mediamtx/internal/defs"
"github.com/bluenviron/mediamtx/internal/logger"
"github.com/bluenviron/mediamtx/internal/packetdumper"
"github.com/bluenviron/mediamtx/internal/protocols/tls"
"github.com/bluenviron/mediamtx/internal/protocols/webrtc"
"github.com/bluenviron/mediamtx/internal/protocols/whip"
"github.com/bluenviron/mediamtx/internal/stream"
)
type parent interface {
logger.Writer
SetReady(req defs.PathSourceStaticSetReadyReq) defs.PathSourceStaticSetReadyRes
SetNotReady(req defs.PathSourceStaticSetNotReadyReq)
}
// Source is a WebRTC static source.
type Source struct {
DumpPackets bool
ReadTimeout conf.Duration
UDPReadBufferSize uint
Parent parent
}
// Log implements logger.Writer.
func (s *Source) Log(level logger.Level, format string, args ...any) {
s.Parent.Log(level, "[WebRTC source] "+format, args...)
}
// Run implements StaticSource.
func (s *Source) Run(params defs.StaticSourceRunParams) error {
s.Log(logger.Debug, "connecting")
u, err := url.Parse(params.ResolvedSource)
if err != nil {
return err
}
u.Scheme = strings.ReplaceAll(u.Scheme, "whep", "http")
dialContext := (&net.Dialer{}).DialContext
if s.DumpPackets {
dialContext = (&packetdumper.DialContext{
Prefix: "webrtc_source_conn",
DialContext: dialContext,
}).Do
}
tr := &http.Transport{
DialContext: dialContext,
TLSClientConfig: tls.MakeConfig(u.Hostname(), params.Conf.SourceFingerprint),
}
defer tr.CloseIdleConnections()
client := whip.Client{
URL: u,
HTTPClient: &http.Client{
Timeout: time.Duration(s.ReadTimeout),
Transport: tr,
},
BearerToken: params.Conf.WHEPBearerToken,
UDPReadBufferSize: s.UDPReadBufferSize,
STUNGatherTimeout: time.Duration(params.Conf.WHEPSTUNGatherTimeout),
HandshakeTimeout: time.Duration(params.Conf.WHEPHandshakeTimeout),
TrackGatherTimeout: time.Duration(params.Conf.WHEPTrackGatherTimeout),
Log: s,
}
err = client.Initialize(params.Context)
if err != nil {
return err
}
var subStream *stream.SubStream
medias, err := webrtc.ToStream(client.PeerConnection(), params.Conf, &subStream, s)
if err != nil {
client.Close() //nolint:errcheck
return err
}
rres := s.Parent.SetReady(defs.PathSourceStaticSetReadyReq{
Desc: &description.Session{Medias: medias},
UseRTPPackets: true,
ReplaceNTP: !params.Conf.UseAbsoluteTimestamp,
})
if rres.Err != nil {
client.Close() //nolint:errcheck
return rres.Err
}
defer s.Parent.SetNotReady(defs.PathSourceStaticSetNotReadyReq{})
subStream = rres.SubStream
client.StartReading()
readErr := make(chan error)
go func() {
readErr <- client.Wait()
}()
for {
select {
case err = <-readErr:
client.Close() //nolint:errcheck
return err
case <-params.ReloadConf:
case <-params.Context.Done():
client.Close() //nolint:errcheck
<-readErr
return fmt.Errorf("terminated")
}
}
}
// APISourceDescribe implements StaticSource.
func (*Source) APISourceDescribe() *defs.APIPathSource {
return &defs.APIPathSource{
Type: defs.APIPathSourceTypeWebRTCSource,
ID: "",
}
}
================================================
FILE: internal/staticsources/webrtc/source_test.go
================================================
package webrtc
import (
"context"
"io"
"net"
"net/http"
"testing"
"time"
"github.com/pion/rtp"
pwebrtc "github.com/pion/webrtc/v4"
"github.com/stretchr/testify/require"
"github.com/bluenviron/mediamtx/internal/conf"
"github.com/bluenviron/mediamtx/internal/defs"
"github.com/bluenviron/mediamtx/internal/protocols/webrtc"
"github.com/bluenviron/mediamtx/internal/test"
)
func whipOffer(body []byte) *pwebrtc.SessionDescription {
return &pwebrtc.SessionDescription{
Type: pwebrtc.SDPTypeOffer,
SDP: string(body),
}
}
func TestSource(t *testing.T) {
outgoingTracks := []*webrtc.OutgoingTrack{{
Caps: pwebrtc.RTPCodecCapability{
MimeType: "audio/opus",
ClockRate: 48000,
Channels: 2,
SDPFmtpLine: "minptime=10;useinbandfec=1;stereo=1;sprop-stereo=1",
},
}}
pc := &webrtc.PeerConnection{
LocalRandomUDP: true,
IPsFromInterfaces: true,
Publish: true,
OutgoingTracks: outgoingTracks,
Log: test.NilLogger,
}
err := pc.Start()
require.NoError(t, err)
defer pc.Close()
state := 0
httpServ := &http.Server{
Handler: http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
switch state {
case 0:
require.Equal(t, http.MethodOptions, r.Method)
require.Equal(t, "/my/resource", r.URL.Path)
w.Header().Set("Access-Control-Allow-Methods", "OPTIONS, GET, POST, PATCH")
w.Header().Set("Access-Control-Allow-Headers", "Authorization, Content-Type, If-Match")
w.WriteHeader(http.StatusNoContent)
case 1:
require.Equal(t, http.MethodPost, r.Method)
require.Equal(t, "/my/resource", r.URL.Path)
require.Equal(t, "application/sdp", r.Header.Get("Content-Type"))
body, err2 := io.ReadAll(r.Body)
require.NoError(t, err2)
offer := whipOffer(body)
answer, err2 := pc.CreateFullAnswer(offer)
require.NoError(t, err2)
w.Header().Set("Content-Type", "application/sdp")
w.Header().Set("Accept-Patch", "application/trickle-ice-sdpfrag")
w.Header().Set("ETag", "test_etag")
w.Header().Set("Location", "/my/resource/sessionid")
w.WriteHeader(http.StatusCreated)
w.Write([]byte(answer.SDP))
go func() {
err3 := pc.WaitUntilConnected(10 * time.Second)
require.NoError(t, err3)
err3 = outgoingTracks[0].WriteRTP(&rtp.Packet{
Header: rtp.Header{
Version: 2,
Marker: true,
PayloadType: 111,
SequenceNumber: 1123,
Timestamp: 45343,
SSRC: 563424,
},
Payload: []byte{5, 2},
})
require.NoError(t, err3)
}()
default:
require.Equal(t, "/my/resource/sessionid", r.URL.Path)
switch r.Method {
case http.MethodPatch:
w.WriteHeader(http.StatusNoContent)
case http.MethodDelete:
w.WriteHeader(http.StatusOK)
default:
t.Errorf("should not happen")
}
}
state++
}),
}
ln, err := net.Listen("tcp", "localhost:9003")
require.NoError(t, err)
go httpServ.Serve(ln)
defer httpServ.Shutdown(context.Background())
p := &test.StaticSourceParent{}
p.Initialize()
defer p.Close()
so := &Source{
ReadTimeout: conf.Duration(10 * time.Second),
Parent: p,
}
done := make(chan struct{})
defer func() { <-done }()
ctx, ctxCancel := context.WithCancel(context.Background())
defer ctxCancel()
reloadConf := make(chan *conf.Path)
go func() {
so.Run(defs.StaticSourceRunParams{ //nolint:errcheck
Context: ctx,
ResolvedSource: "whep://localhost:9003/my/resource",
Conf: &conf.Path{},
ReloadConf: reloadConf,
})
close(done)
}()
<-p.Unit
// the source must be listening on ReloadConf
reloadConf <- nil
}
================================================
FILE: internal/stream/format_updater.go
================================================
package stream
import (
"bytes"
"github.com/bluenviron/gortsplib/v5/pkg/format"
mch264 "github.com/bluenviron/mediacommon/v2/pkg/codecs/h264"
mch265 "github.com/bluenviron/mediacommon/v2/pkg/codecs/h265"
"github.com/bluenviron/mediacommon/v2/pkg/codecs/mpeg4video"
"github.com/bluenviron/mediamtx/internal/unit"
)
type formatUpdater func(format.Format, unit.Payload)
func formatUpdaterH265(forma format.Format, payload unit.Payload) {
formatH265 := forma.(*format.H265)
au := payload.(unit.PayloadH265)
vps, sps, pps := formatH265.VPS, formatH265.SPS, formatH265.PPS
update := false
for _, nalu := range au {
typ := mch265.NALUType((nalu[0] >> 1) & 0b111111)
switch typ {
case mch265.NALUType_VPS_NUT:
if !bytes.Equal(nalu, formatH265.VPS) {
vps = nalu
update = true
}
case mch265.NALUType_SPS_NUT:
if !bytes.Equal(nalu, formatH265.SPS) {
sps = nalu
update = true
}
case mch265.NALUType_PPS_NUT:
if !bytes.Equal(nalu, formatH265.PPS) {
pps = nalu
update = true
}
}
}
if update {
formatH265.SafeSetParams(vps, sps, pps)
}
}
func formatUpdaterH264(forma format.Format, payload unit.Payload) {
formatH264 := forma.(*format.H264)
au := payload.(unit.PayloadH264)
sps, pps := formatH264.SPS, formatH264.PPS
update := false
for _, nalu := range au {
typ := mch264.NALUType(nalu[0] & 0x1F)
switch typ {
case mch264.NALUTypeSPS:
if !bytes.Equal(nalu, sps) {
sps = nalu
update = true
}
case mch264.NALUTypePPS:
if !bytes.Equal(nalu, pps) {
pps = nalu
update = true
}
}
}
if update {
formatH264.SafeSetParams(sps, pps)
}
}
func formatUpdaterMPEG4Video(forma format.Format, payload unit.Payload) {
formatMPEG4Video := forma.(*format.MPEG4Video)
frame := payload.(unit.PayloadMPEG4Video)
if bytes.HasPrefix(frame, []byte{0, 0, 1, byte(mpeg4video.VisualObjectSequenceStartCode)}) {
end := bytes.Index(frame[4:], []byte{0, 0, 1, byte(mpeg4video.GroupOfVOPStartCode)})
if end < 0 {
return
}
conf := frame[:end+4]
if !bytes.Equal(conf, formatMPEG4Video.Config) {
formatMPEG4Video.SafeSetParams(conf)
}
}
}
func newFormatUpdater(forma format.Format) formatUpdater {
switch forma.(type) {
case *format.H265:
return formatUpdaterH265
case *format.H264:
return formatUpdaterH264
case *format.MPEG4Video:
return formatUpdaterMPEG4Video
default:
return formatUpdater(func(_ format.Format, _ unit.Payload) {
})
}
}
================================================
FILE: internal/stream/offline_sub_stream.go
================================================
package stream
import (
"context"
"sync"
"time"
)
func multiplyAndDivide2(v, m, d time.Duration) time.Duration {
secs := v / d
dec := v % d
return (secs*m + dec*m/d)
}
type offlineSubStream struct {
stream *Stream
subStream *SubStream
ctx context.Context
ctxCancel func()
wg sync.WaitGroup
tracks []*offlineSubStreamTrack
}
func (o *offlineSubStream) initialize() error {
o.subStream = &SubStream{
Stream: o.stream,
CurDesc: o.stream.offlineDesc,
UseRTPPackets: false,
}
err := o.subStream.Initialize()
if err != nil {
return err
}
o.ctx, o.ctxCancel = context.WithCancel(context.Background())
pos := 0
o.tracks = make([]*offlineSubStreamTrack, len(o.subStream.CurDesc.Medias))
for _, media := range o.subStream.CurDesc.Medias {
for _, forma := range media.Formats {
t := &offlineSubStreamTrack{
wg: &o.wg,
file: o.stream.AlwaysAvailableFile,
pos: pos,
ctx: o.ctx,
subStream: o.subStream,
media: media,
format: forma,
}
t.initialize()
o.tracks[pos] = t
pos++
}
}
return nil
}
func (o *offlineSubStream) close(waitLastSample bool) {
for _, track := range o.tracks {
track.waitLastSample = waitLastSample
}
o.ctxCancel()
o.wg.Wait()
}
================================================
FILE: internal/stream/offline_sub_stream_track.go
================================================
package stream
import (
"bytes"
"context"
_ "embed"
"io"
"os"
"sync"
"time"
"github.com/bluenviron/gortsplib/v5/pkg/description"
"github.com/bluenviron/gortsplib/v5/pkg/format"
"github.com/bluenviron/mediacommon/v2/pkg/codecs/av1"
"github.com/bluenviron/mediacommon/v2/pkg/codecs/h264"
"github.com/bluenviron/mediacommon/v2/pkg/codecs/mpeg4audio"
mcodecs "github.com/bluenviron/mediacommon/v2/pkg/formats/mp4/codecs"
"github.com/bluenviron/mediacommon/v2/pkg/formats/pmp4"
"github.com/bluenviron/mediamtx/internal/unit"
)
//go:embed offline_av1.mp4
var offlineAV1 []byte
//go:embed offline_vp9.mp4
var offlineVP9 []byte
//go:embed offline_h265.mp4
var offlineH265 []byte
var offlineH265VPS = []byte{
0x40, 0x01, 0x0c, 0x01, 0xff, 0xff, 0x01, 0x60,
0x00, 0x00, 0x03, 0x00, 0x90, 0x00, 0x00, 0x03,
0x00, 0x00, 0x03, 0x00, 0x78, 0xba, 0x02, 0x40,
}
var offlineH265SPS = []byte{
0x42, 0x01, 0x01, 0x01, 0x60, 0x00, 0x00, 0x03,
0x00, 0x90, 0x00, 0x00, 0x03, 0x00, 0x00, 0x03,
0x00, 0x78, 0xa0, 0x03, 0xc0, 0x80, 0x11, 0x07,
0xcb, 0x96, 0xe9, 0x29, 0x30, 0xbc, 0x05, 0xa0,
0x20, 0x00, 0x00, 0x03, 0x00, 0x20, 0x00, 0x00,
0x03, 0x03, 0xc1,
}
var offlineH265PPS = []byte{
0x44, 0x01, 0xc0, 0x73, 0xc1, 0x89,
}
//go:embed offline_h264.mp4
var offlineH264 []byte
var offlineH264SPS = []byte{
0x67, 0x42, 0xc0, 0x28, 0xda, 0x01, 0xe0, 0x08,
0x9f, 0x97, 0x01, 0x10, 0x00, 0x00, 0x03, 0x00,
0x10, 0x00, 0x00, 0x03, 0x03, 0xc0, 0xf1, 0x83,
0x2a,
}
var offlineH264PPS = []byte{
0x68, 0xce, 0x3c, 0x80,
}
type offlineSubStreamTrack struct {
wg *sync.WaitGroup
file string
pos int
ctx context.Context
subStream *SubStream
media *description.Media
format format.Format
waitLastSample bool
}
func (t *offlineSubStreamTrack) initialize() {
t.wg.Add(1)
go t.run()
}
func (t *offlineSubStreamTrack) run() {
defer t.wg.Done()
if t.file != "" {
f, err := os.Open(t.file)
if err != nil {
panic(err)
}
defer f.Close()
err = t.runFile(f, t.pos)
if err != nil {
panic(err)
}
return
}
const audioWritesPerSecond = 10
var pts int64
startSystemTime := time.Now()
switch forma := t.format.(type) {
case *format.Opus:
unitsPerWrite := (forma.ClockRate() / 960) / audioWritesPerSecond
writeDuration := 960 * int64(unitsPerWrite)
for {
payload := make(unit.PayloadOpus, unitsPerWrite)
for i := range payload {
payload[i] = []byte{0xF8, 0xFF, 0xFE} // DTX frame
}
t.subStream.WriteUnit(t.media, t.format, &unit.Unit{
PTS: pts,
NTP: time.Time{},
Payload: payload,
})
pts += writeDuration
ptsGo := multiplyAndDivide2(time.Duration(pts), time.Second, 48000)
systemTime := startSystemTime.Add(ptsGo)
if !t.sleep(systemTime) {
return
}
}
case *format.MPEG4Audio:
unitsPerWrite := (forma.ClockRate() / mpeg4audio.SamplesPerAccessUnit) / audioWritesPerSecond
writeDuration := mpeg4audio.SamplesPerAccessUnit * int64(unitsPerWrite)
for {
var frame []byte
switch forma.Config.ChannelConfig {
case 1:
frame = []byte{0x01, 0x18, 0x20, 0x07}
default:
frame = []byte{0x21, 0x10, 0x04, 0x60, 0x8c, 0x1c}
}
payload := make(unit.PayloadMPEG4Audio, unitsPerWrite)
for i := range payload {
payload[i] = frame
}
t.subStream.WriteUnit(t.media, t.format, &unit.Unit{
PTS: pts,
NTP: time.Time{},
Payload: payload,
})
pts += writeDuration
ptsGo := multiplyAndDivide2(time.Duration(pts), time.Second, time.Duration(forma.ClockRate()))
systemTime := startSystemTime.Add(ptsGo)
if !t.sleep(systemTime) {
return
}
}
case *format.G711:
samplesPerWrite := forma.ClockRate() / audioWritesPerSecond
writeDuration := samplesPerWrite
for {
var sample byte
if forma.MULaw {
sample = 0xFF
} else {
sample = 0xD5
}
payload := make(unit.PayloadG711, samplesPerWrite*forma.ChannelCount)
for i := range payload {
payload[i] = sample
}
t.subStream.WriteUnit(t.media, t.format, &unit.Unit{
PTS: pts,
NTP: time.Time{},
Payload: payload,
})
pts += int64(writeDuration)
ptsGo := multiplyAndDivide2(time.Duration(pts), time.Second, time.Duration(forma.ClockRate()))
systemTime := startSystemTime.Add(ptsGo)
if !t.sleep(systemTime) {
return
}
}
case *format.LPCM:
samplesPerWrite := forma.ClockRate() / audioWritesPerSecond
writeDuration := samplesPerWrite
for {
payload := make(unit.PayloadLPCM, samplesPerWrite*forma.ChannelCount*(forma.BitDepth/8))
t.subStream.WriteUnit(t.media, t.format, &unit.Unit{
PTS: pts,
NTP: time.Time{},
Payload: payload,
})
pts += int64(writeDuration)
ptsGo := multiplyAndDivide2(time.Duration(pts), time.Second, time.Duration(forma.ClockRate()))
systemTime := startSystemTime.Add(ptsGo)
if !t.sleep(systemTime) {
return
}
}
default:
var buf []byte
switch t.format.(type) {
case *format.AV1:
buf = offlineAV1
case *format.VP9:
buf = offlineVP9
case *format.H265:
buf = offlineH265
case *format.H264:
buf = offlineH264
default:
panic("should not happen")
}
r := bytes.NewReader(buf)
err := t.runFile(r, 0)
if err != nil {
panic(err)
}
}
}
func (t *offlineSubStreamTrack) runFile(r io.ReadSeeker, pos int) error {
var presentation pmp4.Presentation
err := presentation.Unmarshal(r)
if err != nil {
return err
}
track := presentation.Tracks[pos]
var pts int64
startSystemTime := time.Now()
for {
for _, sample := range track.Samples {
var payload []byte
payload, err = sample.GetPayload()
if err != nil {
return err
}
switch track.Codec.(type) {
case *mcodecs.AV1:
var bs av1.Bitstream
err = bs.Unmarshal(payload)
if err != nil {
return err
}
t.subStream.WriteUnit(t.media, t.format, &unit.Unit{
PTS: pts,
NTP: time.Time{},
Payload: unit.PayloadAV1(bs),
})
case *mcodecs.VP9:
t.subStream.WriteUnit(t.media, t.format, &unit.Unit{
PTS: pts,
NTP: time.Time{},
Payload: unit.PayloadVP9(payload),
})
case *mcodecs.H265:
var avcc h264.AVCC
err = avcc.Unmarshal(payload)
if err != nil {
return err
}
t.subStream.WriteUnit(t.media, t.format, &unit.Unit{
PTS: pts,
NTP: time.Time{},
Payload: unit.PayloadH265(avcc),
})
case *mcodecs.H264:
var avcc h264.AVCC
err = avcc.Unmarshal(payload)
if err != nil {
return err
}
t.subStream.WriteUnit(t.media, t.format, &unit.Unit{
PTS: pts,
NTP: time.Time{},
Payload: unit.PayloadH264(avcc),
})
case *mcodecs.Opus:
t.subStream.WriteUnit(t.media, t.format, &unit.Unit{
PTS: pts,
NTP: time.Time{},
Payload: unit.PayloadOpus([][]byte{payload}),
})
case *mcodecs.MPEG4Audio:
t.subStream.WriteUnit(t.media, t.format, &unit.Unit{
PTS: pts,
NTP: time.Time{},
Payload: unit.PayloadMPEG4Audio([][]byte{payload}),
})
case *mcodecs.LPCM:
t.subStream.WriteUnit(t.media, t.format, &unit.Unit{
PTS: pts,
NTP: time.Time{},
Payload: unit.PayloadLPCM(payload),
})
}
pts += multiplyAndDivide(int64(sample.Duration)+int64(sample.PTSOffset),
int64(t.format.ClockRate()), int64(track.TimeScale))
ptsGo := multiplyAndDivide2(time.Duration(pts), time.Second, time.Duration(t.format.ClockRate()))
systemTime := startSystemTime.Add(ptsGo)
if !t.sleep(systemTime) {
return nil
}
}
}
}
func (t *offlineSubStreamTrack) sleep(systemTime time.Time) bool {
select {
case <-time.After(time.Until(systemTime)):
case <-t.ctx.Done():
if t.waitLastSample {
time.Sleep(time.Until(systemTime))
}
return false
}
return true
}
================================================
FILE: internal/stream/reader.go
================================================
package stream
import (
"fmt"
"github.com/bluenviron/gortsplib/v5/pkg/description"
"github.com/bluenviron/gortsplib/v5/pkg/format"
"github.com/bluenviron/gortsplib/v5/pkg/ringbuffer"
"github.com/bluenviron/mediamtx/internal/counterdumper"
"github.com/bluenviron/mediamtx/internal/logger"
"github.com/bluenviron/mediamtx/internal/unit"
)
// OnDataFunc is the callback passed to OnData().
type OnDataFunc func(*unit.Unit) error
// Reader is a stream reader.
type Reader struct {
SkipBytesSent bool
Parent logger.Writer
onDatas map[*description.Media]map[format.Format]OnDataFunc
queueSize int
buffer *ringbuffer.RingBuffer
outboundFramesDiscarded *counterdumper.Dumper
// out
err chan error
}
// OnData registers a callback that is called when data from given format is available.
func (r *Reader) OnData(medi *description.Media, forma format.Format, cb OnDataFunc) {
if r.onDatas == nil {
r.onDatas = make(map[*description.Media]map[format.Format]OnDataFunc)
}
if r.onDatas[medi] == nil {
r.onDatas[medi] = make(map[format.Format]OnDataFunc)
}
r.onDatas[medi][forma] = cb
}
// Formats returns all formats for which the reader has registered a OnData callback.
func (r *Reader) Formats() []format.Format {
n := 0
for _, formats := range r.onDatas {
for range formats {
n++
}
}
if n == 0 {
return nil
}
out := make([]format.Format, n)
n = 0
for _, formats := range r.onDatas {
for forma := range formats {
out[n] = forma
n++
}
}
return out
}
// OutboundFramesDiscarded returns the number of frames discarded because the reader is too slow.
func (r *Reader) OutboundFramesDiscarded() uint64 {
return r.outboundFramesDiscarded.Get()
}
// error returns whenever there's an error.
// It can be called only after stream.AddReader().
func (r *Reader) Error() chan error {
return r.err
}
func (r *Reader) start() {
buffer, _ := ringbuffer.New(uint64(r.queueSize))
r.buffer = buffer
r.err = make(chan error)
r.outboundFramesDiscarded = &counterdumper.Dumper{
OnReport: func(val uint64) {
r.Parent.Log(logger.Warn, "reader is too slow, discarding %d %s",
val,
func() string {
if val == 1 {
return "frame"
}
return "frames"
}())
},
}
r.outboundFramesDiscarded.Start()
go r.run()
}
func (r *Reader) stop() {
r.buffer.Close()
r.outboundFramesDiscarded.Stop()
<-r.err
}
func (r *Reader) run() {
r.err <- r.runInner()
close(r.err)
}
func (r *Reader) runInner() error {
for {
cb, ok := r.buffer.Pull()
if !ok {
return fmt.Errorf("terminated")
}
err := cb.(func() error)()
if err != nil {
return err
}
}
}
func (r *Reader) push(cb func() error) {
ok := r.buffer.Push(cb)
if !ok {
r.outboundFramesDiscarded.Increase()
}
}
================================================
FILE: internal/stream/rtp_decoder.go
================================================
package stream
import (
"errors"
"github.com/bluenviron/gortsplib/v5/pkg/format"
"github.com/bluenviron/gortsplib/v5/pkg/format/rtpac3"
"github.com/bluenviron/gortsplib/v5/pkg/format/rtpav1"
"github.com/bluenviron/gortsplib/v5/pkg/format/rtpfragmented"
"github.com/bluenviron/gortsplib/v5/pkg/format/rtph264"
"github.com/bluenviron/gortsplib/v5/pkg/format/rtph265"
"github.com/bluenviron/gortsplib/v5/pkg/format/rtpklv"
"github.com/bluenviron/gortsplib/v5/pkg/format/rtplpcm"
"github.com/bluenviron/gortsplib/v5/pkg/format/rtpmjpeg"
"github.com/bluenviron/gortsplib/v5/pkg/format/rtpmpeg1audio"
"github.com/bluenviron/gortsplib/v5/pkg/format/rtpmpeg1video"
"github.com/bluenviron/gortsplib/v5/pkg/format/rtpmpeg4audio"
"github.com/bluenviron/gortsplib/v5/pkg/format/rtpsimpleaudio"
"github.com/bluenviron/gortsplib/v5/pkg/format/rtpvp8"
"github.com/bluenviron/gortsplib/v5/pkg/format/rtpvp9"
"github.com/bluenviron/mediamtx/internal/unit"
"github.com/pion/rtp"
)
type rtpDecoder interface {
decode(*rtp.Packet) (unit.Payload, error)
}
type rtpDecoderAV1 rtpav1.Decoder
func (d *rtpDecoderAV1) decode(pkt *rtp.Packet) (unit.Payload, error) {
tu, err := (*rtpav1.Decoder)(d).Decode(pkt)
if err != nil {
if errors.Is(err, rtpav1.ErrNonStartingPacketAndNoPrevious) ||
errors.Is(err, rtpav1.ErrMorePacketsNeeded) {
return nil, nil
}
return nil, err
}
return unit.PayloadAV1(tu), nil
}
type rtpDecoderVP9 rtpvp9.Decoder
func (d *rtpDecoderVP9) decode(pkt *rtp.Packet) (unit.Payload, error) {
frame, err := (*rtpvp9.Decoder)(d).Decode(pkt)
if err != nil {
if errors.Is(err, rtpvp9.ErrNonStartingPacketAndNoPrevious) ||
errors.Is(err, rtpvp9.ErrMorePacketsNeeded) {
return nil, nil
}
return nil, err
}
return unit.PayloadVP9(frame), nil
}
type rtpDecoderVP8 rtpvp8.Decoder
func (d *rtpDecoderVP8) decode(pkt *rtp.Packet) (unit.Payload, error) {
frame, err := (*rtpvp8.Decoder)(d).Decode(pkt)
if err != nil {
if errors.Is(err, rtpvp8.ErrNonStartingPacketAndNoPrevious) ||
errors.Is(err, rtpvp8.ErrMorePacketsNeeded) {
return nil, nil
}
return nil, err
}
return unit.PayloadVP8(frame), nil
}
type rtpDecoderH265 rtph265.Decoder
func (d *rtpDecoderH265) decode(pkt *rtp.Packet) (unit.Payload, error) {
au, err := (*rtph265.Decoder)(d).Decode(pkt)
if err != nil {
if errors.Is(err, rtph265.ErrNonStartingPacketAndNoPrevious) ||
errors.Is(err, rtph265.ErrMorePacketsNeeded) {
return nil, nil
}
return nil, err
}
return unit.PayloadH265(au), nil
}
type rtpDecoderH264 rtph264.Decoder
func (d *rtpDecoderH264) decode(pkt *rtp.Packet) (unit.Payload, error) {
au, err := (*rtph264.Decoder)(d).Decode(pkt)
if err != nil {
if errors.Is(err, rtph264.ErrNonStartingPacketAndNoPrevious) ||
errors.Is(err, rtph264.ErrMorePacketsNeeded) {
return nil, nil
}
return nil, err
}
return unit.PayloadH264(au), nil
}
type rtpDecoderMPEG4Video rtpfragmented.Decoder
func (d *rtpDecoderMPEG4Video) decode(pkt *rtp.Packet) (unit.Payload, error) {
frame, err := (*rtpfragmented.Decoder)(d).Decode(pkt)
if err != nil {
if errors.Is(err, rtpfragmented.ErrMorePacketsNeeded) {
return nil, nil
}
return nil, err
}
return unit.PayloadMPEG4Video(frame), nil
}
type rtpDecoderMPEG1Video rtpmpeg1video.Decoder
func (d *rtpDecoderMPEG1Video) decode(pkt *rtp.Packet) (unit.Payload, error) {
frame, err := (*rtpmpeg1video.Decoder)(d).Decode(pkt)
if err != nil {
if errors.Is(err, rtpmpeg1video.ErrNonStartingPacketAndNoPrevious) ||
errors.Is(err, rtpmpeg1video.ErrMorePacketsNeeded) {
return nil, nil
}
return nil, err
}
return unit.PayloadMPEG1Video(frame), nil
}
type rtpDecoderMJPEG rtpmjpeg.Decoder
func (d *rtpDecoderMJPEG) decode(pkt *rtp.Packet) (unit.Payload, error) {
frame, err := (*rtpmjpeg.Decoder)(d).Decode(pkt)
if err != nil {
if errors.Is(err, rtpmjpeg.ErrNonStartingPacketAndNoPrevious) ||
errors.Is(err, rtpmjpeg.ErrMorePacketsNeeded) {
return nil, nil
}
return nil, err
}
return unit.PayloadMJPEG(frame), nil
}
type rtpDecoderOpus rtpsimpleaudio.Decoder
func (d *rtpDecoderOpus) decode(pkt *rtp.Packet) (unit.Payload, error) {
packet, err := (*rtpsimpleaudio.Decoder)(d).Decode(pkt)
if err != nil {
return nil, err
}
return unit.PayloadOpus{packet}, nil
}
type rtpDecoderMPEG4Audio rtpmpeg4audio.Decoder
func (d *rtpDecoderMPEG4Audio) decode(pkt *rtp.Packet) (unit.Payload, error) {
aus, err := (*rtpmpeg4audio.Decoder)(d).Decode(pkt)
if err != nil {
if errors.Is(err, rtpmpeg4audio.ErrMorePacketsNeeded) {
return nil, nil
}
return nil, err
}
return unit.PayloadMPEG4Audio(aus), nil
}
type rtpDecoderMPEG4AudioLATM rtpfragmented.Decoder
func (d *rtpDecoderMPEG4AudioLATM) decode(pkt *rtp.Packet) (unit.Payload, error) {
payload, err := (*rtpfragmented.Decoder)(d).Decode(pkt)
if err != nil {
if errors.Is(err, rtpfragmented.ErrMorePacketsNeeded) {
return nil, nil
}
return nil, err
}
return unit.PayloadMPEG4AudioLATM(payload), nil
}
type rtpDecoderMPEG1Audio rtpmpeg1audio.Decoder
func (d *rtpDecoderMPEG1Audio) decode(pkt *rtp.Packet) (unit.Payload, error) {
frames, err := (*rtpmpeg1audio.Decoder)(d).Decode(pkt)
if err != nil {
if errors.Is(err, rtpmpeg1audio.ErrNonStartingPacketAndNoPrevious) ||
errors.Is(err, rtpmpeg1audio.ErrMorePacketsNeeded) {
return nil, nil
}
return nil, err
}
return unit.PayloadMPEG1Audio(frames), nil
}
type rtpDecoderAC3 rtpac3.Decoder
func (d *rtpDecoderAC3) decode(pkt *rtp.Packet) (unit.Payload, error) {
frames, err := (*rtpac3.Decoder)(d).Decode(pkt)
if err != nil {
if errors.Is(err, rtpac3.ErrMorePacketsNeeded) {
return nil, nil
}
return nil, err
}
return unit.PayloadAC3(frames), nil
}
type rtpDecoderG711 rtplpcm.Decoder
func (d *rtpDecoderG711) decode(pkt *rtp.Packet) (unit.Payload, error) {
samples, err := (*rtplpcm.Decoder)(d).Decode(pkt)
if err != nil {
return nil, err
}
return unit.PayloadG711(samples), nil
}
type rtpDecoderLPCM rtplpcm.Decoder
func (d *rtpDecoderLPCM) decode(pkt *rtp.Packet) (unit.Payload, error) {
samples, err := (*rtplpcm.Decoder)(d).Decode(pkt)
if err != nil {
return nil, err
}
return unit.PayloadLPCM(samples), nil
}
type rtpDecoderKLV rtpklv.Decoder
func (d *rtpDecoderKLV) decode(pkt *rtp.Packet) (unit.Payload, error) {
payload, err := (*rtpklv.Decoder)(d).Decode(pkt)
if err != nil {
return nil, err
}
return unit.PayloadKLV(payload), nil
}
func newRTPDecoder(forma format.Format) (rtpDecoder, error) {
switch forma := forma.(type) {
case *format.AV1:
wrapped, err := forma.CreateDecoder()
if err != nil {
return nil, err
}
return (*rtpDecoderAV1)(wrapped), nil
case *format.VP9:
wrapped, err := forma.CreateDecoder()
if err != nil {
return nil, err
}
return (*rtpDecoderVP9)(wrapped), nil
case *format.VP8:
wrapped, err := forma.CreateDecoder()
if err != nil {
return nil, err
}
return (*rtpDecoderVP8)(wrapped), nil
case *format.H265:
wrapped, err := forma.CreateDecoder()
if err != nil {
return nil, err
}
return (*rtpDecoderH265)(wrapped), nil
case *format.H264:
wrapped, err := forma.CreateDecoder()
if err != nil {
return nil, err
}
return (*rtpDecoderH264)(wrapped), nil
case *format.MPEG4Video:
wrapped, err := forma.CreateDecoder()
if err != nil {
return nil, err
}
return (*rtpDecoderMPEG4Video)(wrapped), nil
case *format.MPEG1Video:
wrapped, err := forma.CreateDecoder()
if err != nil {
return nil, err
}
return (*rtpDecoderMPEG1Video)(wrapped), nil
case *format.MJPEG:
wrapped, err := forma.CreateDecoder()
if err != nil {
return nil, err
}
return (*rtpDecoderMJPEG)(wrapped), nil
case *format.Opus:
wrapped, err := forma.CreateDecoder()
if err != nil {
return nil, err
}
return (*rtpDecoderOpus)(wrapped), nil
case *format.MPEG4Audio:
wrapped, err := forma.CreateDecoder()
if err != nil {
return nil, err
}
return (*rtpDecoderMPEG4Audio)(wrapped), nil
case *format.MPEG4AudioLATM:
wrapped, err := forma.CreateDecoder()
if err != nil {
return nil, err
}
return (*rtpDecoderMPEG4AudioLATM)(wrapped), nil
case *format.MPEG1Audio:
wrapped, err := forma.CreateDecoder()
if err != nil {
return nil, err
}
return (*rtpDecoderMPEG1Audio)(wrapped), nil
case *format.AC3:
wrapped, err := forma.CreateDecoder()
if err != nil {
return nil, err
}
return (*rtpDecoderAC3)(wrapped), nil
case *format.G711:
wrapped, err := forma.CreateDecoder()
if err != nil {
return nil, err
}
return (*rtpDecoderG711)(wrapped), nil
case *format.LPCM:
wrapped, err := forma.CreateDecoder()
if err != nil {
return nil, err
}
return (*rtpDecoderLPCM)(wrapped), nil
case *format.KLV:
wrapped, err := forma.CreateDecoder()
if err != nil {
return nil, err
}
return (*rtpDecoderKLV)(wrapped), nil
default:
return nil, nil
}
}
================================================
FILE: internal/stream/rtp_encoder.go
================================================
package stream
import (
"fmt"
"github.com/bluenviron/gortsplib/v5/pkg/format"
"github.com/bluenviron/gortsplib/v5/pkg/format/rtpac3"
"github.com/bluenviron/gortsplib/v5/pkg/format/rtpav1"
"github.com/bluenviron/gortsplib/v5/pkg/format/rtpfragmented"
"github.com/bluenviron/gortsplib/v5/pkg/format/rtph264"
"github.com/bluenviron/gortsplib/v5/pkg/format/rtph265"
"github.com/bluenviron/gortsplib/v5/pkg/format/rtpklv"
"github.com/bluenviron/gortsplib/v5/pkg/format/rtplpcm"
"github.com/bluenviron/gortsplib/v5/pkg/format/rtpmjpeg"
"github.com/bluenviron/gortsplib/v5/pkg/format/rtpmpeg1audio"
"github.com/bluenviron/gortsplib/v5/pkg/format/rtpmpeg1video"
"github.com/bluenviron/gortsplib/v5/pkg/format/rtpmpeg4audio"
"github.com/bluenviron/gortsplib/v5/pkg/format/rtpsimpleaudio"
"github.com/bluenviron/gortsplib/v5/pkg/format/rtpvp8"
"github.com/bluenviron/gortsplib/v5/pkg/format/rtpvp9"
mcopus "github.com/bluenviron/mediacommon/v2/pkg/codecs/opus"
"github.com/bluenviron/mediamtx/internal/unit"
"github.com/pion/rtp"
)
func ptrOf[T any](v T) *T {
p := new(T)
*p = v
return p
}
type rtpEncoderNotAvailableError struct {
format format.Format
}
func (e rtpEncoderNotAvailableError) Error() string {
return fmt.Sprintf("RTP encoder not available for format %T", e.format)
}
type rtpEncoder interface {
encode(unit.Payload) ([]*rtp.Packet, error)
}
type rtpEncoderH265 rtph265.Encoder
func (e *rtpEncoderH265) encode(payload unit.Payload) ([]*rtp.Packet, error) {
return (*rtph265.Encoder)(e).Encode(payload.(unit.PayloadH265))
}
type rtpEncoderH264 rtph264.Encoder
func (e *rtpEncoderH264) encode(payload unit.Payload) ([]*rtp.Packet, error) {
return (*rtph264.Encoder)(e).Encode(payload.(unit.PayloadH264))
}
type rtpEncoderAV1 rtpav1.Encoder
func (e *rtpEncoderAV1) encode(payload unit.Payload) ([]*rtp.Packet, error) {
return (*rtpav1.Encoder)(e).Encode(payload.(unit.PayloadAV1))
}
type rtpEncoderVP9 rtpvp9.Encoder
func (e *rtpEncoderVP9) encode(payload unit.Payload) ([]*rtp.Packet, error) {
return (*rtpvp9.Encoder)(e).Encode(payload.(unit.PayloadVP9))
}
type rtpEncoderVP8 rtpvp8.Encoder
func (e *rtpEncoderVP8) encode(payload unit.Payload) ([]*rtp.Packet, error) {
return (*rtpvp8.Encoder)(e).Encode(payload.(unit.PayloadVP8))
}
type rtpEncoderMPEG4Video rtpfragmented.Encoder
func (e *rtpEncoderMPEG4Video) encode(payload unit.Payload) ([]*rtp.Packet, error) {
return (*rtpfragmented.Encoder)(e).Encode(payload.(unit.PayloadMPEG4Video))
}
type rtpEncoderMPEG1Video rtpmpeg1video.Encoder
func (e *rtpEncoderMPEG1Video) encode(payload unit.Payload) ([]*rtp.Packet, error) {
return (*rtpmpeg1video.Encoder)(e).Encode(payload.(unit.PayloadMPEG1Video))
}
type rtpEncoderMJPEG rtpmjpeg.Encoder
func (e *rtpEncoderMJPEG) encode(payload unit.Payload) ([]*rtp.Packet, error) {
return (*rtpmjpeg.Encoder)(e).Encode(payload.(unit.PayloadMJPEG))
}
type rtpEncoderOpus rtpsimpleaudio.Encoder
func (e *rtpEncoderOpus) encode(payload unit.Payload) ([]*rtp.Packet, error) {
pts := int64(0)
packets := make([]*rtp.Packet, len(payload.(unit.PayloadOpus)))
for i, packet := range payload.(unit.PayloadOpus) {
pkt, err := (*rtpsimpleaudio.Encoder)(e).Encode(packet)
if err != nil {
return nil, err
}
pkt.Timestamp += uint32(pts)
pts += mcopus.PacketDuration2(packet)
packets[i] = pkt
}
return packets, nil
}
type rtpEncoderMPEG4Audio rtpmpeg4audio.Encoder
func (e *rtpEncoderMPEG4Audio) encode(payload unit.Payload) ([]*rtp.Packet, error) {
return (*rtpmpeg4audio.Encoder)(e).Encode(payload.(unit.PayloadMPEG4Audio))
}
type rtpEncoderMPEG4AudioLATM rtpfragmented.Encoder
func (e *rtpEncoderMPEG4AudioLATM) encode(payload unit.Payload) ([]*rtp.Packet, error) {
return (*rtpfragmented.Encoder)(e).Encode(payload.(unit.PayloadMPEG4AudioLATM))
}
type rtpEncoderMPEG1Audio rtpmpeg1audio.Encoder
func (e *rtpEncoderMPEG1Audio) encode(payload unit.Payload) ([]*rtp.Packet, error) {
return (*rtpmpeg1audio.Encoder)(e).Encode(payload.(unit.PayloadMPEG1Audio))
}
type rtpEncoderAC3 rtpac3.Encoder
func (e *rtpEncoderAC3) encode(payload unit.Payload) ([]*rtp.Packet, error) {
return (*rtpac3.Encoder)(e).Encode(payload.(unit.PayloadAC3))
}
type rtpEncoderG711 rtplpcm.Encoder
func (e *rtpEncoderG711) encode(payload unit.Payload) ([]*rtp.Packet, error) {
return (*rtplpcm.Encoder)(e).Encode(payload.(unit.PayloadG711))
}
type rtpEncoderLPCM rtplpcm.Encoder
func (e *rtpEncoderLPCM) encode(payload unit.Payload) ([]*rtp.Packet, error) {
return (*rtplpcm.Encoder)(e).Encode(payload.(unit.PayloadLPCM))
}
type rtpEncoderKLV rtpklv.Encoder
func (e *rtpEncoderKLV) encode(payload unit.Payload) ([]*rtp.Packet, error) {
return (*rtpklv.Encoder)(e).Encode(payload.(unit.PayloadKLV))
}
func newRTPEncoder(
forma format.Format,
rtpMaxPayloadSize int,
ssrc *uint32,
initialSequenceNumber *uint16,
) (rtpEncoder, error) {
switch forma := forma.(type) {
case *format.H265:
wrapped := &rtph265.Encoder{
PayloadMaxSize: rtpMaxPayloadSize,
PayloadType: forma.PayloadTyp,
SSRC: ssrc,
InitialSequenceNumber: initialSequenceNumber,
MaxDONDiff: forma.MaxDONDiff,
}
err := wrapped.Init()
if err != nil {
return nil, err
}
return (*rtpEncoderH265)(wrapped), nil
case *format.H264:
wrapped := &rtph264.Encoder{
PayloadMaxSize: rtpMaxPayloadSize,
PayloadType: forma.PayloadTyp,
SSRC: ssrc,
InitialSequenceNumber: initialSequenceNumber,
PacketizationMode: forma.PacketizationMode,
}
err := wrapped.Init()
if err != nil {
return nil, err
}
return (*rtpEncoderH264)(wrapped), nil
case *format.AV1:
wrapped := &rtpav1.Encoder{
PayloadMaxSize: rtpMaxPayloadSize,
PayloadType: forma.PayloadTyp,
SSRC: ssrc,
InitialSequenceNumber: initialSequenceNumber,
}
err := wrapped.Init()
if err != nil {
return nil, err
}
return (*rtpEncoderAV1)(wrapped), nil
case *format.VP9:
wrapped := &rtpvp9.Encoder{
PayloadMaxSize: rtpMaxPayloadSize,
PayloadType: forma.PayloadTyp,
SSRC: ssrc,
InitialSequenceNumber: initialSequenceNumber,
InitialPictureID: ptrOf(uint16(0x35af)),
}
err := wrapped.Init()
if err != nil {
return nil, err
}
return (*rtpEncoderVP9)(wrapped), nil
case *format.VP8:
wrapped := &rtpvp8.Encoder{
PayloadMaxSize: rtpMaxPayloadSize,
PayloadType: forma.PayloadTyp,
SSRC: ssrc,
InitialSequenceNumber: initialSequenceNumber,
}
err := wrapped.Init()
if err != nil {
return nil, err
}
return (*rtpEncoderVP8)(wrapped), nil
case *format.MPEG4Video:
wrapped := &rtpfragmented.Encoder{
PayloadMaxSize: rtpMaxPayloadSize,
PayloadType: forma.PayloadTyp,
SSRC: ssrc,
InitialSequenceNumber: initialSequenceNumber,
}
err := wrapped.Init()
if err != nil {
return nil, err
}
return (*rtpEncoderMPEG4Video)(wrapped), nil
case *format.MPEG1Video:
wrapped := &rtpmpeg1video.Encoder{
PayloadMaxSize: rtpMaxPayloadSize,
SSRC: ssrc,
InitialSequenceNumber: initialSequenceNumber,
}
err := wrapped.Init()
if err != nil {
return nil, err
}
return (*rtpEncoderMPEG1Video)(wrapped), nil
case *format.MJPEG:
wrapped := &rtpmjpeg.Encoder{
PayloadMaxSize: rtpMaxPayloadSize,
SSRC: ssrc,
InitialSequenceNumber: initialSequenceNumber,
}
err := wrapped.Init()
if err != nil {
return nil, err
}
return (*rtpEncoderMJPEG)(wrapped), nil
case *format.Opus:
wrapped := &rtpsimpleaudio.Encoder{
PayloadMaxSize: rtpMaxPayloadSize,
PayloadType: forma.PayloadTyp,
SSRC: ssrc,
InitialSequenceNumber: initialSequenceNumber,
}
err := wrapped.Init()
if err != nil {
return nil, err
}
return (*rtpEncoderOpus)(wrapped), nil
case *format.MPEG4Audio:
wrapped := &rtpmpeg4audio.Encoder{
PayloadMaxSize: rtpMaxPayloadSize,
PayloadType: forma.PayloadTyp,
SSRC: ssrc,
InitialSequenceNumber: initialSequenceNumber,
SizeLength: forma.SizeLength,
IndexLength: forma.IndexLength,
IndexDeltaLength: forma.IndexDeltaLength,
}
err := wrapped.Init()
if err != nil {
return nil, err
}
return (*rtpEncoderMPEG4Audio)(wrapped), nil
case *format.MPEG4AudioLATM:
wrapped := &rtpfragmented.Encoder{
PayloadMaxSize: rtpMaxPayloadSize,
PayloadType: forma.PayloadTyp,
SSRC: ssrc,
InitialSequenceNumber: initialSequenceNumber,
}
err := wrapped.Init()
if err != nil {
return nil, err
}
return (*rtpEncoderMPEG4AudioLATM)(wrapped), nil
case *format.MPEG1Audio:
wrapped := &rtpmpeg1audio.Encoder{
PayloadMaxSize: rtpMaxPayloadSize,
SSRC: ssrc,
InitialSequenceNumber: initialSequenceNumber,
}
err := wrapped.Init()
if err != nil {
return nil, err
}
return (*rtpEncoderMPEG1Audio)(wrapped), nil
case *format.AC3:
wrapped := &rtpac3.Encoder{
PayloadType: forma.PayloadTyp,
SSRC: ssrc,
InitialSequenceNumber: initialSequenceNumber,
}
err := wrapped.Init()
if err != nil {
return nil, err
}
return (*rtpEncoderAC3)(wrapped), nil
case *format.G711:
wrapped := &rtplpcm.Encoder{
PayloadMaxSize: rtpMaxPayloadSize,
PayloadType: forma.PayloadType(),
SSRC: ssrc,
InitialSequenceNumber: initialSequenceNumber,
BitDepth: 8,
ChannelCount: forma.ChannelCount,
}
err := wrapped.Init()
if err != nil {
return nil, err
}
return (*rtpEncoderG711)(wrapped), nil
case *format.LPCM:
wrapped := &rtplpcm.Encoder{
PayloadMaxSize: rtpMaxPayloadSize,
PayloadType: forma.PayloadTyp,
SSRC: ssrc,
InitialSequenceNumber: initialSequenceNumber,
BitDepth: forma.BitDepth,
ChannelCount: forma.ChannelCount,
}
err := wrapped.Init()
if err != nil {
return nil, err
}
return (*rtpEncoderLPCM)(wrapped), nil
case *format.KLV:
wrapped := &rtpklv.Encoder{
PayloadMaxSize: rtpMaxPayloadSize,
PayloadType: forma.PayloadTyp,
SSRC: ssrc,
InitialSequenceNumber: initialSequenceNumber,
}
err := wrapped.Init()
if err != nil {
return nil, err
}
return (*rtpEncoderKLV)(wrapped), nil
default:
return nil, rtpEncoderNotAvailableError{forma}
}
}
================================================
FILE: internal/stream/stream.go
================================================
// Package stream contains the Stream object.
package stream
import (
"os"
"sync"
"sync/atomic"
"time"
"github.com/bluenviron/gortsplib/v5"
"github.com/bluenviron/gortsplib/v5/pkg/description"
"github.com/bluenviron/gortsplib/v5/pkg/format"
"github.com/bluenviron/mediacommon/v2/pkg/codecs/mpeg4audio"
"github.com/bluenviron/mediacommon/v2/pkg/formats/mp4/codecs"
"github.com/bluenviron/mediacommon/v2/pkg/formats/pmp4"
"github.com/pion/rtp"
"github.com/bluenviron/mediamtx/internal/conf"
"github.com/bluenviron/mediamtx/internal/errordumper"
"github.com/bluenviron/mediamtx/internal/logger"
)
func mediasFromAlwaysAvailableFile(alwaysAvailableFile string) ([]*description.Media, error) {
f, err := os.Open(alwaysAvailableFile)
if err != nil {
return nil, err
}
defer f.Close()
var presentation pmp4.Presentation
err = presentation.Unmarshal(f)
if err != nil {
return nil, err
}
var medias []*description.Media
for _, track := range presentation.Tracks {
switch codec := track.Codec.(type) {
case *codecs.AV1:
medias = append(medias, &description.Media{
Type: description.MediaTypeVideo,
Formats: []format.Format{&format.AV1{
PayloadTyp: 96,
}},
})
case *codecs.VP9:
medias = append(medias, &description.Media{
Type: description.MediaTypeVideo,
Formats: []format.Format{&format.VP9{
PayloadTyp: 96,
}},
})
case *codecs.H265:
medias = append(medias, &description.Media{
Type: description.MediaTypeVideo,
Formats: []format.Format{&format.H265{
PayloadTyp: 96,
VPS: codec.VPS,
SPS: codec.SPS,
PPS: codec.PPS,
}},
})
case *codecs.H264:
medias = append(medias, &description.Media{
Type: description.MediaTypeVideo,
Formats: []format.Format{&format.H264{
PayloadTyp: 96,
PacketizationMode: 1,
SPS: codec.SPS,
PPS: codec.PPS,
}},
})
case *codecs.Opus:
medias = append(medias, &description.Media{
Type: description.MediaTypeAudio,
Formats: []format.Format{&format.Opus{
PayloadTyp: 96,
ChannelCount: codec.ChannelCount,
}},
})
case *codecs.MPEG4Audio:
medias = append(medias, &description.Media{
Type: description.MediaTypeAudio,
Formats: []format.Format{&format.MPEG4Audio{
PayloadTyp: 96,
SizeLength: 13,
IndexLength: 3,
IndexDeltaLength: 3,
Config: &mpeg4audio.AudioSpecificConfig{
Type: codec.Config.Type,
SampleRate: codec.Config.SampleRate,
ChannelConfig: codec.Config.ChannelConfig,
ChannelCount: codec.Config.ChannelCount, //nolint:staticcheck
},
}},
})
case *codecs.LPCM:
medias = append(medias, &description.Media{
Type: description.MediaTypeAudio,
Formats: []format.Format{&format.LPCM{
PayloadTyp: 96,
BitDepth: codec.BitDepth,
SampleRate: codec.SampleRate,
ChannelCount: codec.ChannelCount,
}},
})
}
}
return medias, nil
}
func mediasFromAlwaysAvailableTracks(alwaysAvailableTracks []conf.AlwaysAvailableTrack) []*description.Media {
var medias []*description.Media
for _, track := range alwaysAvailableTracks {
switch track.Codec {
case conf.CodecAV1:
medias = append(medias, &description.Media{
Type: description.MediaTypeVideo,
Formats: []format.Format{&format.AV1{
PayloadTyp: 96,
}},
})
case conf.CodecVP9:
medias = append(medias, &description.Media{
Type: description.MediaTypeVideo,
Formats: []format.Format{&format.VP9{
PayloadTyp: 96,
}},
})
case conf.CodecH265:
medias = append(medias, &description.Media{
Type: description.MediaTypeVideo,
Formats: []format.Format{&format.H265{
PayloadTyp: 96,
VPS: offlineH265VPS,
SPS: offlineH265SPS,
PPS: offlineH265PPS,
}},
})
case conf.CodecH264:
medias = append(medias, &description.Media{
Type: description.MediaTypeVideo,
Formats: []format.Format{&format.H264{
PayloadTyp: 96,
PacketizationMode: 1,
SPS: offlineH264SPS,
PPS: offlineH264PPS,
}},
})
case conf.CodecOpus:
medias = append(medias, &description.Media{
Type: description.MediaTypeAudio,
Formats: []format.Format{&format.Opus{
PayloadTyp: 96,
ChannelCount: 2,
}},
})
case conf.CodecMPEG4Audio:
medias = append(medias, &description.Media{
Type: description.MediaTypeAudio,
Formats: []format.Format{&format.MPEG4Audio{
PayloadTyp: 96,
SizeLength: 13,
IndexLength: 3,
IndexDeltaLength: 3,
Config: &mpeg4audio.AudioSpecificConfig{
Type: mpeg4audio.ObjectTypeAACLC,
SampleRate: track.SampleRate,
ChannelConfig: uint8(track.ChannelCount),
ChannelCount: track.ChannelCount,
},
}},
})
case conf.CodecG711:
medias = append(medias, &description.Media{
Type: description.MediaTypeAudio,
Formats: []format.Format{&format.G711{
PayloadTyp: func() uint8 {
switch {
case track.ChannelCount == 1 && track.MULaw:
return 0
case track.ChannelCount == 1 && !track.MULaw:
return 8
default:
return 96
}
}(),
MULaw: track.MULaw,
SampleRate: track.SampleRate,
ChannelCount: track.ChannelCount,
}},
})
case conf.CodecLPCM:
medias = append(medias, &description.Media{
Type: description.MediaTypeAudio,
Formats: []format.Format{&format.LPCM{
PayloadTyp: 96,
BitDepth: 16,
SampleRate: track.SampleRate,
ChannelCount: track.ChannelCount,
}},
})
}
}
return medias
}
// only fields filled by mediasFromAlwaysAvailableFile and mediasFromAlwaysAvailableTracks are cloned
func cloneFormat(forma format.Format) format.Format {
switch forma := forma.(type) {
case *format.AV1:
return &format.AV1{
PayloadTyp: forma.PayloadTyp,
}
case *format.VP9:
return &format.VP9{
PayloadTyp: forma.PayloadTyp,
}
case *format.H265:
return &format.H265{
PayloadTyp: forma.PayloadTyp,
VPS: forma.VPS,
SPS: forma.SPS,
PPS: forma.PPS,
}
case *format.H264:
return &format.H264{
PayloadTyp: forma.PayloadTyp,
PacketizationMode: forma.PacketizationMode,
SPS: forma.SPS,
PPS: forma.PPS,
}
case *format.Opus:
return &format.Opus{
PayloadTyp: forma.PayloadTyp,
ChannelCount: forma.ChannelCount,
}
case *format.MPEG4Audio:
return &format.MPEG4Audio{
PayloadTyp: forma.PayloadTyp,
SizeLength: forma.SizeLength,
IndexLength: forma.IndexLength,
IndexDeltaLength: forma.IndexDeltaLength,
Config: forma.Config,
}
case *format.G711:
return &format.G711{
PayloadTyp: forma.PayloadTyp,
MULaw: forma.MULaw,
SampleRate: forma.SampleRate,
ChannelCount: forma.ChannelCount,
}
case *format.LPCM:
return &format.LPCM{
PayloadTyp: forma.PayloadTyp,
BitDepth: forma.BitDepth,
SampleRate: forma.SampleRate,
ChannelCount: forma.ChannelCount,
}
default:
panic("unsupported format")
}
}
// only fields filled by mediasFromAlwaysAvailableFile and mediasFromAlwaysAvailableTracks are cloned
func cloneDesc(desc *description.Session) *description.Session {
medias := make([]*description.Media, len(desc.Medias))
for i, media := range desc.Medias {
formats := make([]format.Format, len(media.Formats))
for j, forma := range media.Formats {
formats[j] = cloneFormat(forma)
}
medias[i] = &description.Media{
Type: media.Type,
Formats: formats,
}
}
return &description.Session{
Medias: medias,
}
}
// Stream is a media stream.
// It stores tracks, readers and allows to write data to readers, remuxing it when needed.
type Stream struct {
Desc *description.Session
AlwaysAvailable bool
AlwaysAvailableTracks []conf.AlwaysAvailableTrack
AlwaysAvailableFile string
WriteQueueSize int
RTPMaxPayloadSize int
ReplaceNTP bool
Parent logger.Writer
offlineDesc *description.Session
mutex sync.RWMutex
subStream *SubStream
offlineSubStream *offlineSubStream
inboundBytes *uint64
outboundBytes *uint64
medias map[*description.Media]*streamMedia
rtspStream *gortsplib.ServerStream
rtspsStream *gortsplib.ServerStream
readers map[*Reader]struct{}
inboundFramesInError *errordumper.Dumper
timeMutex sync.Mutex
firstTimeReceived bool
lastPTS time.Duration
lastSystemTime time.Time
hasReaders chan struct{}
}
// Initialize initializes a Stream.
func (s *Stream) Initialize() error {
if s.AlwaysAvailable {
if s.Desc != nil {
panic("should not happen")
}
if !s.ReplaceNTP {
panic("should not happen")
}
var medias []*description.Media
if s.AlwaysAvailableFile != "" {
var err error
medias, err = mediasFromAlwaysAvailableFile(s.AlwaysAvailableFile)
if err != nil {
return err
}
} else {
medias = mediasFromAlwaysAvailableTracks(s.AlwaysAvailableTracks)
}
s.offlineDesc = &description.Session{
Medias: medias,
}
// clone the description since its parameters can be modified
s.Desc = cloneDesc(s.offlineDesc)
}
s.inboundBytes = new(uint64)
s.outboundBytes = new(uint64)
s.medias = make(map[*description.Media]*streamMedia)
s.readers = make(map[*Reader]struct{})
s.hasReaders = make(chan struct{})
s.inboundFramesInError = &errordumper.Dumper{
OnReport: func(val uint64, last error) {
if val == 1 {
s.Parent.Log(logger.Warn, "processing error: %v", last)
} else {
s.Parent.Log(logger.Warn, "%d processing errors, last was: %v", val, last)
}
},
}
s.inboundFramesInError.Start()
s.lastSystemTime = time.Now()
for _, media := range s.Desc.Medias {
sm := &streamMedia{
media: media,
alwaysAvailable: s.AlwaysAvailable,
rtpMaxPayloadSize: s.RTPMaxPayloadSize,
replaceNTP: s.ReplaceNTP,
addInboundBytes: s.addInboundBytes,
addOutboundBytes: s.addOutboundBytes,
updateLastTime: s.updateLastTime,
writeRTSP: s.writeRTSP,
inboundFramesInError: s.inboundFramesInError,
parent: s.Parent,
}
err := sm.initialize()
if err != nil {
return err
}
s.medias[media] = sm
}
if s.AlwaysAvailable {
err := s.StartOfflineSubStream()
if err != nil {
return err
}
}
return nil
}
// Close closes all resources of the stream.
func (s *Stream) Close() {
if s.offlineSubStream != nil {
s.offlineSubStream.close(false)
}
s.inboundFramesInError.Stop()
if s.rtspStream != nil {
s.rtspStream.Close()
}
if s.rtspsStream != nil {
s.rtspsStream.Close()
}
}
// StartOfflineSubStream starts the offline substream.
func (s *Stream) StartOfflineSubStream() error {
if !s.AlwaysAvailable {
panic("should not happen")
}
oss := &offlineSubStream{
stream: s,
}
err := oss.initialize()
if err != nil {
return err
}
if s.offlineSubStream != nil {
s.Parent.Log(logger.Info, "stream is offline")
}
s.offlineSubStream = oss
return nil
}
// InboundBytes returns received bytes.
func (s *Stream) InboundBytes() uint64 {
return atomic.LoadUint64(s.inboundBytes)
}
// OutboundBytes returns sent bytes.
func (s *Stream) OutboundBytes() uint64 {
outboundBytes := atomic.LoadUint64(s.outboundBytes)
s.mutex.RLock()
defer s.mutex.RUnlock()
if s.rtspStream != nil {
stats := s.rtspStream.Stats()
outboundBytes += stats.OutboundBytes
}
if s.rtspsStream != nil {
stats := s.rtspsStream.Stats()
outboundBytes += stats.OutboundBytes
}
return outboundBytes
}
// InboundFramesInError returns the number of frames received with processing errors.
func (s *Stream) InboundFramesInError() uint64 {
return s.inboundFramesInError.Get()
}
// RTSPStream returns the RTSP stream.
func (s *Stream) RTSPStream(server *gortsplib.Server) *gortsplib.ServerStream {
s.mutex.Lock()
defer s.mutex.Unlock()
if s.rtspStream == nil {
s.rtspStream = &gortsplib.ServerStream{
Server: server,
Desc: s.Desc,
}
err := s.rtspStream.Initialize()
if err != nil {
panic(err)
}
}
return s.rtspStream
}
// RTSPSStream returns the RTSPS stream.
func (s *Stream) RTSPSStream(server *gortsplib.Server) *gortsplib.ServerStream {
s.mutex.Lock()
defer s.mutex.Unlock()
if s.rtspsStream == nil {
s.rtspsStream = &gortsplib.ServerStream{
Server: server,
Desc: s.Desc,
}
err := s.rtspsStream.Initialize()
if err != nil {
panic(err)
}
}
return s.rtspsStream
}
// AddReader adds a reader.
// Used by all protocols except RTSP.
func (s *Stream) AddReader(r *Reader) {
s.mutex.Lock()
defer s.mutex.Unlock()
s.readers[r] = struct{}{}
for medi, formats := range r.onDatas {
sm := s.medias[medi]
for forma, onData := range formats {
sf := sm.formats[forma]
sf.onDatas[r] = onData
}
}
r.queueSize = s.WriteQueueSize
r.start()
select {
case <-s.hasReaders:
default:
close(s.hasReaders)
}
}
// RemoveReader removes a reader.
// Used by all protocols except RTSP.
func (s *Stream) RemoveReader(r *Reader) {
s.mutex.Lock()
defer s.mutex.Unlock()
r.stop()
for medi, formats := range r.onDatas {
sm := s.medias[medi]
for forma := range formats {
sf := sm.formats[forma]
delete(sf.onDatas, r)
}
}
delete(s.readers, r)
}
// WaitForReaders waits for the stream to have at least one reader.
func (s *Stream) WaitForReaders() {
<-s.hasReaders
}
func (s *Stream) addInboundBytes(v uint64) {
atomic.AddUint64(s.inboundBytes, v)
}
func (s *Stream) addOutboundBytes(v uint64) {
atomic.AddUint64(s.outboundBytes, v)
}
func (s *Stream) updateLastTime(pts time.Duration) {
s.timeMutex.Lock()
defer s.timeMutex.Unlock()
s.firstTimeReceived = true
if pts > s.lastPTS {
s.lastPTS = pts
}
s.lastSystemTime = time.Now()
}
func (s *Stream) writeRTSP(medi *description.Media, pkts []*rtp.Packet, ntp time.Time) {
if s.rtspStream != nil {
for _, pkt := range pkts {
s.rtspStream.WritePacketRTPWithNTP(medi, pkt, ntp) //nolint:errcheck
}
}
if s.rtspsStream != nil {
for _, pkt := range pkts {
s.rtspsStream.WritePacketRTPWithNTP(medi, pkt, ntp) //nolint:errcheck
}
}
}
================================================
FILE: internal/stream/stream_alwaysavailable_test.go
================================================
package stream
import (
"os"
"sync"
"sync/atomic"
"testing"
"github.com/bluenviron/gortsplib/v5/pkg/description"
"github.com/bluenviron/gortsplib/v5/pkg/format"
"github.com/bluenviron/mediacommon/v2/pkg/codecs/mpeg4audio"
"github.com/bluenviron/mediacommon/v2/pkg/formats/mp4/codecs"
"github.com/bluenviron/mediacommon/v2/pkg/formats/pmp4"
"github.com/bluenviron/mediamtx/internal/conf"
"github.com/bluenviron/mediamtx/internal/unit"
"github.com/stretchr/testify/require"
)
func TestStreamAlwaysAvailableErrors(t *testing.T) {
for _, ca := range []struct {
name string
tracks []conf.AlwaysAvailableTrack
desc *description.Session
err string
}{
{
"wrong tracks",
[]conf.AlwaysAvailableTrack{
{Codec: "H264"},
{Codec: "H265"},
},
&description.Session{
Medias: []*description.Media{
{
Type: description.MediaTypeVideo,
Formats: []format.Format{&format.H264{}},
},
},
},
"wants to publish [H264], but stream expects [H264 H265]",
},
{
"wrong mpeg-4 audio config",
[]conf.AlwaysAvailableTrack{
{Codec: "MPEG4Audio", SampleRate: 44100, ChannelCount: 2},
},
&description.Session{
Medias: []*description.Media{
{
Type: description.MediaTypeAudio,
Formats: []format.Format{&format.MPEG4Audio{
Config: &mpeg4audio.AudioSpecificConfig{
Type: 2,
SampleRate: 48000,
ChannelConfig: 1,
},
}},
},
},
},
"MPEG-4 audio configuration does not match, is type=2, sampleRate=48000, " +
"channelCount=1, but stream expects type=2, sampleRate=44100, channelCount=2",
},
{
"wrong g711 config",
[]conf.AlwaysAvailableTrack{
{Codec: "G711", MULaw: true, SampleRate: 8000, ChannelCount: 2},
},
&description.Session{
Medias: []*description.Media{
{
Type: description.MediaTypeAudio,
Formats: []format.Format{&format.G711{
MULaw: false,
SampleRate: 8000,
ChannelCount: 2,
}},
},
},
},
"G711 configuration does not match, is MULaw=false, sampleRate=8000, " +
"channelCount=2, but stream expects MULaw=true, sampleRate=8000, channelCount=2",
},
{
"wrong lpcm config",
[]conf.AlwaysAvailableTrack{
{Codec: "LPCM", SampleRate: 44100, ChannelCount: 2},
},
&description.Session{
Medias: []*description.Media{
{
Type: description.MediaTypeAudio,
Formats: []format.Format{&format.LPCM{
BitDepth: 16,
SampleRate: 48000,
ChannelCount: 2,
}},
},
},
},
"LPCM configuration does not match, is bitDepth=16, sampleRate=48000, " +
"channelCount=2, but stream expects bitDepth=16, sampleRate=44100, channelCount=2",
},
} {
t.Run(ca.name, func(t *testing.T) {
strm := &Stream{
AlwaysAvailable: true,
AlwaysAvailableTracks: ca.tracks,
WriteQueueSize: 512,
RTPMaxPayloadSize: 1450,
ReplaceNTP: true,
Parent: &nilLogger{},
}
err := strm.Initialize()
require.NoError(t, err)
defer strm.Close()
subStream := &SubStream{
Stream: strm,
CurDesc: ca.desc,
UseRTPPackets: false,
}
err = subStream.Initialize()
require.EqualError(t, err, ca.err)
})
}
}
func TestStreamAlwaysAvailable(t *testing.T) {
for _, ca := range []string{"default", "file"} {
t.Run(ca, func(t *testing.T) {
strm := &Stream{
AlwaysAvailable: true,
WriteQueueSize: 512,
RTPMaxPayloadSize: 1450,
ReplaceNTP: true,
Parent: &nilLogger{},
}
if ca == "default" {
strm.AlwaysAvailableTracks = []conf.AlwaysAvailableTrack{
{Codec: conf.CodecAV1},
{Codec: conf.CodecVP9},
{Codec: conf.CodecH265},
{Codec: conf.CodecH264},
{Codec: conf.CodecOpus},
{Codec: conf.CodecMPEG4Audio, SampleRate: 44100, ChannelCount: 2},
{Codec: conf.CodecLPCM, SampleRate: 48000, ChannelCount: 2},
}
} else {
tmpf, err := os.CreateTemp(os.TempDir(), "rtsp-")
require.NoError(t, err)
defer os.Remove(tmpf.Name())
pmp4 := &pmp4.Presentation{
Tracks: []*pmp4.Track{
{
ID: 1,
TimeScale: 90000,
Codec: &codecs.AV1{
SequenceHeader: []byte{8, 0, 0, 0, 66, 167, 191, 228, 96, 13, 0, 64},
},
Samples: []*pmp4.Sample{
{
Duration: 90000,
PayloadSize: 13,
GetPayload: func() ([]byte, error) {
return []byte{0xa, 0xb, 0x0, 0x0, 0x0, 0x42, 0xa7, 0xbf, 0xe4, 0x60, 0xd, 0x0, 0x40}, nil
},
},
},
},
{
ID: 2,
TimeScale: 90000,
Codec: &codecs.VP9{
Width: 1280,
Height: 720,
Profile: 1,
BitDepth: 8,
ChromaSubsampling: 1,
ColorRange: false,
},
Samples: []*pmp4.Sample{
{
Duration: 90000,
PayloadSize: 4,
GetPayload: func() ([]byte, error) {
return []byte{1, 2, 3, 4}, nil
},
},
},
},
{
ID: 3,
TimeScale: 90000,
Codec: &codecs.H265{
VPS: []byte{
0x40, 0x01, 0x0c, 0x01, 0xff, 0xff, 0x02, 0x20,
0x00, 0x00, 0x03, 0x00, 0xb0, 0x00, 0x00, 0x03,
0x00, 0x00, 0x03, 0x00, 0x7b, 0x18, 0xb0, 0x24,
},
SPS: []byte{
0x42, 0x01, 0x01, 0x02, 0x20, 0x00, 0x00, 0x03,
0x00, 0xb0, 0x00, 0x00, 0x03, 0x00, 0x00, 0x03,
0x00, 0x7b, 0xa0, 0x07, 0x82, 0x00, 0x88, 0x7d,
0xb6, 0x71, 0x8b, 0x92, 0x44, 0x80, 0x53, 0x88,
0x88, 0x92, 0xcf, 0x24, 0xa6, 0x92, 0x72, 0xc9,
0x12, 0x49, 0x22, 0xdc, 0x91, 0xaa, 0x48, 0xfc,
0xa2, 0x23, 0xff, 0x00, 0x01, 0x00, 0x01, 0x6a,
0x02, 0x02, 0x02, 0x01,
},
PPS: []byte{
0x44, 0x01, 0xc0, 0x25, 0x2f, 0x05, 0x32, 0x40,
},
},
Samples: []*pmp4.Sample{
{
Duration: 90000,
PayloadSize: 8,
GetPayload: func() ([]byte, error) {
return []byte{0x0, 0x0, 0x0, 0x4, 0x1, 0x2, 0x3, 0x4}, nil
},
},
},
},
{
ID: 4,
TimeScale: 90000,
Codec: &codecs.H264{
SPS: []byte{ // 1920x1080 baseline
0x67, 0x42, 0xc0, 0x28, 0xd9, 0x00, 0x78, 0x02,
0x27, 0xe5, 0x84, 0x00, 0x00, 0x03, 0x00, 0x04,
0x00, 0x00, 0x03, 0x00, 0xf0, 0x3c, 0x60, 0xc9, 0x20,
},
PPS: []byte{0x08, 0x06, 0x07, 0x08},
},
Samples: []*pmp4.Sample{
{
Duration: 90000,
PayloadSize: 8,
GetPayload: func() ([]byte, error) {
return []byte{0x0, 0x0, 0x0, 0x4, 0x1, 0x2, 0x3, 0x4}, nil
},
},
},
},
{
ID: 5,
TimeScale: 48000,
Codec: &codecs.Opus{
ChannelCount: 2,
},
Samples: []*pmp4.Sample{
{
Duration: 48000,
PayloadSize: 2,
GetPayload: func() ([]byte, error) {
return []byte{0x1, 0x2}, nil
},
},
},
},
{
ID: 6,
TimeScale: 44100,
Codec: &codecs.MPEG4Audio{
Config: mpeg4audio.AudioSpecificConfig{
Type: 2,
SampleRate: 44100,
ChannelConfig: 2,
ChannelCount: 2,
},
},
Samples: []*pmp4.Sample{
{
Duration: 44100,
PayloadSize: 4,
GetPayload: func() ([]byte, error) {
return []byte{0x12, 0x10, 0x0, 0x0}, nil
},
},
},
},
{
ID: 7,
TimeScale: 48000,
Codec: &codecs.LPCM{
BitDepth: 16,
SampleRate: 48000,
ChannelCount: 2,
},
Samples: []*pmp4.Sample{
{
Duration: 48000,
PayloadSize: 4,
GetPayload: func() ([]byte, error) {
return []byte{0x12, 0x10, 0x0, 0x0}, nil
},
},
},
},
},
}
err = pmp4.Marshal(tmpf)
require.NoError(t, err)
tmpf.Close()
strm.AlwaysAvailableFile = tmpf.Name()
}
err := strm.Initialize()
require.NoError(t, err)
defer strm.Close()
r := &Reader{
Parent: &nilLogger{},
}
var wg sync.WaitGroup
n := 0
var phase2 atomic.Bool
wg.Add(1)
var lastPTSAV1 int64
var soAV1a sync.Once
var soAV1b sync.Once
r.OnData(strm.Desc.Medias[n], strm.Desc.Medias[n].Formats[0], func(u *unit.Unit) error {
require.GreaterOrEqual(t, u.PTS, lastPTSAV1)
lastPTSAV1 = u.PTS
if !phase2.Load() {
soAV1a.Do(func() {
require.NotEmpty(t, u.Payload)
wg.Done()
})
} else {
soAV1b.Do(func() {
require.Equal(t, unit.PayloadAV1{{1, 2, 3, 4}}, u.Payload)
wg.Done()
})
}
return nil
})
n++
wg.Add(1)
var lastPTSVP9 int64
var soVP9a sync.Once
var soVP9b sync.Once
r.OnData(strm.Desc.Medias[n], strm.Desc.Medias[n].Formats[0], func(u *unit.Unit) error {
require.GreaterOrEqual(t, u.PTS, lastPTSVP9)
lastPTSVP9 = u.PTS
if !phase2.Load() {
soVP9a.Do(func() {
require.NotEmpty(t, u.Payload)
wg.Done()
})
} else {
soVP9b.Do(func() {
require.Equal(t, unit.PayloadVP9{1, 2, 3, 4}, u.Payload)
wg.Done()
})
}
return nil
})
n++
wg.Add(1)
var lastPTSH265 int64
var soH265a sync.Once
var soH265b sync.Once
r.OnData(strm.Desc.Medias[n], strm.Desc.Medias[n].Formats[0], func(u *unit.Unit) error {
require.GreaterOrEqual(t, u.PTS, lastPTSH265)
lastPTSH265 = u.PTS
if !phase2.Load() {
soH265a.Do(func() {
require.NotEmpty(t, u.Payload)
wg.Done()
})
} else {
soH265b.Do(func() {
require.Equal(t, unit.PayloadH265{{1, 2, 3, 4}}, u.Payload)
wg.Done()
})
}
return nil
})
n++
wg.Add(1)
var lastPTSH264 int64
var soH264a sync.Once
var soH264b sync.Once
r.OnData(strm.Desc.Medias[n], strm.Desc.Medias[n].Formats[0], func(u *unit.Unit) error {
require.GreaterOrEqual(t, u.PTS, lastPTSH264)
lastPTSH264 = u.PTS
if !phase2.Load() {
soH264a.Do(func() {
require.NotEmpty(t, u.Payload)
wg.Done()
})
} else {
soH264b.Do(func() {
require.Equal(t, unit.PayloadH264{{1, 2, 3, 4}}, u.Payload)
wg.Done()
})
}
return nil
})
n++
wg.Add(1)
var lastPTSOpus int64
var soOpusa sync.Once
var soOpusb sync.Once
r.OnData(strm.Desc.Medias[n], strm.Desc.Medias[n].Formats[0], func(u *unit.Unit) error {
require.GreaterOrEqual(t, u.PTS, lastPTSOpus)
lastPTSOpus = u.PTS
if !phase2.Load() {
soOpusa.Do(func() {
require.NotEmpty(t, u.Payload)
wg.Done()
})
} else {
soOpusb.Do(func() {
require.Equal(t, unit.PayloadOpus{{1, 2}}, u.Payload)
wg.Done()
})
}
return nil
})
n++
wg.Add(1)
var lastPTSMPEG4Audio int64
var soMPEG4Audioa sync.Once
var soMPEG4Audiob sync.Once
r.OnData(strm.Desc.Medias[n], strm.Desc.Medias[n].Formats[0], func(u *unit.Unit) error {
require.GreaterOrEqual(t, u.PTS, lastPTSMPEG4Audio)
lastPTSMPEG4Audio = u.PTS
if !phase2.Load() {
soMPEG4Audioa.Do(func() {
require.NotEmpty(t, u.Payload)
wg.Done()
})
} else {
soMPEG4Audiob.Do(func() {
require.Equal(t, unit.PayloadMPEG4Audio{{1, 2, 3, 4}}, u.Payload)
wg.Done()
})
}
return nil
})
n++
wg.Add(1)
var lastPTSLPCM int64
var soLPCMa sync.Once
var soLPCMb sync.Once
r.OnData(strm.Desc.Medias[n], strm.Desc.Medias[n].Formats[0], func(u *unit.Unit) error {
require.GreaterOrEqual(t, u.PTS, lastPTSLPCM)
lastPTSLPCM = u.PTS
if !phase2.Load() {
soLPCMa.Do(func() {
require.NotEmpty(t, u.Payload)
wg.Done()
})
} else {
soLPCMb.Do(func() {
require.Equal(t, unit.PayloadLPCM{1, 2, 3, 4}, u.Payload)
wg.Done()
})
}
return nil
})
strm.AddReader(r)
defer strm.RemoveReader(r)
wg.Wait()
subStream := &SubStream{
Stream: strm,
CurDesc: &description.Session{Medias: []*description.Media{
{
Type: description.MediaTypeVideo,
Formats: []format.Format{&format.AV1{}},
},
{
Type: description.MediaTypeVideo,
Formats: []format.Format{&format.VP9{}},
},
{
Type: description.MediaTypeVideo,
Formats: []format.Format{&format.H265{}},
},
{
Type: description.MediaTypeVideo,
Formats: []format.Format{&format.H264{}},
},
{
Type: description.MediaTypeAudio,
Formats: []format.Format{&format.Opus{}},
},
{
Type: description.MediaTypeAudio,
Formats: []format.Format{&format.MPEG4Audio{
Config: &mpeg4audio.AudioSpecificConfig{
Type: 2,
SampleRate: 44100,
ChannelConfig: 2,
ChannelCount: 2,
},
}},
},
{
Type: description.MediaTypeAudio,
Formats: []format.Format{&format.LPCM{
BitDepth: 16,
SampleRate: 48000,
ChannelCount: 2,
}},
},
}},
UseRTPPackets: false,
}
err = subStream.Initialize()
require.NoError(t, err)
wg.Add(7)
phase2.Store(true)
subStream.WriteUnit(subStream.CurDesc.Medias[0], subStream.CurDesc.Medias[0].Formats[0], &unit.Unit{
PTS: 0,
Payload: unit.PayloadAV1{{1, 2, 3, 4}},
})
subStream.WriteUnit(subStream.CurDesc.Medias[1], subStream.CurDesc.Medias[1].Formats[0], &unit.Unit{
PTS: 0,
Payload: unit.PayloadVP9{1, 2, 3, 4},
})
subStream.WriteUnit(subStream.CurDesc.Medias[2], subStream.CurDesc.Medias[2].Formats[0], &unit.Unit{
PTS: 0,
Payload: unit.PayloadH265{{1, 2, 3, 4}},
})
subStream.WriteUnit(subStream.CurDesc.Medias[3], subStream.CurDesc.Medias[3].Formats[0], &unit.Unit{
PTS: 0,
Payload: unit.PayloadH264{{1, 2, 3, 4}},
})
subStream.WriteUnit(subStream.CurDesc.Medias[4], subStream.CurDesc.Medias[4].Formats[0], &unit.Unit{
PTS: 0,
Payload: unit.PayloadOpus{{1, 2}},
})
subStream.WriteUnit(subStream.CurDesc.Medias[5], subStream.CurDesc.Medias[5].Formats[0], &unit.Unit{
PTS: 0,
Payload: unit.PayloadMPEG4Audio{{1, 2, 3, 4}},
})
subStream.WriteUnit(subStream.CurDesc.Medias[6], subStream.CurDesc.Medias[6].Formats[0], &unit.Unit{
PTS: 0,
Payload: unit.PayloadLPCM{1, 2, 3, 4},
})
wg.Wait()
})
}
}
================================================
FILE: internal/stream/stream_format.go
================================================
package stream
import (
"crypto/rand"
"time"
"github.com/bluenviron/gortsplib/v5/pkg/description"
"github.com/bluenviron/gortsplib/v5/pkg/format"
"github.com/pion/rtp"
"github.com/bluenviron/mediamtx/internal/errordumper"
"github.com/bluenviron/mediamtx/internal/logger"
"github.com/bluenviron/mediamtx/internal/ntpestimator"
"github.com/bluenviron/mediamtx/internal/unit"
)
func multiplyAndDivide(v, m, d int64) int64 {
secs := v / d
dec := v % d
return (secs*m + dec*m/d)
}
func unitSize(u *unit.Unit) uint64 {
n := uint64(0)
for _, pkt := range u.RTPPackets {
n += uint64(pkt.MarshalSize())
}
return n
}
func randUint32() (uint32, error) {
var b [4]byte
_, err := rand.Read(b[:])
if err != nil {
return 0, err
}
return uint32(b[0])<<24 | uint32(b[1])<<16 | uint32(b[2])<<8 | uint32(b[3]), nil
}
type streamFormat struct {
format format.Format
media *description.Media
alwaysAvailable bool
rtpMaxPayloadSize int
replaceNTP bool
inboundFramesInError *errordumper.Dumper
addInboundBytes func(uint64)
addOutboundBytes func(uint64)
updateLastTime func(time.Duration)
writeRTSP func(*description.Media, []*rtp.Packet, time.Time)
parent logger.Writer
ptsOffset int64
formatUpdater formatUpdater
unitRemuxer unitRemuxer
rtpEncoder rtpEncoder
rtpTimeOffset uint32
ntpEstimator *ntpestimator.Estimator
onDatas map[*Reader]OnDataFunc
}
func (sf *streamFormat) initialize() error {
sf.formatUpdater = newFormatUpdater(sf.format)
sf.unitRemuxer = newUnitRemuxer(sf.format)
if sf.replaceNTP {
sf.ntpEstimator = &ntpestimator.Estimator{
ClockRate: sf.format.ClockRate(),
}
}
sf.onDatas = make(map[*Reader]OnDataFunc)
return nil
}
================================================
FILE: internal/stream/stream_media.go
================================================
package stream
import (
"time"
"github.com/bluenviron/gortsplib/v5/pkg/description"
"github.com/bluenviron/gortsplib/v5/pkg/format"
"github.com/bluenviron/mediamtx/internal/errordumper"
"github.com/bluenviron/mediamtx/internal/logger"
"github.com/pion/rtp"
)
type streamMedia struct {
media *description.Media
alwaysAvailable bool
rtpMaxPayloadSize int
replaceNTP bool
addInboundBytes func(uint64)
addOutboundBytes func(uint64)
updateLastTime func(time.Duration)
writeRTSP func(*description.Media, []*rtp.Packet, time.Time)
inboundFramesInError *errordumper.Dumper
parent logger.Writer
formats map[format.Format]*streamFormat
}
func (sm *streamMedia) initialize() error {
sm.formats = make(map[format.Format]*streamFormat)
for _, forma := range sm.media.Formats {
sf := &streamFormat{
format: forma,
media: sm.media,
alwaysAvailable: sm.alwaysAvailable,
rtpMaxPayloadSize: sm.rtpMaxPayloadSize,
replaceNTP: sm.replaceNTP,
inboundFramesInError: sm.inboundFramesInError,
addInboundBytes: sm.addInboundBytes,
addOutboundBytes: sm.addOutboundBytes,
updateLastTime: sm.updateLastTime,
writeRTSP: sm.writeRTSP,
parent: sm.parent,
}
err := sf.initialize()
if err != nil {
return err
}
sm.formats[forma] = sf
}
return nil
}
================================================
FILE: internal/stream/stream_standard_test.go
================================================
package stream
import (
"testing"
"github.com/bluenviron/gortsplib/v5/pkg/description"
"github.com/bluenviron/gortsplib/v5/pkg/format"
"github.com/bluenviron/mediamtx/internal/logger"
"github.com/bluenviron/mediamtx/internal/unit"
"github.com/pion/rtp"
"github.com/stretchr/testify/require"
)
type nilLogger struct{}
func (nilLogger) Log(logger.Level, string, ...any) {
}
func TestStream(t *testing.T) {
desc := &description.Session{Medias: []*description.Media{
{
Type: description.MediaTypeVideo,
Formats: []format.Format{&format.H264{}},
},
{
Type: description.MediaTypeVideo,
Formats: []format.Format{&format.VP8{}},
},
}}
strm := &Stream{
Desc: desc,
WriteQueueSize: 512,
RTPMaxPayloadSize: 1450,
}
err := strm.Initialize()
require.NoError(t, err)
defer strm.Close()
subStream := &SubStream{
Stream: strm,
UseRTPPackets: false,
}
err = subStream.Initialize()
require.NoError(t, err)
r := &Reader{}
recv := make(chan struct{})
r.OnData(desc.Medias[0], desc.Medias[0].Formats[0], func(_ *unit.Unit) error {
close(recv)
return nil
})
strm.AddReader(r)
defer strm.RemoveReader(r)
subStream.WriteUnit(desc.Medias[0], desc.Medias[0].Formats[0], &unit.Unit{
PTS: 30000 * 2,
Payload: unit.PayloadH264{
{5, 2}, // IDR
},
})
<-recv
require.Equal(t, uint64(14), strm.InboundBytes())
require.Equal(t, uint64(14), strm.OutboundBytes())
}
func TestStreamSkipBytesSent(t *testing.T) {
desc := &description.Session{Medias: []*description.Media{
{
Type: description.MediaTypeVideo,
Formats: []format.Format{&format.H264{}},
},
{
Type: description.MediaTypeVideo,
Formats: []format.Format{&format.VP8{}},
},
}}
strm := &Stream{
Desc: desc,
WriteQueueSize: 512,
RTPMaxPayloadSize: 1450,
}
err := strm.Initialize()
require.NoError(t, err)
defer strm.Close()
subStream := &SubStream{
Stream: strm,
UseRTPPackets: false,
}
err = subStream.Initialize()
require.NoError(t, err)
r := &Reader{
SkipBytesSent: true,
}
recv := make(chan struct{})
r.OnData(desc.Medias[0], desc.Medias[0].Formats[0], func(_ *unit.Unit) error {
close(recv)
return nil
})
strm.AddReader(r)
defer strm.RemoveReader(r)
subStream.WriteUnit(desc.Medias[0], desc.Medias[0].Formats[0], &unit.Unit{
PTS: 30000 * 2,
Payload: unit.PayloadH264{
{5, 2}, // IDR
},
})
<-recv
require.Equal(t, uint64(14), strm.InboundBytes())
require.Equal(t, uint64(0), strm.OutboundBytes())
}
func TestStreamResizeOversizedRTPPackets(t *testing.T) {
desc := &description.Session{Medias: []*description.Media{
{
Type: description.MediaTypeVideo,
Formats: []format.Format{&format.H264{
SPS: []byte{ // 1920x1080 baseline
0x67, 0x42, 0xc0, 0x28, 0xd9, 0x00, 0x78, 0x02,
0x27, 0xe5, 0x84, 0x00, 0x00, 0x03, 0x00, 0x04,
0x00, 0x00, 0x03, 0x00, 0xf0, 0x3c, 0x60, 0xc9, 0x20,
},
PPS: []byte{0x08, 0x06, 0x07, 0x08},
}},
},
}}
strm := &Stream{
Desc: desc,
WriteQueueSize: 512,
RTPMaxPayloadSize: 400,
Parent: &nilLogger{},
}
err := strm.Initialize()
require.NoError(t, err)
defer strm.Close()
subStream := &SubStream{
Stream: strm,
UseRTPPackets: true,
}
err = subStream.Initialize()
require.NoError(t, err)
r := &Reader{}
recv := make(chan *unit.Unit)
n := 0
r.OnData(desc.Medias[0], desc.Medias[0].Formats[0], func(u *unit.Unit) error {
switch n {
case 0:
case 1:
recv <- u
default:
t.Error("should not happen")
}
n++
return nil
})
strm.AddReader(r)
defer strm.RemoveReader(r)
subStream.WriteUnit(desc.Medias[0], desc.Medias[0].Formats[0], &unit.Unit{
PTS: 90000,
RTPPackets: []*rtp.Packet{
{
Header: rtp.Header{
Version: 2,
Marker: true,
PayloadType: 96,
SequenceNumber: 122,
Timestamp: 45343,
SSRC: 563423,
},
Payload: []byte{1, 2, 3, 4},
},
},
})
oversizedPayload := make([]byte, 1000)
for i := range oversizedPayload {
oversizedPayload[i] = byte(i % 256)
}
subStream.WriteUnit(desc.Medias[0], desc.Medias[0].Formats[0], &unit.Unit{
PTS: 90000,
RTPPackets: []*rtp.Packet{
{
Header: rtp.Header{
Version: 2,
Marker: true,
PayloadType: 96,
SequenceNumber: 123,
Timestamp: 45343,
SSRC: 563423,
},
Payload: oversizedPayload,
},
},
})
received := <-recv
require.Equal(t, 3, len(received.RTPPackets))
for i, pkt := range received.RTPPackets {
require.Equal(t, 123+uint16(i), pkt.SequenceNumber)
require.Equal(t, uint32(45343), pkt.Timestamp)
}
totalPayloadSize := 0
for _, pkt := range received.RTPPackets {
require.LessOrEqual(t, len(pkt.Payload), 400)
totalPayloadSize += len(pkt.Payload)
}
require.Equal(t, 1005, totalPayloadSize)
}
func TestStreamUpdateFormatParams(t *testing.T) {
for _, ca := range []string{"h264", "h265", "mpeg4video"} {
t.Run(ca, func(t *testing.T) {
var desc *description.Session
var media *description.Media
var forma format.Format
var u *unit.Unit
switch ca {
case "h264":
sps := []byte{
0x67, 0x64, 0x00, 0x20, 0xac, 0xd9, 0x40, 0x78,
0x02, 0x27, 0xe5, 0x9a, 0x80, 0x80, 0x80, 0xa0,
}
pps := []byte{0x08, 0x07, 0x08, 0x09}
formatH264 := &format.H264{
SPS: []byte{0x67, 0x42, 0xc0, 0x28},
PPS: []byte{0x08, 0x06},
}
desc = &description.Session{Medias: []*description.Media{{
Type: description.MediaTypeVideo,
Formats: []format.Format{formatH264},
}}}
media = desc.Medias[0]
forma = formatH264
u = &unit.Unit{
PTS: 90000,
Payload: unit.PayloadH264{
sps, // New SPS
pps, // New PPS
{5, 1}, // IDR
},
}
case "h265":
vps := []byte{0x40, 0x01, 0x0c, 0x01, 0xff, 0xfe}
sps := []byte{0x42, 0x01, 0x01, 0x01, 0x60, 0x00, 0x00, 0x04}
pps := []byte{0x44, 0x01, 0xc1, 0x73, 0xd1, 0x8a}
formatH265 := &format.H265{
VPS: []byte{0x40, 0x01, 0x0c},
SPS: []byte{0x42, 0x01, 0x01},
PPS: []byte{0x44, 0x01, 0xc1},
}
desc = &description.Session{Medias: []*description.Media{{
Type: description.MediaTypeVideo,
Formats: []format.Format{formatH265},
}}}
media = desc.Medias[0]
forma = formatH265
u = &unit.Unit{
PTS: 90000,
Payload: unit.PayloadH265{
vps, // New VPS
sps, // New SPS
pps, // New PPS
{0x26, 0x01, 0x01, 0x02}, // IDR
},
}
case "mpeg4video":
config := []byte{
0x00, 0x00, 0x01, 0xb0, // Visual Object Sequence Start
0x02, 0x00, 0x00, 0x01, 0xb5, 0x8a,
0x14, 0x00, 0x00, 0x01, 0x00,
}
formatMPEG4Video := &format.MPEG4Video{
Config: []byte{0x00, 0x00, 0x01, 0xb0, 0x01},
}
desc = &description.Session{Medias: []*description.Media{{
Type: description.MediaTypeVideo,
Formats: []format.Format{formatMPEG4Video},
}}}
media = desc.Medias[0]
forma = formatMPEG4Video
frame := make([]byte, 0, len(config)+20)
frame = append(frame, config...)
frame = append(frame, []byte{0x00, 0x00, 0x01, 0xb3}...) // Group of VOP
frame = append(frame, []byte{0x01, 0x02, 0x03, 0x04}...)
u = &unit.Unit{
PTS: 90000,
Payload: unit.PayloadMPEG4Video(frame),
}
}
strm := &Stream{
Desc: desc,
WriteQueueSize: 512,
RTPMaxPayloadSize: 1450,
}
err := strm.Initialize()
require.NoError(t, err)
defer strm.Close()
subStream := &SubStream{
Stream: strm,
UseRTPPackets: false,
}
err = subStream.Initialize()
require.NoError(t, err)
r := &Reader{}
recv := make(chan struct{})
r.OnData(media, forma, func(_ *unit.Unit) error {
close(recv)
return nil
})
strm.AddReader(r)
defer strm.RemoveReader(r)
subStream.WriteUnit(media, forma, u)
<-recv
// Verify that format parameters were updated
switch ca {
case "h264":
formatH264 := forma.(*format.H264)
require.Equal(t, []byte{
0x67, 0x64, 0x00, 0x20, 0xac, 0xd9, 0x40, 0x78,
0x02, 0x27, 0xe5, 0x9a, 0x80, 0x80, 0x80, 0xa0,
}, formatH264.SPS)
require.Equal(t, []byte{0x08, 0x07, 0x08, 0x09}, formatH264.PPS)
case "h265":
formatH265 := forma.(*format.H265)
require.Equal(t, []byte{0x40, 0x01, 0x0c, 0x01, 0xff, 0xfe}, formatH265.VPS)
require.Equal(t, []byte{0x42, 0x01, 0x01, 0x01, 0x60, 0x00, 0x00, 0x04}, formatH265.SPS)
require.Equal(t, []byte{0x44, 0x01, 0xc1, 0x73, 0xd1, 0x8a}, formatH265.PPS)
case "mpeg4video":
formatMPEG4Video := forma.(*format.MPEG4Video)
require.Equal(t, []byte{
0x00, 0x00, 0x01, 0xb0,
0x02, 0x00, 0x00, 0x01, 0xb5, 0x8a,
0x14, 0x00, 0x00, 0x01, 0x00,
}, formatMPEG4Video.Config)
}
})
}
}
var casesDecodeEncode = []struct {
name string
format format.Format
encoded []*rtp.Packet
decoded unit.Payload
}{
{
name: "av1",
format: &format.AV1{
PayloadTyp: 96,
},
encoded: []*rtp.Packet{
{
Header: rtp.Header{
Version: 2,
Marker: true,
PayloadType: 96,
SequenceNumber: 123,
Timestamp: 45343,
SSRC: 563423,
},
Payload: []byte{
0x10,
0x02, // Size = 2
0x01, 0x02, // OBU data
},
},
},
decoded: unit.PayloadAV1{
{0x02, 0x01, 0x02}, // Size byte included with OBU data
},
},
{
name: "vp9",
format: &format.VP9{
PayloadTyp: 96,
},
encoded: []*rtp.Packet{
{
Header: rtp.Header{
Version: 2,
Marker: true,
PayloadType: 96,
SequenceNumber: 123,
Timestamp: 45343,
SSRC: 563423,
},
Payload: []byte{
0x8f, 0xb5, 0xaf, 0x18, 0x07, 0x80, 0x03, 0x24,
0x01, 0x14, 0x01, 0x82, 0x49, 0x83, 0x42, 0x00,
0x77, 0xf0, 0x32, 0x34,
},
},
},
decoded: unit.PayloadVP9{0x82, 0x49, 0x83, 0x42, 0x0, 0x77, 0xf0, 0x32, 0x34},
},
{
name: "vp8",
format: &format.VP8{
PayloadTyp: 96,
},
encoded: []*rtp.Packet{
{
Header: rtp.Header{
Version: 2,
Marker: true,
PayloadType: 96,
SequenceNumber: 123,
Timestamp: 45343,
SSRC: 563423,
},
Payload: []byte{
0x10, // X=0, R=0, N=0, S=1, PartID=0
0x01, 0x02, 0x03, 0x04,
},
},
},
decoded: unit.PayloadVP8{0x01, 0x02, 0x03, 0x04},
},
{
name: "h265",
format: &format.H265{
PayloadTyp: 96,
VPS: []byte{0x40, 0x01, 0x0c, 0x01, 0xff, 0xfe},
SPS: []byte{0x42, 0x01, 0x01, 0x01, 0x60, 0x00, 0x00, 0x04},
PPS: []byte{0x44, 0x01, 0xc1, 0x73, 0xd1, 0x8a},
},
encoded: []*rtp.Packet{
{
Header: rtp.Header{
Version: 2,
Marker: true,
PayloadType: 96,
SequenceNumber: 123,
Timestamp: 45343,
SSRC: 563423,
},
Payload: []byte{
0x60, 0x01, 0x00, 0x06, 0x40, 0x01, 0x0c, 0x01,
0xff, 0xfe, 0x00, 0x08, 0x42, 0x01, 0x01, 0x01,
0x60, 0x00, 0x00, 0x04, 0x00, 0x06, 0x44, 0x01,
0xc1, 0x73, 0xd1, 0x8a, 0x00, 0x05, 0x26, 0x01,
0x01, 0x02, 0x03,
},
},
},
decoded: unit.PayloadH265{
{0x40, 0x01, 0x0c, 0x01, 0xff, 0xfe}, // VPS
{0x42, 0x01, 0x01, 0x01, 0x60, 0x00, 0x00, 0x04}, // SPS
{0x44, 0x01, 0xc1, 0x73, 0xd1, 0x8a}, // PPS
{0x26, 0x01, 0x01, 0x02, 0x03}, // IDR
},
},
{
name: "h264",
format: &format.H264{
PayloadTyp: 96,
SPS: []byte{
0x67, 0x42, 0xc0, 0x28, 0xd9, 0x00, 0x78, 0x02,
0x27, 0xe5, 0x84, 0x00, 0x00, 0x03, 0x00, 0x04,
0x00, 0x00, 0x03, 0x00, 0xf0, 0x3c, 0x60, 0xc9, 0x20,
},
PPS: []byte{0x08, 0x06, 0x07, 0x08},
},
encoded: []*rtp.Packet{
{
Header: rtp.Header{
Version: 2,
Marker: true,
PayloadType: 96,
SequenceNumber: 123,
Timestamp: 45343,
SSRC: 563423,
},
Payload: []byte{
0x18, 0x00, 0x19, 0x67, 0x42, 0xc0, 0x28, 0xd9,
0x00, 0x78, 0x02, 0x27, 0xe5, 0x84, 0x00, 0x00,
0x03, 0x00, 0x04, 0x00, 0x00, 0x03, 0x00, 0xf0,
0x3c, 0x60, 0xc9, 0x20, 0x00, 0x04, 0x08, 0x06,
0x07, 0x08, 0x00, 0x05, 0x05, 0x01, 0x02, 0x03,
0x04,
},
},
},
decoded: unit.PayloadH264{
{
0x67, 0x42, 0xc0, 0x28, 0xd9, 0x00, 0x78, 0x02, 0x27, 0xe5, 0x84,
0x00, 0x00, 0x03, 0x00, 0x04, 0x00, 0x00, 0x03, 0x00, 0xf0, 0x3c, 0x60, 0xc9, 0x20,
}, // SPS
{0x08, 0x06, 0x07, 0x08}, // PPS
{0x05, 0x01, 0x02, 0x03, 0x04}, // IDR
},
},
{
name: "mpeg4video",
format: &format.MPEG4Video{
PayloadTyp: 96,
Config: []byte{0x00, 0x00, 0x01, 0xb0, 0x01},
},
encoded: []*rtp.Packet{
{
Header: rtp.Header{
Version: 2,
Marker: true,
PayloadType: 96,
SequenceNumber: 123,
Timestamp: 45343,
SSRC: 563423,
},
Payload: []byte{0x00, 0x01, 0x02, 0x03, 0x04},
},
},
decoded: unit.PayloadMPEG4Video{0x00, 0x01, 0x02, 0x03, 0x04},
},
{
name: "mpeg1video",
format: &format.MPEG1Video{},
encoded: []*rtp.Packet{
{
Header: rtp.Header{
Version: 2,
Marker: true, // Marker indicates complete frame
PayloadType: 32,
SequenceNumber: 123,
Timestamp: 45343,
SSRC: 563423,
},
Payload: []byte{
// MPEG-1 Video RTP header (4 bytes)
0x00, // MBZ=0, T=0 (MPEG-1)
0x00, // TR (temporal reference) - low 8 bits
0x18, // AN=0, N=0, S=0 (no sequence header), B=1, E=1 (complete slice), FBV=0, BFC=0, FFV=0, FFC=0
0x00, // FFC (continued)
// MPEG-1 Video data (slice or frame data)
0x00, 0x00, 0x01, 0x01, // Slice start code
0x01, 0x02, 0x03, 0x04, // Slice data
},
},
},
decoded: unit.PayloadMPEG1Video{
// Only the video data after the 4-byte RTP header
0x00, 0x00, 0x01, 0x01,
0x01, 0x02, 0x03, 0x04,
},
},
{
name: "mjpeg",
format: &format.MJPEG{},
encoded: []*rtp.Packet{
{
Header: rtp.Header{
Version: 2,
PayloadType: 26,
},
Payload: []byte{
0x00, 0x00, 0x00, 0x00, 0x01, 0xff, 0xf0, 0x87,
0x00, 0x00, 0x00, 0x80, 0x0d, 0x09, 0x0a, 0x0b,
0x0a, 0x08, 0x0d, 0x0b, 0x0a, 0x0b, 0x0e, 0x0e,
0x0d, 0x0f, 0x13, 0x20, 0x15, 0x13, 0x12, 0x12,
0x13, 0x27, 0x1c, 0x1e, 0x17, 0x20, 0x2e, 0x29,
0x31, 0x30, 0x2e, 0x29, 0x2d, 0x2c, 0x33, 0x3a,
0x4a, 0x3e, 0x33, 0x36, 0x46, 0x37, 0x2c, 0x2d,
0x40, 0x57, 0x41, 0x46, 0x4c, 0x4e, 0x52, 0x53,
0x52, 0x32, 0x3e, 0x5a, 0x61, 0x5a, 0x50, 0x60,
0x4a, 0x51, 0x52, 0x4f, 0x0e, 0x0e, 0x0e, 0x13,
0x11, 0x13, 0x26, 0x15, 0x15, 0x26, 0x4f, 0x35,
0x2d, 0x35, 0x4f, 0x4f, 0x4f, 0x4f, 0x4f, 0x4f,
0x4f, 0x4f, 0x4f, 0x4f, 0x4f, 0x4f, 0x4f, 0x4f,
0x4f, 0x4f, 0x4f, 0x4f, 0x4f, 0x4f, 0x4f, 0x4f,
0x4f, 0x4f, 0x4f, 0x4f, 0x4f, 0x4f, 0x4f, 0x4f,
0x4f, 0x4f, 0x4f, 0x4f, 0x4f, 0x4f, 0x4f, 0x4f,
0x4f, 0x4f, 0x4f, 0x4f, 0x4f, 0x4f, 0x4f, 0x4f,
0x4f, 0x4f, 0x4f, 0x4f, 0x92, 0x8a, 0x28, 0xaf,
0x54, 0xf2, 0x42, 0x8a, 0x28, 0xa0, 0x02, 0x96,
0x92, 0x96, 0x80, 0x0a, 0x4a, 0x75, 0x25, 0x02,
0x12, 0x8a, 0x5a, 0x28, 0x18, 0x94, 0x52, 0xd1,
0x40, 0x09, 0x45, 0x2d, 0x14, 0x08, 0x29, 0x69,
0x29, 0x68, 0x00, 0xa5, 0xa4, 0xa5, 0xa0, 0x02,
0x8a, 0x28, 0xa0, 0x02, 0x8a, 0x28, 0xa0, 0x04,
0xa5, 0xa2, 0x8a, 0x00, 0x5a, 0x28, 0xa2, 0x80,
0x0a, 0x28, 0xa2, 0x80, 0x0a, 0x28, 0xa2, 0x80,
0x12, 0x8a, 0x5a, 0x28, 0x24, 0x29, 0x69, 0x29,
0x68, 0x00, 0xa2, 0x8a, 0x28, 0x00, 0xa2, 0x8a,
0x28, 0x00, 0xa2, 0x8a, 0x28, 0x00, 0xa2, 0x8a,
0x28, 0x00, 0xa2, 0x8a, 0x28, 0x00, 0xa2, 0x8a,
0x28, 0x00, 0xa2, 0x8a, 0x28, 0x00, 0xa2, 0x8a,
0x28, 0x00, 0xa2, 0x8a, 0x28, 0x00, 0xa2, 0x8a,
0x28, 0x00, 0xa2, 0x8a, 0x28, 0x00, 0xa4, 0xa5,
0xa4, 0xa0, 0x02, 0x8a, 0x28, 0xa0, 0x02, 0x8a,
0x28, 0xa0, 0x02, 0x8a, 0x28, 0xa0, 0x02, 0x8a,
0x28, 0xa0, 0x02, 0x8a, 0x28, 0xa0, 0x02, 0x8a,
0x28, 0xa0, 0x02, 0x8a, 0x28, 0xa0, 0x02, 0x8a,
0x28, 0xa0, 0x02, 0x96, 0x92, 0x96, 0x80, 0x0a,
0x28, 0xa2, 0x80, 0x0a, 0x28, 0xa2, 0x80, 0x0a,
0x28, 0xa2, 0x80, 0x0a, 0x28, 0xa2, 0x80, 0x0a,
0x28, 0xa2, 0x80, 0x0a, 0x28, 0xa2, 0x80, 0x0a,
0x28, 0xa2, 0x80, 0x0a, 0x28, 0xa2, 0x80, 0x0a,
0x28, 0xa2, 0x81, 0x85, 0x14, 0x51, 0x40, 0x05,
0x14, 0x51, 0x40, 0x05, 0x14, 0x51, 0x40, 0x05,
0x14, 0x52, 0xd0, 0x01, 0x45, 0x14, 0x50, 0x01,
0x45, 0x14, 0x50, 0x01, 0x45, 0x14, 0x50, 0x01,
0x45, 0x2d, 0x14, 0x00, 0x94, 0xb4, 0x51, 0x40,
0x05, 0x14, 0x52, 0xd0, 0x02, 0x51, 0x4b, 0x45,
0x00, 0x25, 0x2d, 0x14, 0x50, 0x01, 0x45, 0x14,
0x50, 0x01, 0x45, 0x14, 0x50, 0x20, 0xa5, 0xa4,
0xa5, 0xa0, 0x02, 0x8a, 0x28, 0xa0, 0x02, 0x8a,
0x28, 0xa0, 0x02, 0x8a, 0x5a, 0x28, 0x18, 0x94,
0xb4, 0x51, 0x40, 0xc2, 0x8a, 0x28, 0xa0, 0x05,
0xa2, 0x92, 0x9d, 0x40, 0x05, 0x14, 0x51, 0x48,
0x02, 0x8a, 0x28, 0xa4, 0x01, 0x4b, 0x49, 0x4b,
0x40, 0x05, 0x14, 0x51, 0x40, 0x05, 0x14, 0xb4,
0x50, 0x02, 0x51, 0x4b, 0x45, 0x00, 0x25, 0x2d,
0x14, 0x50, 0x03, 0xa8, 0xa2, 0x8a, 0x00, 0x28,
0xa2, 0x8a, 0x00, 0x5a, 0x29, 0x29, 0x68, 0x00,
0xa2, 0x8a, 0x28, 0x00, 0xa2, 0x96, 0x8a, 0x06,
0x25, 0x14, 0xb4, 0x50, 0x01, 0x45, 0x14, 0x50,
0x02, 0xd2, 0xd2, 0x52, 0xd0, 0x20, 0xa2, 0x8a,
0x28, 0x01, 0x68, 0xa2, 0x8a, 0x40, 0x14, 0x51,
0x45, 0x30, 0x0a, 0x5a, 0x4a, 0x5a, 0x06, 0x14,
0x51, 0x45, 0x02, 0x0a, 0x28, 0xa5, 0xa0, 0x62,
0x51, 0x4b, 0x45, 0x00, 0x2d, 0x14, 0x51, 0x48,
0x02, 0x8a, 0x28, 0xa0, 0x61, 0x45, 0x14, 0x50,
0x03, 0xa8, 0xa2, 0x8a, 0x06, 0x2d, 0x14, 0x51,
0x48, 0x02, 0x8a, 0x28, 0xa4, 0x30, 0xa2, 0x8a,
0x2a, 0x80, 0x28, 0xa2, 0x8a, 0x00, 0x28, 0xa2,
0x8a, 0x92, 0x45, 0xa5, 0xa2, 0x96, 0x82, 0x82,
0x8a, 0x28, 0xa0, 0x02, 0x8a, 0x28, 0xa0, 0x05,
0xa2, 0x8a, 0x29, 0x80, 0x52, 0xd2, 0x52, 0xd0,
0x01, 0x45, 0x14, 0x50, 0x01, 0x4e, 0xa2, 0x8a,
0x43, 0x0a, 0x28, 0xa2, 0x80, 0x0a, 0x28, 0xa4,
0xa4, 0x31, 0x68, 0xa4, 0xf3, 0x62, 0xff, 0x00,
0x9e, 0xd1, 0x7e, 0xea, 0x9f, 0xfe, 0xb6, 0xa4,
0x62, 0x52, 0x53, 0xa9, 0x28, 0x01, 0x28, 0xa2,
0x6f, 0xdd, 0x7f, 0xaf, 0xa5, 0xa0, 0x62, 0x51,
0x4b, 0x45, 0x00, 0x25, 0x14, 0xbf, 0xba, 0xff,
0x00, 0xae, 0xb4, 0xea, 0x60, 0x36, 0x9d, 0x49,
0x49, 0x34, 0xb1, 0x45, 0xfe, 0xbe, 0x6f, 0x2a,
0x98, 0x0f, 0xa2, 0xb9, 0xbd, 0x0f, 0x59, 0x97,
0x54, 0xf1, 0x2d, 0xd7, 0xfc, 0xf9, 0xd7, 0x49,
0x52, 0x30, 0xac, 0x7d, 0x5b, 0x54, 0xd5, 0x74,
0xbf, 0xdf, 0x41, 0x67, 0x15, 0xd4, 0x35, 0x63,
0x56, 0xd5, 0x22, 0xd2, 0xe0, 0xf3, 0xbc, 0x99,
0x65, 0xae, 0x4b, 0x51, 0xf1, 0x44, 0x52, 0xff,
0x00, 0xc7, 0x97, 0x9b, 0xe4, 0xd0, 0x69, 0x4c,
0x76, 0xa3, 0xe2, 0xd9, 0xa5, 0x82, 0x29, 0xb4,
0xbf, 0xdd, 0x79, 0xbf, 0xeb, 0x22, 0xaa, 0x7e,
0x1e, 0xd5, 0x3e, 0xc1, 0x3f, 0xfa, 0x9f, 0xfa,
0xe9, 0x25, 0x61, 0xd6, 0x9e, 0x87, 0xf6, 0xbf,
0xed, 0x68, 0xbc, 0x8a, 0x82, 0xcf, 0x4e, 0x86,
0x5f, 0x36, 0x0a, 0x92, 0x9b, 0xff, 0x00, 0x5d,
0xeb, 0x3a, 0x6d, 0x53, 0xfd, 0x3f, 0xec, 0x76,
0x3f, 0xbd, 0xff, 0x00, 0xa6, 0xbf, 0xc1, 0x54,
0x66, 0x69, 0x51, 0x50, 0x4b, 0x2c, 0x51, 0x7e,
0xe7, 0xce, 0xf3, 0x66, 0xff, 0x00, 0xa6, 0x75,
0x35, 0x00, 0x2d, 0x65, 0x6a, 0xde, 0x23, 0xd3,
0xec, 0x3f, 0xe5, 0xb7, 0x9b, 0x34, 0x5f, 0xf2,
0xce, 0xb4, 0x7e, 0xd5, 0x69, 0x2f, 0xfc, 0xbe,
0x45, 0x5e, 0x7b, 0xe2, 0x7d, 0x07, 0xec, 0x1e,
0x6e, 0xa5, 0xf6, 0xc8, 0xa5, 0xf3, 0x6a, 0xc0,
0xdf, 0xa2, 0x9d, 0x45, 0x6c, 0x72, 0x0d, 0xa5,
0xa5, 0xa2, 0x80, 0x12, 0x96, 0x8a, 0x28, 0x10,
0x51, 0x4b, 0x45, 0x00, 0x25, 0x14, 0xb4, 0x50,
0x02, 0x51, 0x4b, 0x45, 0x03, 0x12, 0x8a, 0x5a,
0x28, 0x10, 0x94, 0xb4, 0x51, 0x40, 0x05, 0x14,
0x51, 0x40, 0x05, 0x14, 0xb4, 0x50, 0x02, 0x51,
0x4b, 0x45, 0x00, 0x14, 0x51, 0x4b, 0x40, 0x84,
0xa2, 0x8a, 0x28, 0x00, 0xa2, 0x96, 0x8a, 0x00,
0x4a, 0x29, 0x68, 0xa0, 0x04, 0xa2, 0x96, 0x8a,
0x00, 0x4a, 0x29, 0x68, 0xa0, 0x41, 0x45, 0x14,
0x50, 0x01, 0x45, 0x14, 0x50, 0x01, 0x45, 0x14,
0x50, 0x01, 0x45, 0x14, 0x50, 0x01, 0x45, 0x14,
0x50, 0x01, 0x45, 0x14, 0x50, 0x01, 0x45, 0x14,
0x50, 0x01, 0x45, 0x14, 0x50, 0x01, 0x45, 0x14,
0x50, 0x01, 0x45, 0x14, 0x50, 0x01, 0x45, 0x14,
0x50, 0x01, 0x49, 0x4b, 0x45, 0x00, 0x25, 0x14,
0xb4, 0x50, 0x01, 0x45, 0x14, 0x50, 0x30, 0xa4,
0xa5, 0xa2, 0x81, 0x09, 0x45, 0x2d, 0x14, 0x00,
0x94, 0x52, 0xd1, 0x40, 0x09, 0x45, 0x2d, 0x14,
0x00, 0x94, 0x52, 0xd1, 0x40, 0x05, 0x14, 0xb4,
0x94, 0x0c, 0x28, 0xa2, 0x8a, 0x04, 0x14, 0x51,
0x45, 0x00, 0x14, 0x51, 0x45, 0x00, 0x14, 0x51,
0x45, 0x00, 0x14, 0x51, 0x45, 0x00, 0x14, 0x52,
0xd1, 0x40, 0xc4, 0xa2, 0x96, 0x8a, 0x04, 0x25,
0x14, 0xb4, 0x50, 0x31, 0x28, 0xa5, 0xa2, 0x80,
0x12, 0x8a, 0x5a, 0x4a, 0x00, 0x5a, 0x28, 0xa2,
0x80, 0x0a, 0x29, 0x68, 0xa0, 0x04, 0xa2, 0x96,
0x8a, 0x00, 0x4a, 0x29, 0x68, 0xa0, 0x04, 0xa2,
0x9d, 0x45, 0x03, 0x1b, 0x45, 0x3a, 0x8a, 0x00,
0x6d, 0x14, 0xea, 0x28, 0x10, 0x94, 0x52, 0xd1,
0x40, 0x09, 0x4b, 0x45, 0x14, 0x08, 0x28, 0xa2,
0x8a, 0x06, 0x14, 0x52, 0xd1, 0x40, 0x09, 0x45,
0x2d, 0x2d, 0x00, 0x25, 0x14, 0xb4, 0x50, 0x21,
0x28, 0xa5, 0xa2, 0x81, 0x89, 0x4b, 0x45, 0x14,
0x00, 0x51, 0x45, 0x14, 0x00, 0x51, 0x4b, 0x45,
0x00, 0x25, 0x14, 0xb4, 0x50, 0x01, 0x45, 0x2d,
0x14, 0x0c, 0x28, 0xa2, 0x8a, 0x00, 0x4a, 0x5a,
0x5a, 0x28, 0x01, 0x28, 0xa5, 0xa2, 0x90, 0x05,
0x14, 0x51, 0x40, 0x05, 0x14, 0xb4, 0x52, 0x01,
0x28, 0xa5, 0xa2, 0x80, 0x0a, 0x28, 0xa7, 0x50,
0x03, 0x68, 0xa7, 0x51, 0x40, 0x0d, 0xa7, 0x51,
0x45, 0x00, 0x14, 0x51, 0x4b, 0x40, 0x09, 0x45,
0x2d, 0x2d, 0x00, 0x25, 0x14, 0xb4, 0x50, 0x02,
0x51, 0x4b, 0x45, 0x00, 0x14, 0x51, 0x45, 0x00,
0x14, 0x51, 0x45, 0x00, 0x14, 0xb4, 0x53, 0xa8,
0x18, 0xda, 0x5a, 0x5a, 0x28, 0x10, 0x94, 0xb4,
0x51, 0x40, 0xc2, 0x8a, 0x5a, 0x29, 0x00, 0x94,
0x52, 0xd1, 0x40, 0x05, 0x14, 0x51, 0x4c, 0x02,
0x96, 0x8a, 0x29, 0x00, 0x52, 0xd2, 0x52, 0xd0,
0x01, 0x45, 0x14, 0x50, 0x02, 0xd1, 0x45, 0x14,
0x0c, 0x28, 0xa2, 0x96, 0x80, 0x0a, 0x28, 0xa2,
0x81, 0x85, 0x2d, 0x14, 0x50, 0x01, 0x45, 0x14,
0xb4, 0x80, 0x4a, 0x29, 0x68, 0xa0, 0x62, 0xd1,
0x45, 0x14, 0xc0, 0x28, 0xa5, 0xa2, 0x90, 0x0d,
0xa5, 0xa5, 0xa2, 0x80, 0x0a, 0x5a, 0x28, 0xa4,
0x01, 0x45, 0x14, 0xb4, 0x00, 0x94, 0x52, 0xd1,
0x40, 0x05, 0x14, 0x51, 0x4c, 0x02, 0x8a, 0x29,
0x68, 0x01, 0x28, 0xa5, 0xa2, 0x80, 0x16, 0x8a,
0x28, 0xa4, 0x30, 0xa7, 0x55, 0x7b, 0xbb, 0x5f,
0xb7, 0xc1, 0xe4, 0xff, 0x00, 0xaa, 0xac, 0x49,
0xb4, 0x6d, 0x57, 0x4b, 0xf3, 0x66, 0xd2, 0xef,
0x3c, 0xd8, 0x69, 0x17, 0x4c, 0xe9, 0x2b, 0x07,
0xc4, 0x32, 0xcb, 0x75, 0xa4, 0xff, 0x00, 0xc4,
0xae, 0x68, 0xbf, 0x75, 0xfe, 0xb2, 0xb9, 0x09,
0xb5, 0x9d, 0x42, 0x5f, 0x36, 0xcf, 0xce, 0xff,
0x00, 0x5b, 0x56, 0x3c, 0x3d, 0x6b, 0xfd, 0xa9,
0xab, 0x4b, 0x67, 0x3f, 0xfc, 0xf3, 0xff, 0x00,
0x96, 0x74, 0x8d, 0xbd, 0x99, 0x9b, 0x0d, 0xfc,
0xb2, 0xf9, 0xbf, 0xeb, 0x7f, 0x7b, 0x5a, 0xf0,
0xf8, 0x8e, 0xee, 0x2d, 0x27, 0xec, 0x70, 0x7f,
0xdf, 0xca, 0x66, 0xa3, 0xe1, 0x7f, 0xb0, 0x79,
0xbe, 0x46, 0xa5, 0x17, 0xfd, 0x73, 0x92, 0xb0,
0xe1, 0xa8, 0x0f, 0x66, 0x76, 0x90, 0xf8, 0xa2,
0x29, 0x6c, 0x3c, 0x9f, 0xde, 0xf9, 0xde, 0x5f,
0xef, 0x24, 0xaa, 0x76, 0x9e, 0x2d, 0xbb, 0x8b,
0x49, 0xf2, 0x7f, 0xe5, 0xb5, 0x62, 0x5a, 0x5f,
0xcb, 0x6b, 0xfe, 0xa3, 0xfe, 0x5a, 0xd1, 0xe5,
0x45, 0xff,
},
},
{
Header: rtp.Header{
Version: 2,
PayloadType: 26,
Marker: true,
},
Payload: []byte{
0x00, 0x00, 0x05, 0x1e, 0x01, 0xff, 0xf0, 0x87,
0x00, 0x2c, 0x29, 0x0f, 0xd9, 0x97, 0xff, 0x00,
0xb6, 0x65, 0xba, 0x82, 0x5f, 0xb7, 0x4d, 0xe6,
0xcd, 0xff, 0x00, 0x2c, 0xe2, 0xae, 0xa7, 0x49,
0xd5, 0x3f, 0xe2, 0x9a, 0xf3, 0xa7, 0xff, 0x00,
0x5d, 0x15, 0x70, 0xb4, 0x43, 0xfb, 0xdf, 0xf5,
0xf3, 0x4b, 0xff, 0x00, 0x5c, 0xe8, 0xf6, 0x83,
0xf6, 0x67, 0xa1, 0x68, 0x7a, 0xcc, 0x5a, 0xcf,
0xfd, 0x32, 0x9b, 0xfe, 0x79, 0xd5, 0xeb, 0xbb,
0xab, 0x4b, 0x08, 0x3f, 0xd3, 0xab, 0xcd, 0x66,
0xba, 0xfb, 0x57, 0xfd, 0x32, 0x9a, 0x2a, 0x96,
0xd2, 0xff, 0x00, 0xcd, 0xbf, 0xf3, 0xb5, 0x49,
0xbc, 0xdf, 0x2b, 0xfe, 0x59, 0xd3, 0x27, 0xd9,
0x9a, 0x30, 0xdd, 0x7d, 0xab, 0x5e, 0xfb, 0x1d,
0x8c, 0xde, 0x55, 0x9c, 0xb2, 0x79, 0x95, 0xd3,
0x6a, 0x3a, 0xa7, 0xd9, 0x75, 0xdb, 0x5b, 0x39,
0xff, 0x00, 0xd4, 0xcb, 0xff, 0x00, 0x2d, 0x2b,
0xcf, 0xbe, 0xdf, 0xe5, 0x6a, 0xdf, 0x6c, 0x83,
0xfe, 0x59, 0x54, 0xda, 0xb6, 0xb3, 0x2e, 0xb3,
0x7f, 0xe7, 0x7f, 0xaa, 0xff, 0xff, 0xd9,
},
},
},
decoded: unit.PayloadMJPEG{
0xff, 0xd8, 0xff, 0xdb, 0x00, 0x84, 0x00, 0x0d,
0x09, 0x0a, 0x0b, 0x0a, 0x08, 0x0d, 0x0b, 0x0a,
0x0b, 0x0e, 0x0e, 0x0d, 0x0f, 0x13, 0x20, 0x15,
0x13, 0x12, 0x12, 0x13, 0x27, 0x1c, 0x1e, 0x17,
0x20, 0x2e, 0x29, 0x31, 0x30, 0x2e, 0x29, 0x2d,
0x2c, 0x33, 0x3a, 0x4a, 0x3e, 0x33, 0x36, 0x46,
0x37, 0x2c, 0x2d, 0x40, 0x57, 0x41, 0x46, 0x4c,
0x4e, 0x52, 0x53, 0x52, 0x32, 0x3e, 0x5a, 0x61,
0x5a, 0x50, 0x60, 0x4a, 0x51, 0x52, 0x4f, 0x01,
0x0e, 0x0e, 0x0e, 0x13, 0x11, 0x13, 0x26, 0x15,
0x15, 0x26, 0x4f, 0x35, 0x2d, 0x35, 0x4f, 0x4f,
0x4f, 0x4f, 0x4f, 0x4f, 0x4f, 0x4f, 0x4f, 0x4f,
0x4f, 0x4f, 0x4f, 0x4f, 0x4f, 0x4f, 0x4f, 0x4f,
0x4f, 0x4f, 0x4f, 0x4f, 0x4f, 0x4f, 0x4f, 0x4f,
0x4f, 0x4f, 0x4f, 0x4f, 0x4f, 0x4f, 0x4f, 0x4f,
0x4f, 0x4f, 0x4f, 0x4f, 0x4f, 0x4f, 0x4f, 0x4f,
0x4f, 0x4f, 0x4f, 0x4f, 0x4f, 0x4f, 0x4f, 0x4f,
0xff, 0xc0, 0x00, 0x11, 0x08, 0x04, 0x38, 0x07,
0x80, 0x03, 0x00, 0x22, 0x00, 0x01, 0x11, 0x01,
0x02, 0x11, 0x01, 0xff, 0xc4, 0x00, 0x1f, 0x00,
0x00, 0x01, 0x05, 0x01, 0x01, 0x01, 0x01, 0x01,
0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
0x08, 0x09, 0x0a, 0x0b, 0xff, 0xc4, 0x00, 0xb5,
0x10, 0x00, 0x02, 0x01, 0x03, 0x03, 0x02, 0x04,
0x03, 0x05, 0x05, 0x04, 0x04, 0x00, 0x00, 0x01,
0x7d, 0x01, 0x02, 0x03, 0x00, 0x04, 0x11, 0x05,
0x12, 0x21, 0x31, 0x41, 0x06, 0x13, 0x51, 0x61,
0x07, 0x22, 0x71, 0x14, 0x32, 0x81, 0x91, 0xa1,
0x08, 0x23, 0x42, 0xb1, 0xc1, 0x15, 0x52, 0xd1,
0xf0, 0x24, 0x33, 0x62, 0x72, 0x82, 0x09, 0x0a,
0x16, 0x17, 0x18, 0x19, 0x1a, 0x25, 0x26, 0x27,
0x28, 0x29, 0x2a, 0x34, 0x35, 0x36, 0x37, 0x38,
0x39, 0x3a, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48,
0x49, 0x4a, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58,
0x59, 0x5a, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68,
0x69, 0x6a, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78,
0x79, 0x7a, 0x83, 0x84, 0x85, 0x86, 0x87, 0x88,
0x89, 0x8a, 0x92, 0x93, 0x94, 0x95, 0x96, 0x97,
0x98, 0x99, 0x9a, 0xa2, 0xa3, 0xa4, 0xa5, 0xa6,
0xa7, 0xa8, 0xa9, 0xaa, 0xb2, 0xb3, 0xb4, 0xb5,
0xb6, 0xb7, 0xb8, 0xb9, 0xba, 0xc2, 0xc3, 0xc4,
0xc5, 0xc6, 0xc7, 0xc8, 0xc9, 0xca, 0xd2, 0xd3,
0xd4, 0xd5, 0xd6, 0xd7, 0xd8, 0xd9, 0xda, 0xe1,
0xe2, 0xe3, 0xe4, 0xe5, 0xe6, 0xe7, 0xe8, 0xe9,
0xea, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7,
0xf8, 0xf9, 0xfa, 0xff, 0xc4, 0x00, 0x1f, 0x01,
0x00, 0x03, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
0x01, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
0x08, 0x09, 0x0a, 0x0b, 0xff, 0xc4, 0x00, 0xb5,
0x11, 0x00, 0x02, 0x01, 0x02, 0x04, 0x04, 0x03,
0x04, 0x07, 0x05, 0x04, 0x04, 0x00, 0x01, 0x02,
0x77, 0x00, 0x01, 0x02, 0x03, 0x11, 0x04, 0x05,
0x21, 0x31, 0x06, 0x12, 0x41, 0x51, 0x07, 0x61,
0x71, 0x13, 0x22, 0x32, 0x81, 0x08, 0x14, 0x42,
0x91, 0xa1, 0xb1, 0xc1, 0x09, 0x23, 0x33, 0x52,
0xf0, 0x15, 0x62, 0x72, 0xd1, 0x0a, 0x16, 0x24,
0x34, 0xe1, 0x25, 0xf1, 0x17, 0x18, 0x19, 0x1a,
0x26, 0x27, 0x28, 0x29, 0x2a, 0x35, 0x36, 0x37,
0x38, 0x39, 0x3a, 0x43, 0x44, 0x45, 0x46, 0x47,
0x48, 0x49, 0x4a, 0x53, 0x54, 0x55, 0x56, 0x57,
0x58, 0x59, 0x5a, 0x63, 0x64, 0x65, 0x66, 0x67,
0x68, 0x69, 0x6a, 0x73, 0x74, 0x75, 0x76, 0x77,
0x78, 0x79, 0x7a, 0x82, 0x83, 0x84, 0x85, 0x86,
0x87, 0x88, 0x89, 0x8a, 0x92, 0x93, 0x94, 0x95,
0x96, 0x97, 0x98, 0x99, 0x9a, 0xa2, 0xa3, 0xa4,
0xa5, 0xa6, 0xa7, 0xa8, 0xa9, 0xaa, 0xb2, 0xb3,
0xb4, 0xb5, 0xb6, 0xb7, 0xb8, 0xb9, 0xba, 0xc2,
0xc3, 0xc4, 0xc5, 0xc6, 0xc7, 0xc8, 0xc9, 0xca,
0xd2, 0xd3, 0xd4, 0xd5, 0xd6, 0xd7, 0xd8, 0xd9,
0xda, 0xe2, 0xe3, 0xe4, 0xe5, 0xe6, 0xe7, 0xe8,
0xe9, 0xea, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7,
0xf8, 0xf9, 0xfa, 0xff, 0xda, 0x00, 0x0c, 0x03,
0x00, 0x00, 0x01, 0x11, 0x02, 0x11, 0x00, 0x3f,
0x00, 0x92, 0x8a, 0x28, 0xaf, 0x54, 0xf2, 0x42,
0x8a, 0x28, 0xa0, 0x02, 0x96, 0x92, 0x96, 0x80,
0x0a, 0x4a, 0x75, 0x25, 0x02, 0x12, 0x8a, 0x5a,
0x28, 0x18, 0x94, 0x52, 0xd1, 0x40, 0x09, 0x45,
0x2d, 0x14, 0x08, 0x29, 0x69, 0x29, 0x68, 0x00,
0xa5, 0xa4, 0xa5, 0xa0, 0x02, 0x8a, 0x28, 0xa0,
0x02, 0x8a, 0x28, 0xa0, 0x04, 0xa5, 0xa2, 0x8a,
0x00, 0x5a, 0x28, 0xa2, 0x80, 0x0a, 0x28, 0xa2,
0x80, 0x0a, 0x28, 0xa2, 0x80, 0x12, 0x8a, 0x5a,
0x28, 0x24, 0x29, 0x69, 0x29, 0x68, 0x00, 0xa2,
0x8a, 0x28, 0x00, 0xa2, 0x8a, 0x28, 0x00, 0xa2,
0x8a, 0x28, 0x00, 0xa2, 0x8a, 0x28, 0x00, 0xa2,
0x8a, 0x28, 0x00, 0xa2, 0x8a, 0x28, 0x00, 0xa2,
0x8a, 0x28, 0x00, 0xa2, 0x8a, 0x28, 0x00, 0xa2,
0x8a, 0x28, 0x00, 0xa2, 0x8a, 0x28, 0x00, 0xa2,
0x8a, 0x28, 0x00, 0xa4, 0xa5, 0xa4, 0xa0, 0x02,
0x8a, 0x28, 0xa0, 0x02, 0x8a, 0x28, 0xa0, 0x02,
0x8a, 0x28, 0xa0, 0x02, 0x8a, 0x28, 0xa0, 0x02,
0x8a, 0x28, 0xa0, 0x02, 0x8a, 0x28, 0xa0, 0x02,
0x8a, 0x28, 0xa0, 0x02, 0x8a, 0x28, 0xa0, 0x02,
0x96, 0x92, 0x96, 0x80, 0x0a, 0x28, 0xa2, 0x80,
0x0a, 0x28, 0xa2, 0x80, 0x0a, 0x28, 0xa2, 0x80,
0x0a, 0x28, 0xa2, 0x80, 0x0a, 0x28, 0xa2, 0x80,
0x0a, 0x28, 0xa2, 0x80, 0x0a, 0x28, 0xa2, 0x80,
0x0a, 0x28, 0xa2, 0x80, 0x0a, 0x28, 0xa2, 0x81,
0x85, 0x14, 0x51, 0x40, 0x05, 0x14, 0x51, 0x40,
0x05, 0x14, 0x51, 0x40, 0x05, 0x14, 0x52, 0xd0,
0x01, 0x45, 0x14, 0x50, 0x01, 0x45, 0x14, 0x50,
0x01, 0x45, 0x14, 0x50, 0x01, 0x45, 0x2d, 0x14,
0x00, 0x94, 0xb4, 0x51, 0x40, 0x05, 0x14, 0x52,
0xd0, 0x02, 0x51, 0x4b, 0x45, 0x00, 0x25, 0x2d,
0x14, 0x50, 0x01, 0x45, 0x14, 0x50, 0x01, 0x45,
0x14, 0x50, 0x20, 0xa5, 0xa4, 0xa5, 0xa0, 0x02,
0x8a, 0x28, 0xa0, 0x02, 0x8a, 0x28, 0xa0, 0x02,
0x8a, 0x5a, 0x28, 0x18, 0x94, 0xb4, 0x51, 0x40,
0xc2, 0x8a, 0x28, 0xa0, 0x05, 0xa2, 0x92, 0x9d,
0x40, 0x05, 0x14, 0x51, 0x48, 0x02, 0x8a, 0x28,
0xa4, 0x01, 0x4b, 0x49, 0x4b, 0x40, 0x05, 0x14,
0x51, 0x40, 0x05, 0x14, 0xb4, 0x50, 0x02, 0x51,
0x4b, 0x45, 0x00, 0x25, 0x2d, 0x14, 0x50, 0x03,
0xa8, 0xa2, 0x8a, 0x00, 0x28, 0xa2, 0x8a, 0x00,
0x5a, 0x29, 0x29, 0x68, 0x00, 0xa2, 0x8a, 0x28,
0x00, 0xa2, 0x96, 0x8a, 0x06, 0x25, 0x14, 0xb4,
0x50, 0x01, 0x45, 0x14, 0x50, 0x02, 0xd2, 0xd2,
0x52, 0xd0, 0x20, 0xa2, 0x8a, 0x28, 0x01, 0x68,
0xa2, 0x8a, 0x40, 0x14, 0x51, 0x45, 0x30, 0x0a,
0x5a, 0x4a, 0x5a, 0x06, 0x14, 0x51, 0x45, 0x02,
0x0a, 0x28, 0xa5, 0xa0, 0x62, 0x51, 0x4b, 0x45,
0x00, 0x2d, 0x14, 0x51, 0x48, 0x02, 0x8a, 0x28,
0xa0, 0x61, 0x45, 0x14, 0x50, 0x03, 0xa8, 0xa2,
0x8a, 0x06, 0x2d, 0x14, 0x51, 0x48, 0x02, 0x8a,
0x28, 0xa4, 0x30, 0xa2, 0x8a, 0x2a, 0x80, 0x28,
0xa2, 0x8a, 0x00, 0x28, 0xa2, 0x8a, 0x92, 0x45,
0xa5, 0xa2, 0x96, 0x82, 0x82, 0x8a, 0x28, 0xa0,
0x02, 0x8a, 0x28, 0xa0, 0x05, 0xa2, 0x8a, 0x29,
0x80, 0x52, 0xd2, 0x52, 0xd0, 0x01, 0x45, 0x14,
0x50, 0x01, 0x4e, 0xa2, 0x8a, 0x43, 0x0a, 0x28,
0xa2, 0x80, 0x0a, 0x28, 0xa4, 0xa4, 0x31, 0x68,
0xa4, 0xf3, 0x62, 0xff, 0x00, 0x9e, 0xd1, 0x7e,
0xea, 0x9f, 0xfe, 0xb6, 0xa4, 0x62, 0x52, 0x53,
0xa9, 0x28, 0x01, 0x28, 0xa2, 0x6f, 0xdd, 0x7f,
0xaf, 0xa5, 0xa0, 0x62, 0x51, 0x4b, 0x45, 0x00,
0x25, 0x14, 0xbf, 0xba, 0xff, 0x00, 0xae, 0xb4,
0xea, 0x60, 0x36, 0x9d, 0x49, 0x49, 0x34, 0xb1,
0x45, 0xfe, 0xbe, 0x6f, 0x2a, 0x98, 0x0f, 0xa2,
0xb9, 0xbd, 0x0f, 0x59, 0x97, 0x54, 0xf1, 0x2d,
0xd7, 0xfc, 0xf9, 0xd7, 0x49, 0x52, 0x30, 0xac,
0x7d, 0x5b, 0x54, 0xd5, 0x74, 0xbf, 0xdf, 0x41,
0x67, 0x15, 0xd4, 0x35, 0x63, 0x56, 0xd5, 0x22,
0xd2, 0xe0, 0xf3, 0xbc, 0x99, 0x65, 0xae, 0x4b,
0x51, 0xf1, 0x44, 0x52, 0xff, 0x00, 0xc7, 0x97,
0x9b, 0xe4, 0xd0, 0x69, 0x4c, 0x76, 0xa3, 0xe2,
0xd9, 0xa5, 0x82, 0x29, 0xb4, 0xbf, 0xdd, 0x79,
0xbf, 0xeb, 0x22, 0xaa, 0x7e, 0x1e, 0xd5, 0x3e,
0xc1, 0x3f, 0xfa, 0x9f, 0xfa, 0xe9, 0x25, 0x61,
0xd6, 0x9e, 0x87, 0xf6, 0xbf, 0xed, 0x68, 0xbc,
0x8a, 0x82, 0xcf, 0x4e, 0x86, 0x5f, 0x36, 0x0a,
0x92, 0x9b, 0xff, 0x00, 0x5d, 0xeb, 0x3a, 0x6d,
0x53, 0xfd, 0x3f, 0xec, 0x76, 0x3f, 0xbd, 0xff,
0x00, 0xa6, 0xbf, 0xc1, 0x54, 0x66, 0x69, 0x51,
0x50, 0x4b, 0x2c, 0x51, 0x7e, 0xe7, 0xce, 0xf3,
0x66, 0xff, 0x00, 0xa6, 0x75, 0x35, 0x00, 0x2d,
0x65, 0x6a, 0xde, 0x23, 0xd3, 0xec, 0x3f, 0xe5,
0xb7, 0x9b, 0x34, 0x5f, 0xf2, 0xce, 0xb4, 0x7e,
0xd5, 0x69, 0x2f, 0xfc, 0xbe, 0x45, 0x5e, 0x7b,
0xe2, 0x7d, 0x07, 0xec, 0x1e, 0x6e, 0xa5, 0xf6,
0xc8, 0xa5, 0xf3, 0x6a, 0xc0, 0xdf, 0xa2, 0x9d,
0x45, 0x6c, 0x72, 0x0d, 0xa5, 0xa5, 0xa2, 0x80,
0x12, 0x96, 0x8a, 0x28, 0x10, 0x51, 0x4b, 0x45,
0x00, 0x25, 0x14, 0xb4, 0x50, 0x02, 0x51, 0x4b,
0x45, 0x03, 0x12, 0x8a, 0x5a, 0x28, 0x10, 0x94,
0xb4, 0x51, 0x40, 0x05, 0x14, 0x51, 0x40, 0x05,
0x14, 0xb4, 0x50, 0x02, 0x51, 0x4b, 0x45, 0x00,
0x14, 0x51, 0x4b, 0x40, 0x84, 0xa2, 0x8a, 0x28,
0x00, 0xa2, 0x96, 0x8a, 0x00, 0x4a, 0x29, 0x68,
0xa0, 0x04, 0xa2, 0x96, 0x8a, 0x00, 0x4a, 0x29,
0x68, 0xa0, 0x41, 0x45, 0x14, 0x50, 0x01, 0x45,
0x14, 0x50, 0x01, 0x45, 0x14, 0x50, 0x01, 0x45,
0x14, 0x50, 0x01, 0x45, 0x14, 0x50, 0x01, 0x45,
0x14, 0x50, 0x01, 0x45, 0x14, 0x50, 0x01, 0x45,
0x14, 0x50, 0x01, 0x45, 0x14, 0x50, 0x01, 0x45,
0x14, 0x50, 0x01, 0x45, 0x14, 0x50, 0x01, 0x49,
0x4b, 0x45, 0x00, 0x25, 0x14, 0xb4, 0x50, 0x01,
0x45, 0x14, 0x50, 0x30, 0xa4, 0xa5, 0xa2, 0x81,
0x09, 0x45, 0x2d, 0x14, 0x00, 0x94, 0x52, 0xd1,
0x40, 0x09, 0x45, 0x2d, 0x14, 0x00, 0x94, 0x52,
0xd1, 0x40, 0x05, 0x14, 0xb4, 0x94, 0x0c, 0x28,
0xa2, 0x8a, 0x04, 0x14, 0x51, 0x45, 0x00, 0x14,
0x51, 0x45, 0x00, 0x14, 0x51, 0x45, 0x00, 0x14,
0x51, 0x45, 0x00, 0x14, 0x52, 0xd1, 0x40, 0xc4,
0xa2, 0x96, 0x8a, 0x04, 0x25, 0x14, 0xb4, 0x50,
0x31, 0x28, 0xa5, 0xa2, 0x80, 0x12, 0x8a, 0x5a,
0x4a, 0x00, 0x5a, 0x28, 0xa2, 0x80, 0x0a, 0x29,
0x68, 0xa0, 0x04, 0xa2, 0x96, 0x8a, 0x00, 0x4a,
0x29, 0x68, 0xa0, 0x04, 0xa2, 0x9d, 0x45, 0x03,
0x1b, 0x45, 0x3a, 0x8a, 0x00, 0x6d, 0x14, 0xea,
0x28, 0x10, 0x94, 0x52, 0xd1, 0x40, 0x09, 0x4b,
0x45, 0x14, 0x08, 0x28, 0xa2, 0x8a, 0x06, 0x14,
0x52, 0xd1, 0x40, 0x09, 0x45, 0x2d, 0x2d, 0x00,
0x25, 0x14, 0xb4, 0x50, 0x21, 0x28, 0xa5, 0xa2,
0x81, 0x89, 0x4b, 0x45, 0x14, 0x00, 0x51, 0x45,
0x14, 0x00, 0x51, 0x4b, 0x45, 0x00, 0x25, 0x14,
0xb4, 0x50, 0x01, 0x45, 0x2d, 0x14, 0x0c, 0x28,
0xa2, 0x8a, 0x00, 0x4a, 0x5a, 0x5a, 0x28, 0x01,
0x28, 0xa5, 0xa2, 0x90, 0x05, 0x14, 0x51, 0x40,
0x05, 0x14, 0xb4, 0x52, 0x01, 0x28, 0xa5, 0xa2,
0x80, 0x0a, 0x28, 0xa7, 0x50, 0x03, 0x68, 0xa7,
0x51, 0x40, 0x0d, 0xa7, 0x51, 0x45, 0x00, 0x14,
0x51, 0x4b, 0x40, 0x09, 0x45, 0x2d, 0x2d, 0x00,
0x25, 0x14, 0xb4, 0x50, 0x02, 0x51, 0x4b, 0x45,
0x00, 0x14, 0x51, 0x45, 0x00, 0x14, 0x51, 0x45,
0x00, 0x14, 0xb4, 0x53, 0xa8, 0x18, 0xda, 0x5a,
0x5a, 0x28, 0x10, 0x94, 0xb4, 0x51, 0x40, 0xc2,
0x8a, 0x5a, 0x29, 0x00, 0x94, 0x52, 0xd1, 0x40,
0x05, 0x14, 0x51, 0x4c, 0x02, 0x96, 0x8a, 0x29,
0x00, 0x52, 0xd2, 0x52, 0xd0, 0x01, 0x45, 0x14,
0x50, 0x02, 0xd1, 0x45, 0x14, 0x0c, 0x28, 0xa2,
0x96, 0x80, 0x0a, 0x28, 0xa2, 0x81, 0x85, 0x2d,
0x14, 0x50, 0x01, 0x45, 0x14, 0xb4, 0x80, 0x4a,
0x29, 0x68, 0xa0, 0x62, 0xd1, 0x45, 0x14, 0xc0,
0x28, 0xa5, 0xa2, 0x90, 0x0d, 0xa5, 0xa5, 0xa2,
0x80, 0x0a, 0x5a, 0x28, 0xa4, 0x01, 0x45, 0x14,
0xb4, 0x00, 0x94, 0x52, 0xd1, 0x40, 0x05, 0x14,
0x51, 0x4c, 0x02, 0x8a, 0x29, 0x68, 0x01, 0x28,
0xa5, 0xa2, 0x80, 0x16, 0x8a, 0x28, 0xa4, 0x30,
0xa7, 0x55, 0x7b, 0xbb, 0x5f, 0xb7, 0xc1, 0xe4,
0xff, 0x00, 0xaa, 0xac, 0x49, 0xb4, 0x6d, 0x57,
0x4b, 0xf3, 0x66, 0xd2, 0xef, 0x3c, 0xd8, 0x69,
0x17, 0x4c, 0xe9, 0x2b, 0x07, 0xc4, 0x32, 0xcb,
0x75, 0xa4, 0xff, 0x00, 0xc4, 0xae, 0x68, 0xbf,
0x75, 0xfe, 0xb2, 0xb9, 0x09, 0xb5, 0x9d, 0x42,
0x5f, 0x36, 0xcf, 0xce, 0xff, 0x00, 0x5b, 0x56,
0x3c, 0x3d, 0x6b, 0xfd, 0xa9, 0xab, 0x4b, 0x67,
0x3f, 0xfc, 0xf3, 0xff, 0x00, 0x96, 0x74, 0x8d,
0xbd, 0x99, 0x9b, 0x0d, 0xfc, 0xb2, 0xf9, 0xbf,
0xeb, 0x7f, 0x7b, 0x5a, 0xf0, 0xf8, 0x8e, 0xee,
0x2d, 0x27, 0xec, 0x70, 0x7f, 0xdf, 0xca, 0x66,
0xa3, 0xe1, 0x7f, 0xb0, 0x79, 0xbe, 0x46, 0xa5,
0x17, 0xfd, 0x73, 0x92, 0xb0, 0xe1, 0xa8, 0x0f,
0x66, 0x76, 0x90, 0xf8, 0xa2, 0x29, 0x6c, 0x3c,
0x9f, 0xde, 0xf9, 0xde, 0x5f, 0xef, 0x24, 0xaa,
0x76, 0x9e, 0x2d, 0xbb, 0x8b, 0x49, 0xf2, 0x7f,
0xe5, 0xb5, 0x62, 0x5a, 0x5f, 0xcb, 0x6b, 0xfe,
0xa3, 0xfe, 0x5a, 0xd1, 0xe5, 0x45, 0xff, 0x00,
0x2c, 0x29, 0x0f, 0xd9, 0x97, 0xff, 0x00, 0xb6,
0x65, 0xba, 0x82, 0x5f, 0xb7, 0x4d, 0xe6, 0xcd,
0xff, 0x00, 0x2c, 0xe2, 0xae, 0xa7, 0x49, 0xd5,
0x3f, 0xe2, 0x9a, 0xf3, 0xa7, 0xff, 0x00, 0x5d,
0x15, 0x70, 0xb4, 0x43, 0xfb, 0xdf, 0xf5, 0xf3,
0x4b, 0xff, 0x00, 0x5c, 0xe8, 0xf6, 0x83, 0xf6,
0x67, 0xa1, 0x68, 0x7a, 0xcc, 0x5a, 0xcf, 0xfd,
0x32, 0x9b, 0xfe, 0x79, 0xd5, 0xeb, 0xbb, 0xab,
0x4b, 0x08, 0x3f, 0xd3, 0xab, 0xcd, 0x66, 0xba,
0xfb, 0x57, 0xfd, 0x32, 0x9a, 0x2a, 0x96, 0xd2,
0xff, 0x00, 0xcd, 0xbf, 0xf3, 0xb5, 0x49, 0xbc,
0xdf, 0x2b, 0xfe, 0x59, 0xd3, 0x27, 0xd9, 0x9a,
0x30, 0xdd, 0x7d, 0xab, 0x5e, 0xfb, 0x1d, 0x8c,
0xde, 0x55, 0x9c, 0xb2, 0x79, 0x95, 0xd3, 0x6a,
0x3a, 0xa7, 0xd9, 0x75, 0xdb, 0x5b, 0x39, 0xff,
0x00, 0xd4, 0xcb, 0xff, 0x00, 0x2d, 0x2b, 0xcf,
0xbe, 0xdf, 0xe5, 0x6a, 0xdf, 0x6c, 0x83, 0xfe,
0x59, 0x54, 0xda, 0xb6, 0xb3, 0x2e, 0xb3, 0x7f,
0xe7, 0x7f, 0xaa, 0xff, 0xff, 0xd9,
},
},
{
name: "mpeg4audio",
format: &format.MPEG4Audio{
PayloadTyp: 96,
SizeLength: 13,
IndexLength: 3,
IndexDeltaLength: 3,
},
encoded: []*rtp.Packet{
{
Header: rtp.Header{
Version: 2,
Marker: true,
PayloadType: 96,
SequenceNumber: 123,
Timestamp: 45343,
SSRC: 563423,
},
Payload: []byte{
// AU-headers-length: 16 bits (2 bytes) = 16 bits of headers
0x00, 0x10,
// AU-header: 13 bits size + 3 bits index
// size=4 (13 bits): 0000000000100
// index=0 (3 bits): 000
// Combined: 0000000000100000 = 0x0020
0x00, 0x20,
// AU data
0x01, 0x02, 0x03, 0x04,
},
},
},
decoded: unit.PayloadMPEG4Audio{
{0x01, 0x02, 0x03, 0x04},
},
},
{
name: "opus",
format: &format.Opus{
PayloadTyp: 96,
ChannelCount: 2,
},
encoded: []*rtp.Packet{
{
Header: rtp.Header{
Version: 2,
Marker: false,
PayloadType: 96,
SequenceNumber: 123,
Timestamp: 45343,
SSRC: 563423,
},
Payload: []byte{0x01, 0x02, 0x03, 0x04},
},
},
decoded: unit.PayloadOpus{
{0x01, 0x02, 0x03, 0x04},
},
},
{
name: "g711",
format: &format.G711{
MULaw: true,
SampleRate: 8000,
ChannelCount: 1,
},
encoded: []*rtp.Packet{
{
Header: rtp.Header{
Version: 2,
Marker: false,
PayloadType: 0,
SequenceNumber: 123,
Timestamp: 45343,
SSRC: 563423,
},
Payload: []byte{0x01, 0x02, 0x03, 0x04},
},
},
decoded: unit.PayloadG711{0x01, 0x02, 0x03, 0x04},
},
{
name: "lpcm",
format: &format.LPCM{
PayloadTyp: 96,
BitDepth: 16,
SampleRate: 48000,
ChannelCount: 2,
},
encoded: []*rtp.Packet{
{
Header: rtp.Header{
Version: 2,
Marker: false,
PayloadType: 96,
SequenceNumber: 123,
Timestamp: 45343,
SSRC: 563423,
},
Payload: []byte{0x01, 0x02, 0x03, 0x04},
},
},
decoded: unit.PayloadLPCM{0x01, 0x02, 0x03, 0x04},
},
{
name: "klv",
format: &format.KLV{
PayloadTyp: 96,
},
encoded: []*rtp.Packet{
{
Header: rtp.Header{
Version: 2,
Marker: true, // Marker bit indicates complete KLV unit
PayloadType: 96,
SequenceNumber: 123,
Timestamp: 45343,
SSRC: 563423,
},
Payload: []byte{
// KLV Universal Label Key (16 bytes) - starts with 0x060e2b34
0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x01,
0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08,
// Length (1 byte, short form: 4 bytes of data)
0x04,
// Value (4 bytes)
0x01, 0x02, 0x03, 0x04,
},
},
},
decoded: unit.PayloadKLV{
// Complete KLV unit: Universal Label Key + Length + Value
0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x01,
0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08,
0x04,
0x01, 0x02, 0x03, 0x04,
},
},
}
func TestStreamDecode(t *testing.T) {
for _, ca := range casesDecodeEncode {
t.Run(ca.name, func(t *testing.T) {
desc := &description.Session{Medias: []*description.Media{{
Formats: []format.Format{ca.format},
}}}
strm := &Stream{
Desc: desc,
WriteQueueSize: 512,
RTPMaxPayloadSize: 1450,
Parent: &nilLogger{},
}
err := strm.Initialize()
require.NoError(t, err)
defer strm.Close()
subStream := &SubStream{
Stream: strm,
UseRTPPackets: true,
}
err = subStream.Initialize()
require.NoError(t, err)
r := &Reader{}
recv := make(chan *unit.Unit)
r.OnData(desc.Medias[0], ca.format, func(u *unit.Unit) error {
if !u.NilPayload() {
recv <- u
close(recv)
}
return nil
})
strm.AddReader(r)
defer strm.RemoveReader(r)
for _, pkt := range ca.encoded {
subStream.WriteUnit(desc.Medias[0], ca.format, &unit.Unit{
RTPPackets: []*rtp.Packet{pkt},
})
}
received := <-recv
require.Equal(t, ca.decoded, received.Payload)
})
}
}
func TestStreamEncode(t *testing.T) {
for _, ca := range casesDecodeEncode {
t.Run(ca.name, func(t *testing.T) {
desc := &description.Session{Medias: []*description.Media{{
Formats: []format.Format{ca.format},
}}}
strm := &Stream{
Desc: desc,
WriteQueueSize: 512,
RTPMaxPayloadSize: 1450,
Parent: &nilLogger{},
}
err := strm.Initialize()
require.NoError(t, err)
defer strm.Close()
subStream := &SubStream{
Stream: strm,
UseRTPPackets: false,
}
err = subStream.Initialize()
require.NoError(t, err)
r := &Reader{}
recv := make(chan struct{})
r.OnData(desc.Medias[0], ca.format, func(u *unit.Unit) error {
for i := range min(len(u.RTPPackets), len(ca.encoded)) {
u.RTPPackets[i].Timestamp = ca.encoded[i].Timestamp
u.RTPPackets[i].SequenceNumber = ca.encoded[i].SequenceNumber
u.RTPPackets[i].SSRC = ca.encoded[i].SSRC
}
require.Equal(t, ca.encoded, u.RTPPackets)
close(recv)
return nil
})
strm.AddReader(r)
defer strm.RemoveReader(r)
subStream.WriteUnit(desc.Medias[0], ca.format, &unit.Unit{
Payload: ca.decoded,
})
<-recv
})
}
}
================================================
FILE: internal/stream/sub_stream.go
================================================
package stream
import (
"fmt"
"reflect"
"github.com/bluenviron/gortsplib/v5/pkg/description"
"github.com/bluenviron/gortsplib/v5/pkg/format"
"github.com/bluenviron/mediacommon/v2/pkg/codecs/mpeg4audio"
"github.com/bluenviron/mediamtx/internal/logger"
"github.com/bluenviron/mediamtx/internal/unit"
)
// FormatsToCodecs returns the name of codecs of given formats.
func FormatsToCodecs(formats []format.Format) []string {
ret := make([]string, len(formats))
for i, forma := range formats {
ret[i] = forma.Codec()
}
return ret
}
func gatherFormats(medias []*description.Media) []format.Format {
n := 0
for _, media := range medias {
n += len(media.Formats)
}
if n == 0 {
return nil
}
formats := make([]format.Format, n)
n = 0
for _, media := range medias {
n += copy(formats[n:], media.Formats)
}
return formats
}
func mediasToCodecs(medias []*description.Media) []string {
return FormatsToCodecs(gatherFormats(medias))
}
func formatMPEG4AudioConfig(asc *mpeg4audio.AudioSpecificConfig) string {
return fmt.Sprintf("type=%d, sampleRate=%d, channelCount=%d",
asc.Type, asc.SampleRate, asc.ChannelConfig)
}
func formatG711Config(f *format.G711) string {
return fmt.Sprintf("MULaw=%v, sampleRate=%d, channelCount=%d",
f.MULaw, f.SampleRate, f.ChannelCount)
}
func formatLPCMConfig(f *format.LPCM) string {
return fmt.Sprintf("bitDepth=%d, sampleRate=%d, channelCount=%d",
f.BitDepth, f.SampleRate, f.ChannelCount)
}
func mediasAreCompatible(medias1 []*description.Media, medias2 []*description.Media) error {
if len(medias1) != len(medias2) {
return fmt.Errorf("wants to publish %v, but stream expects %v",
mediasToCodecs(medias2), mediasToCodecs(medias1))
}
for i := range medias1 {
if len(medias1[i].Formats) != len(medias2[i].Formats) {
return fmt.Errorf("wants to publish %v, but stream expects %v",
mediasToCodecs(medias2), mediasToCodecs(medias1))
}
for j := range medias1[i].Formats {
if reflect.TypeOf(medias1[i].Formats[j]) != reflect.TypeOf(medias2[i].Formats[j]) {
return fmt.Errorf("wants to publish %v, but stream expects %v",
mediasToCodecs(medias2), mediasToCodecs(medias1))
}
}
}
for i := range medias1 {
for j := range medias1[i].Formats {
switch format1 := medias1[i].Formats[j].(type) {
case *format.MPEG4Audio:
format2 := medias2[i].Formats[j].(*format.MPEG4Audio)
if !reflect.DeepEqual(format1.Config, format2.Config) {
return fmt.Errorf("MPEG-4 audio configuration does not match, is %s, but stream expects %s",
formatMPEG4AudioConfig(format2.Config), formatMPEG4AudioConfig(format1.Config))
}
case *format.G711:
format2 := medias2[i].Formats[j].(*format.G711)
if format1.MULaw != format2.MULaw ||
format1.SampleRate != format2.SampleRate ||
format1.ChannelCount != format2.ChannelCount {
return fmt.Errorf("G711 configuration does not match, is %s, but stream expects %s",
formatG711Config(format2), formatG711Config(format1))
}
case *format.LPCM:
format2 := medias2[i].Formats[j].(*format.LPCM)
if format1.BitDepth != format2.BitDepth ||
format1.SampleRate != format2.SampleRate ||
format1.ChannelCount != format2.ChannelCount {
return fmt.Errorf("LPCM configuration does not match, is %s, but stream expects %s",
formatLPCMConfig(format2), formatLPCMConfig(format1))
}
}
}
}
return nil
}
// SubStream is a Stream without interruptions.
type SubStream struct {
Stream *Stream
CurDesc *description.Session
UseRTPPackets bool
medias map[*description.Media]*subStreamMedia
}
// Initialize initializes the SubStream.
func (ss *SubStream) Initialize() error {
if !ss.Stream.AlwaysAvailable {
if ss.Stream.subStream != nil {
panic("should not happen")
}
if ss.CurDesc != nil {
panic("should not happen")
}
} else {
if ss.CurDesc == nil {
panic("should not happen")
}
err := mediasAreCompatible(ss.Stream.Desc.Medias, ss.CurDesc.Medias)
if err != nil {
return err
}
}
if !ss.Stream.AlwaysAvailable {
ss.CurDesc = ss.Stream.Desc
}
ss.medias = make(map[*description.Media]*subStreamMedia)
for i, curMedia := range ss.CurDesc.Medias {
media := ss.Stream.Desc.Medias[i]
ssm := &subStreamMedia{
curMedia: curMedia,
streamMedia: ss.Stream.medias[media],
useRTPPackets: ss.UseRTPPackets,
}
err := ssm.initialize()
if err != nil {
return err
}
ss.medias[curMedia] = ssm
}
if ss.Stream.AlwaysAvailable {
if ss.Stream.offlineSubStream != nil {
ss.Stream.Parent.Log(logger.Info, "stream is online")
// wait for the entire duration of the last sample of the offline sub stream
// to minimize errors in clients.
// TODO: it would be better in the future to wait for the last sample
// of normal sub streams as well (this is currently impossible because
// we don't know the duration of their samples).
ss.Stream.offlineSubStream.close(true)
ss.Stream.offlineSubStream = nil
}
}
ss.Stream.mutex.Lock()
ss.Stream.subStream = ss
ss.Stream.mutex.Unlock()
for _, ssm := range ss.medias {
for _, ssf := range ssm.formats {
ssf.initialize2(ss.Stream.firstTimeReceived, ss.Stream.lastPTS, ss.Stream.lastSystemTime)
}
}
return nil
}
// WriteUnit writes a Unit.
func (ss *SubStream) WriteUnit(medi *description.Media, forma format.Format, u *unit.Unit) {
ss.Stream.mutex.RLock()
defer ss.Stream.mutex.RUnlock()
if ss.Stream.subStream != ss {
return
}
ssm := ss.medias[medi]
ssf := ssm.formats[forma]
ssf.writeUnit(u)
}
================================================
FILE: internal/stream/sub_stream_format.go
================================================
package stream
import (
"errors"
"fmt"
"time"
"github.com/bluenviron/gortsplib/v5/pkg/format"
"github.com/bluenviron/mediamtx/internal/logger"
"github.com/bluenviron/mediamtx/internal/unit"
)
type subStreamFormat struct {
curFormat format.Format
streamFormat *streamFormat
useRTPPackets bool
rtpDecoder rtpDecoder
tempRTPEncoder rtpEncoder
tempRTPTimeOffset uint32
}
func (ssf *subStreamFormat) initialize() error {
if ssf.useRTPPackets {
var err error
ssf.rtpDecoder, err = newRTPDecoder(ssf.curFormat)
if err != nil {
return err
}
}
if ssf.streamFormat.rtpEncoder == nil && (!ssf.useRTPPackets || ssf.streamFormat.alwaysAvailable) {
var err error
ssf.tempRTPEncoder, err = newRTPEncoder(ssf.curFormat, ssf.streamFormat.rtpMaxPayloadSize, nil, nil)
if err != nil {
return err
}
ssf.tempRTPTimeOffset, err = randUint32()
if err != nil {
return err
}
}
return nil
}
func (ssf *subStreamFormat) initialize2(firstTimeReceived bool, lastPTS time.Duration, lastSystemTime time.Time) {
if ssf.tempRTPEncoder != nil {
if ssf.streamFormat.rtpEncoder == nil {
ssf.streamFormat.rtpEncoder = ssf.tempRTPEncoder
ssf.streamFormat.rtpTimeOffset = ssf.tempRTPTimeOffset
}
ssf.tempRTPEncoder = nil
ssf.tempRTPTimeOffset = 0
}
if ssf.streamFormat.alwaysAvailable {
if firstTimeReceived {
ptsOffsetGo := lastPTS + time.Since(lastSystemTime)
ssf.streamFormat.ptsOffset = multiplyAndDivide(int64(ptsOffsetGo),
int64(ssf.streamFormat.format.ClockRate()), int64(time.Second))
}
switch curFormat := ssf.curFormat.(type) {
case *format.H265:
vps, sps, pps := curFormat.SafeParams()
if vps != nil && sps != nil && pps != nil {
ssf.writeUnit(&unit.Unit{
PTS: 0,
NTP: time.Time{},
RTPPackets: nil,
Payload: unit.PayloadH265([][]byte{vps, sps, pps}),
})
}
case *format.H264:
sps, pps := curFormat.SafeParams()
if sps != nil && pps != nil {
ssf.writeUnit(&unit.Unit{
PTS: 0,
NTP: time.Time{},
RTPPackets: nil,
Payload: unit.PayloadH264([][]byte{sps, pps}),
})
}
}
}
}
func (ssf *subStreamFormat) writeUnit(u *unit.Unit) {
err := ssf.writeUnitInner(u)
if err != nil {
ssf.streamFormat.inboundFramesInError.Add(err)
return
}
}
func (ssf *subStreamFormat) writeUnitInner(u *unit.Unit) error {
if ssf.streamFormat.alwaysAvailable {
u.PTS += ssf.streamFormat.ptsOffset
ssf.streamFormat.updateLastTime(
multiplyAndDivide2(time.Duration(u.PTS),
time.Second, time.Duration(ssf.streamFormat.format.ClockRate())))
}
if ssf.streamFormat.replaceNTP {
u.NTP = ssf.streamFormat.ntpEstimator.Estimate(u.PTS)
}
if len(u.RTPPackets) != 0 {
if ssf.rtpDecoder != nil {
var err error
u.Payload, err = ssf.rtpDecoder.decode(u.RTPPackets[0])
if err != nil {
return err
}
}
if ssf.streamFormat.rtpEncoder == nil {
for _, pkt := range u.RTPPackets {
if len(pkt.Payload) > ssf.streamFormat.rtpMaxPayloadSize {
var err error
ssf.streamFormat.rtpEncoder, err = newRTPEncoder(ssf.streamFormat.format, ssf.streamFormat.rtpMaxPayloadSize,
ptrOf(pkt.SSRC), ptrOf(pkt.SequenceNumber))
if err != nil {
var err2 rtpEncoderNotAvailableError
if errors.As(err, &err2) {
return fmt.Errorf("RTP payload size (%d) is greater than maximum allowed (%d)",
len(pkt.Payload), ssf.streamFormat.rtpMaxPayloadSize)
}
return err
}
ssf.streamFormat.rtpTimeOffset = pkt.Timestamp - uint32(u.PTS)
ssf.streamFormat.parent.Log(logger.Info,
"RTP packets are too big (%d > %d), remuxing them into smaller ones",
len(pkt.Payload), ssf.streamFormat.rtpMaxPayloadSize)
break
}
}
}
if ssf.streamFormat.rtpEncoder != nil {
u.RTPPackets = nil
}
}
if !u.NilPayload() {
ssf.streamFormat.formatUpdater(ssf.streamFormat.format, u.Payload)
u.Payload = ssf.streamFormat.unitRemuxer(ssf.streamFormat.format, u.Payload)
if ssf.streamFormat.rtpEncoder != nil && !u.NilPayload() {
var err error
u.RTPPackets, err = ssf.streamFormat.rtpEncoder.encode(u.Payload)
if err != nil {
return err
}
for _, pkt := range u.RTPPackets {
pkt.Timestamp += ssf.streamFormat.rtpTimeOffset + uint32(u.PTS)
}
}
}
size := unitSize(u)
ssf.streamFormat.addInboundBytes(size)
ssf.streamFormat.writeRTSP(ssf.streamFormat.media, u.RTPPackets, u.NTP)
for sr, onData := range ssf.streamFormat.onDatas {
csr := sr
cOnData := onData
sr.push(func() error {
if !csr.SkipBytesSent {
ssf.streamFormat.addOutboundBytes(size)
}
return cOnData(u)
})
}
return nil
}
================================================
FILE: internal/stream/sub_stream_media.go
================================================
package stream
import (
"github.com/bluenviron/gortsplib/v5/pkg/description"
"github.com/bluenviron/gortsplib/v5/pkg/format"
)
type subStreamMedia struct {
curMedia *description.Media
streamMedia *streamMedia
useRTPPackets bool
formats map[format.Format]*subStreamFormat
}
func (ssm *subStreamMedia) initialize() error {
ssm.formats = make(map[format.Format]*subStreamFormat)
for i, curFormat := range ssm.curMedia.Formats {
forma := ssm.streamMedia.media.Formats[i]
ssf := &subStreamFormat{
curFormat: curFormat,
streamFormat: ssm.streamMedia.formats[forma],
useRTPPackets: ssm.useRTPPackets,
}
err := ssf.initialize()
if err != nil {
return err
}
ssm.formats[curFormat] = ssf
}
return nil
}
================================================
FILE: internal/stream/unit_remuxer.go
================================================
package stream
import (
"bytes"
"github.com/bluenviron/gortsplib/v5/pkg/format"
mch264 "github.com/bluenviron/mediacommon/v2/pkg/codecs/h264"
mch265 "github.com/bluenviron/mediacommon/v2/pkg/codecs/h265"
"github.com/bluenviron/mediacommon/v2/pkg/codecs/mpeg4video"
"github.com/bluenviron/mediamtx/internal/unit"
)
type unitRemuxer func(format.Format, unit.Payload) unit.Payload
func unitRemuxerH265(forma format.Format, payload unit.Payload) unit.Payload {
formatH265 := forma.(*format.H265)
au := payload.(unit.PayloadH265)
isKeyFrame := false
n := 0
for _, nalu := range au {
typ := mch265.NALUType((nalu[0] >> 1) & 0b111111)
switch typ {
case mch265.NALUType_VPS_NUT, mch265.NALUType_SPS_NUT, mch265.NALUType_PPS_NUT:
continue
case mch265.NALUType_AUD_NUT:
continue
case mch265.NALUType_IDR_W_RADL, mch265.NALUType_IDR_N_LP, mch265.NALUType_CRA_NUT:
if !isKeyFrame {
isKeyFrame = true
// prepend parameters
if formatH265.VPS != nil && formatH265.SPS != nil && formatH265.PPS != nil {
n += 3
}
}
}
n++
}
if n == 0 {
return unit.PayloadH265(nil)
}
filteredAU := make([][]byte, n)
i := 0
if isKeyFrame && formatH265.VPS != nil && formatH265.SPS != nil && formatH265.PPS != nil {
filteredAU[0] = formatH265.VPS
filteredAU[1] = formatH265.SPS
filteredAU[2] = formatH265.PPS
i = 3
}
for _, nalu := range au {
typ := mch265.NALUType((nalu[0] >> 1) & 0b111111)
switch typ {
case mch265.NALUType_VPS_NUT, mch265.NALUType_SPS_NUT, mch265.NALUType_PPS_NUT:
continue
case mch265.NALUType_AUD_NUT:
continue
}
filteredAU[i] = nalu
i++
}
return unit.PayloadH265(filteredAU)
}
func unitRemuxerH264(forma format.Format, payload unit.Payload) unit.Payload {
formatH264 := forma.(*format.H264)
au := payload.(unit.PayloadH264)
isKeyFrame := false
n := 0
for _, nalu := range au {
typ := mch264.NALUType(nalu[0] & 0x1F)
switch typ {
case mch264.NALUTypeSPS, mch264.NALUTypePPS:
continue
case mch264.NALUTypeAccessUnitDelimiter:
continue
case mch264.NALUTypeIDR:
if !isKeyFrame {
isKeyFrame = true
// prepend parameters
if formatH264.SPS != nil && formatH264.PPS != nil {
n += 2
}
}
}
n++
}
if n == 0 {
return unit.PayloadH264(nil)
}
filteredAU := make([][]byte, n)
i := 0
if isKeyFrame && formatH264.SPS != nil && formatH264.PPS != nil {
filteredAU[0] = formatH264.SPS
filteredAU[1] = formatH264.PPS
i = 2
}
for _, nalu := range au {
typ := mch264.NALUType(nalu[0] & 0x1F)
switch typ {
case mch264.NALUTypeSPS, mch264.NALUTypePPS:
continue
case mch264.NALUTypeAccessUnitDelimiter:
continue
}
filteredAU[i] = nalu
i++
}
return unit.PayloadH264(filteredAU)
}
func unitRemuxerMPEG4Video(forma format.Format, payload unit.Payload) unit.Payload {
formatMPEG4Video := forma.(*format.MPEG4Video)
frame := payload.(unit.PayloadMPEG4Video)
// remove config
if bytes.HasPrefix(frame, []byte{0, 0, 1, byte(mpeg4video.VisualObjectSequenceStartCode)}) {
end := bytes.Index(frame[4:], []byte{0, 0, 1, byte(mpeg4video.GroupOfVOPStartCode)})
if end >= 0 {
frame = frame[end+4:]
}
}
// add config
if bytes.Contains(frame, []byte{0, 0, 1, byte(mpeg4video.GroupOfVOPStartCode)}) {
f := make([]byte, len(formatMPEG4Video.Config)+len(frame))
n := copy(f, formatMPEG4Video.Config)
copy(f[n:], frame)
frame = f
}
if len(frame) == 0 {
return unit.PayloadMPEG4Video(nil)
}
return frame
}
func newUnitRemuxer(forma format.Format) unitRemuxer {
switch forma.(type) {
case *format.H265:
return unitRemuxerH265
case *format.H264:
return unitRemuxerH264
case *format.MPEG4Video:
return unitRemuxerMPEG4Video
default:
return unitRemuxer(func(_ format.Format, payload unit.Payload) unit.Payload {
return payload
})
}
}
================================================
FILE: internal/test/auth_manager.go
================================================
// Package test contains test utilities.
package test
import "github.com/bluenviron/mediamtx/internal/auth"
// AuthManager is a dummy auth manager.
type AuthManager struct {
AuthenticateImpl func(req *auth.Request) (string, *auth.Error)
RefreshJWTJWKSImpl func()
}
// Authenticate replicates auth.Manager.Authenticate.
func (m *AuthManager) Authenticate(req *auth.Request) (string, *auth.Error) {
return m.AuthenticateImpl(req)
}
// RefreshJWTJWKS is a function that simulates a JWKS refresh.
func (m *AuthManager) RefreshJWTJWKS() {
m.RefreshJWTJWKSImpl()
}
// NilAuthManager is an auth manager that accepts everything.
var NilAuthManager = &AuthManager{
AuthenticateImpl: func(_ *auth.Request) (string, *auth.Error) {
return "", nil
},
}
================================================
FILE: internal/test/formats.go
================================================
package test
import (
"github.com/bluenviron/gortsplib/v5/pkg/format"
"github.com/bluenviron/mediacommon/v2/pkg/codecs/mpeg4audio"
)
// FormatH264 is a dummy H264 format.
var FormatH264 = &format.H264{
PayloadTyp: 96,
SPS: []byte{ // 1920x1080 baseline
0x67, 0x42, 0xc0, 0x28, 0xd9, 0x00, 0x78, 0x02,
0x27, 0xe5, 0x84, 0x00, 0x00, 0x03, 0x00, 0x04,
0x00, 0x00, 0x03, 0x00, 0xf0, 0x3c, 0x60, 0xc9, 0x20,
},
PPS: []byte{0x08, 0x06, 0x07, 0x08},
PacketizationMode: 1,
}
// FormatH265 is a dummy H265 format.
var FormatH265 = &format.H265{
PayloadTyp: 96,
VPS: []byte{
0x40, 0x01, 0x0c, 0x01, 0xff, 0xff, 0x02, 0x20,
0x00, 0x00, 0x03, 0x00, 0xb0, 0x00, 0x00, 0x03,
0x00, 0x00, 0x03, 0x00, 0x7b, 0x18, 0xb0, 0x24,
},
SPS: []byte{
0x42, 0x01, 0x01, 0x02, 0x20, 0x00, 0x00, 0x03,
0x00, 0xb0, 0x00, 0x00, 0x03, 0x00, 0x00, 0x03,
0x00, 0x7b, 0xa0, 0x07, 0x82, 0x00, 0x88, 0x7d,
0xb6, 0x71, 0x8b, 0x92, 0x44, 0x80, 0x53, 0x88,
0x88, 0x92, 0xcf, 0x24, 0xa6, 0x92, 0x72, 0xc9,
0x12, 0x49, 0x22, 0xdc, 0x91, 0xaa, 0x48, 0xfc,
0xa2, 0x23, 0xff, 0x00, 0x01, 0x00, 0x01, 0x6a,
0x02, 0x02, 0x02, 0x01,
},
PPS: []byte{
0x44, 0x01, 0xc0, 0x25, 0x2f, 0x05, 0x32, 0x40,
},
}
// FormatMPEG4Audio is a dummy MPEG-4 audio format.
var FormatMPEG4Audio = &format.MPEG4Audio{
PayloadTyp: 96,
Config: &mpeg4audio.AudioSpecificConfig{
Type: 2,
SampleRate: 44100,
ChannelCount: 2,
ChannelConfig: 2,
},
SizeLength: 13,
IndexLength: 3,
IndexDeltaLength: 3,
}
================================================
FILE: internal/test/logger.go
================================================
package test
import "github.com/bluenviron/mediamtx/internal/logger"
type nilLogger struct{}
func (nilLogger) Log(_ logger.Level, _ string, _ ...any) {
}
// NilLogger is a logger to /dev/null
var NilLogger logger.Writer = &nilLogger{}
type testLogger struct {
cb func(level logger.Level, format string, args ...any)
}
func (l *testLogger) Log(level logger.Level, format string, args ...any) {
l.cb(level, format, args...)
}
// Logger returns a dummy logger.
func Logger(cb func(logger.Level, string, ...any)) logger.Writer {
return &testLogger{cb: cb}
}
================================================
FILE: internal/test/medias.go
================================================
package test
import (
"github.com/bluenviron/gortsplib/v5/pkg/description"
"github.com/bluenviron/gortsplib/v5/pkg/format"
)
// MediaH264 is a dummy H264 media.
var MediaH264 = UniqueMediaH264()
// MediaMPEG4Audio is a dummy MPEG-4 audio media.
var MediaMPEG4Audio = UniqueMediaMPEG4Audio()
// UniqueMediaH264 is a dummy H264 media.
func UniqueMediaH264() *description.Media {
return &description.Media{
Type: description.MediaTypeVideo,
Formats: []format.Format{FormatH264},
}
}
// UniqueMediaMPEG4Audio is a dummy MPEG-4 audio media.
func UniqueMediaMPEG4Audio() *description.Media {
return &description.Media{
Type: description.MediaTypeAudio,
Formats: []format.Format{FormatMPEG4Audio},
}
}
================================================
FILE: internal/test/path_manager.go
================================================
package test
import (
"github.com/bluenviron/mediamtx/internal/defs"
)
// PathManager is a dummy path manager.
type PathManager struct {
FindPathConfImpl func(req defs.PathFindPathConfReq) (*defs.PathFindPathConfRes, error)
DescribeImpl func(req defs.PathDescribeReq) defs.PathDescribeRes
AddPublisherImpl func(req defs.PathAddPublisherReq) (*defs.PathAddPublisherRes, error)
AddReaderImpl func(req defs.PathAddReaderReq) (*defs.PathAddReaderRes, error)
}
// FindPathConf implements PathManager.
func (pm *PathManager) FindPathConf(req defs.PathFindPathConfReq) (*defs.PathFindPathConfRes, error) {
return pm.FindPathConfImpl(req)
}
// Describe implements PathManager.
func (pm *PathManager) Describe(req defs.PathDescribeReq) defs.PathDescribeRes {
return pm.DescribeImpl(req)
}
// AddPublisher implements PathManager.
func (pm *PathManager) AddPublisher(req defs.PathAddPublisherReq) (*defs.PathAddPublisherRes, error) {
return pm.AddPublisherImpl(req)
}
// AddReader implements PathManager.
func (pm *PathManager) AddReader(req defs.PathAddReaderReq) (*defs.PathAddReaderRes, error) {
return pm.AddReaderImpl(req)
}
================================================
FILE: internal/test/static_source_parent.go
================================================
package test
import (
"github.com/bluenviron/mediamtx/internal/defs"
"github.com/bluenviron/mediamtx/internal/logger"
"github.com/bluenviron/mediamtx/internal/stream"
"github.com/bluenviron/mediamtx/internal/unit"
)
// StaticSourceParent is a dummy static source parent.
type StaticSourceParent struct {
stream *stream.Stream
reader *stream.Reader
Unit chan *unit.Unit
}
// Log implements logger.Writer.
func (*StaticSourceParent) Log(logger.Level, string, ...any) {}
// Initialize initializes StaticSourceParent.
func (p *StaticSourceParent) Initialize() {
p.Unit = make(chan *unit.Unit)
}
// Close closes StaticSourceParent.
func (p *StaticSourceParent) Close() {
p.stream.RemoveReader(p.reader)
}
// SetReady implements parent.
func (p *StaticSourceParent) SetReady(req defs.PathSourceStaticSetReadyReq) defs.PathSourceStaticSetReadyRes {
p.stream = &stream.Stream{
Desc: req.Desc,
WriteQueueSize: 512,
RTPMaxPayloadSize: 1450,
ReplaceNTP: req.ReplaceNTP,
Parent: p,
}
err := p.stream.Initialize()
if err != nil {
panic(err)
}
subStream := &stream.SubStream{
Stream: p.stream,
UseRTPPackets: req.UseRTPPackets,
}
err = subStream.Initialize()
if err != nil {
panic("should not happen")
}
p.reader = &stream.Reader{Parent: NilLogger}
p.reader.OnData(
req.Desc.Medias[0],
req.Desc.Medias[0].Formats[0],
func(u *unit.Unit) error {
p.Unit <- u
close(p.Unit)
return nil
})
p.stream.AddReader(p.reader)
return defs.PathSourceStaticSetReadyRes{SubStream: subStream}
}
// SetNotReady implements parent.
func (StaticSourceParent) SetNotReady(_ defs.PathSourceStaticSetNotReadyReq) {}
================================================
FILE: internal/test/temp_file.go
================================================
package test
import "os"
// CreateTempFile creates a temporary file with given content.
func CreateTempFile(byts []byte) (string, error) {
tmpf, err := os.CreateTemp(os.TempDir(), "rtsp-")
if err != nil {
return "", err
}
defer tmpf.Close()
_, err = tmpf.Write(byts)
if err != nil {
return "", err
}
return tmpf.Name(), nil
}
================================================
FILE: internal/test/tls_cert.go
================================================
package test
// TLSCertPub is the public key of a dummy certificate.
var TLSCertPub = []byte(`-----BEGIN CERTIFICATE-----
MIIDazCCAlOgAwIBAgIUXw1hEC3LFpTsllv7D3ARJyEq7sIwDQYJKoZIhvcNAQEL
BQAwRTELMAkGA1UEBhMCQVUxEzARBgNVBAgMClNvbWUtU3RhdGUxITAfBgNVBAoM
GEludGVybmV0IFdpZGdpdHMgUHR5IEx0ZDAeFw0yMDEyMTMxNzQ0NThaFw0zMDEy
MTExNzQ0NThaMEUxCzAJBgNVBAYTAkFVMRMwEQYDVQQIDApTb21lLVN0YXRlMSEw
HwYDVQQKDBhJbnRlcm5ldCBXaWRnaXRzIFB0eSBMdGQwggEiMA0GCSqGSIb3DQEB
AQUAA4IBDwAwggEKAoIBAQDG8DyyS51810GsGwgWr5rjJK7OE1kTTLSNEEKax8Bj
zOyiaz8rA2JGl2VUEpi2UjDr9Cm7nd+YIEVs91IIBOb7LGqObBh1kGF3u5aZxLkv
NJE+HrLVvUhaDobK2NU+Wibqc/EI3DfUkt1rSINvv9flwTFu1qHeuLWhoySzDKEp
OzYxpFhwjVSokZIjT4Red3OtFz7gl2E6OAWe2qoh5CwLYVdMWtKR0Xuw3BkDPk9I
qkQKx3fqv97LPEzhyZYjDT5WvGrgZ1WDAN3booxXF3oA1H3GHQc4m/vcLatOtb8e
nI59gMQLEbnp08cl873bAuNuM95EZieXTHNbwUnq5iybAgMBAAGjUzBRMB0GA1Ud
DgQWBBQBKhJh8eWu0a4au9X/2fKhkFX2vjAfBgNVHSMEGDAWgBQBKhJh8eWu0a4a
u9X/2fKhkFX2vjAPBgNVHRMBAf8EBTADAQH/MA0GCSqGSIb3DQEBCwUAA4IBAQBj
3aCW0YPKukYgVK9cwN0IbVy/D0C1UPT4nupJcy/E0iC7MXPZ9D/SZxYQoAkdptdO
xfI+RXkpQZLdODNx9uvV+cHyZHZyjtE5ENu/i5Rer2cWI/mSLZm5lUQyx+0KZ2Yu
tEI1bsebDK30msa8QSTn0WidW9XhFnl3gRi4wRdimcQapOWYVs7ih+nAlSvng7NI
XpAyRs8PIEbpDDBMWnldrX4TP6EWYUi49gCp8OUDRREKX3l6Ls1vZ02F34yHIt/7
7IV/XSKG096bhW+icKBWV0IpcEsgTzPK1J1hMxgjhzIMxGboAeUU+kidthOob6Sd
XQxaORfgM//NzX9LhUPk
-----END CERTIFICATE-----
`)
// TLSCertKey is the private key of a dummy certificate.
var TLSCertKey = []byte(`-----BEGIN RSA PRIVATE KEY-----
MIIEogIBAAKCAQEAxvA8skudfNdBrBsIFq+a4ySuzhNZE0y0jRBCmsfAY8zsoms/
KwNiRpdlVBKYtlIw6/Qpu53fmCBFbPdSCATm+yxqjmwYdZBhd7uWmcS5LzSRPh6y
1b1IWg6GytjVPlom6nPxCNw31JLda0iDb7/X5cExbtah3ri1oaMkswyhKTs2MaRY
cI1UqJGSI0+EXndzrRc+4JdhOjgFntqqIeQsC2FXTFrSkdF7sNwZAz5PSKpECsd3
6r/eyzxM4cmWIw0+Vrxq4GdVgwDd26KMVxd6ANR9xh0HOJv73C2rTrW/HpyOfYDE
CxG56dPHJfO92wLjbjPeRGYnl0xzW8FJ6uYsmwIDAQABAoIBACi0BKcyQ3HElSJC
kaAao+Uvnzh4yvPg8Nwf5JDIp/uDdTMyIEWLtrLczRWrjGVZYbsVROinP5VfnPTT
kYwkfKINj2u+gC6lsNuPnRuvHXikF8eO/mYvCTur1zZvsQnF5kp4GGwIqr+qoPUP
bB0UMndG1PdpoMryHe+JcrvTrLHDmCeH10TqOwMsQMLHYLkowvxwJWsmTY7/Qr5S
Wm3PPpOcW2i0uyPVuyuv4yD1368fqnqJ8QFsQp1K6QtYsNnJ71Hut1/IoxK/e6hj
5Z+byKtHVtmcLnABuoOT7BhleJNFBksX9sh83jid4tMBgci+zXNeGmgqo2EmaWAb
agQslkECgYEA8B1rzjOHVQx/vwSzDa4XOrpoHQRfyElrGNz9JVBvnoC7AorezBXQ
M9WTHQIFTGMjzD8pb+YJGi3gj93VN51r0SmJRxBaBRh1ZZI9kFiFzngYev8POgD3
ygmlS3kTHCNxCK/CJkB+/jMBgtPj5ygDpCWVcTSuWlQFphePkW7jaaECgYEA1Blz
ulqgAyJHZaqgcbcCsI2q6m527hVr9pjzNjIVmkwu38yS9RTCgdlbEVVDnS0hoifl
+jVMEGXjF3xjyMvL50BKbQUH+KAa+V4n1WGlnZOxX9TMny8MBjEuSX2+362vQ3BX
4vOlX00gvoc+sY+lrzvfx/OdPCHQGVYzoKCxhLsCgYA07HcviuIAV/HsO2/vyvhp
xF5gTu+BqNUHNOZDDDid+ge+Jre2yfQLCL8VPLXIQW3Jff53IH/PGl+NtjphuLvj
7UDJvgvpZZuymIojP6+2c3gJ3CASC9aR3JBnUzdoE1O9s2eaoMqc4scpe+SWtZYf
3vzSZ+cqF6zrD/Rf/M35IQKBgHTU4E6ShPm09CcoaeC5sp2WK8OevZw/6IyZi78a
r5Oiy18zzO97U/k6xVMy6F+38ILl/2Rn31JZDVJujniY6eSkIVsUHmPxrWoXV1HO
y++U32uuSFiXDcSLarfIsE992MEJLSAynbF1Rsgsr3gXbGiuToJRyxbIeVy7gwzD
94TpAoGAY4/PejWQj9psZfAhyk5dRGra++gYRQ/gK1IIc1g+Dd2/BxbT/RHr05GK
6vwrfjsoRyMWteC1SsNs/CurjfQ/jqCfHNP5XPvxgd5Ec8sRJIiV7V5RTuWJsPu1
+3K6cnKEyg+0ekYmLertRFIY6SwWmY1fyKgTvxudMcsBY7dC4xs=
-----END RSA PRIVATE KEY-----
`)
// TLSCertPubAlt is the public key of an alternative dummy certificate.
var TLSCertPubAlt = []byte(`-----BEGIN CERTIFICATE-----
MIIDSTCCAjECFEut6ZxIOnbxi3bhrPLfPQZCLReNMA0GCSqGSIb3DQEBCwUAMGEx
CzAJBgNVBAYTAkFVMRMwEQYDVQQIDApTb21lLVN0YXRlMSEwHwYDVQQKDBhJbnRl
cm5ldCBXaWRnaXRzIFB0eSBMdGQxGjAYBgNVBAMMEW1lZGlhbXR4LnRlc3QuY29t
MB4XDTI0MDgwMTIzNDY0MloXDTM0MDczMDIzNDY0MlowYTELMAkGA1UEBhMCQVUx
EzARBgNVBAgMClNvbWUtU3RhdGUxITAfBgNVBAoMGEludGVybmV0IFdpZGdpdHMg
UHR5IEx0ZDEaMBgGA1UEAwwRbWVkaWFtdHgudGVzdC5jb20wggEiMA0GCSqGSIb3
DQEBAQUAA4IBDwAwggEKAoIBAQCzfvG9eLXKSTDBoM+cgV/ThiNRI2JY6dpQV8rK
QFQ5bkkDUDP+2Ae/IWylgLLXmozsMwjz1Pu42awmGymBuo5HDbI4bxPJNQR9qRrR
2+MvfDgmZxyhw5NfZDlVl+enxhb3FRgbHsLBy4oSoHbRUdLApVdM0Kg6r3bXzkih
EEs63boFJOkPhs5H0NX7AzXyBp2WnvB71j+7avnMwAsjJHOiTs8wkp5wvRcIZpJl
MCandUkcZShMirug7QOcR9fAr5CVKxsO/DjqEjwkslJHFfizOl3yRx6nsxvW8JUd
dforpSRj84dkHTi7k37YTiji90GsOvh0qc0MfAmeE181HIb/AgMBAAEwDQYJKoZI
hvcNAQELBQADggEBAEWkLL/7nvt3iD7BVJNHLvAS6GwuTH99vCil6TFYwVl4goht
Dur7YfzN43vUq+lAwS3Ry4ka7tH72pAMkpNFRvHOikWGmWUSDo2DcLd8iu3ruLF7
yUg2ASQuekK0sUv4YKpAqV8gS2R4Jh4vLU+8L5iJ1XWGELbQ+H5wm4l7l+r2X6cD
/opmdV8Slfi0FlNQtflLsGoSlfZF5jHxqi3zyt8QdEf9WZt8e6JPxcx2Fq7Op51u
Qx9nosr5fLwhkx46+B/cotsbI/xPDjLF6RQ1OUpcHwg1HI6czoW4hHn33S0zstCf
BWt5Q1Mb2tGInbmbUgw3wUu/4nWoY+Mq4DKPlKs=
-----END CERTIFICATE-----`)
// TLSCertKeyAlt is the private key of an alternative dummy certificate.
var TLSCertKeyAlt = []byte(`-----BEGIN RSA PRIVATE KEY-----
MIIEoQIBAAKCAQEAs37xvXi1ykkwwaDPnIFf04YjUSNiWOnaUFfKykBUOW5JA1Az
/tgHvyFspYCy15qM7DMI89T7uNmsJhspgbqORw2yOG8TyTUEfaka0dvjL3w4Jmcc
ocOTX2Q5VZfnp8YW9xUYGx7CwcuKEqB20VHSwKVXTNCoOq92185IoRBLOt26BSTp
D4bOR9DV+wM18gadlp7we9Y/u2r5zMALIyRzok7PMJKecL0XCGaSZTAmp3VJHGUo
TIq7oO0DnEfXwK+QlSsbDvw46hI8JLJSRxX4szpd8kcep7Mb1vCVHXX6K6UkY/OH
ZB04u5N+2E4o4vdBrDr4dKnNDHwJnhNfNRyG/wIDAQABAoH/WmCqV6Lv5dEnofCj
ZUO/Fdv0hf/LBS0g2SAoFRSCIM8aJ3dUUH0PaXoeINDGCMlIxT7tKXJg5jJNYhWx
g7oegw6vLe5ZiA+p5miL/uue+Jas4kLVp9DrfQLgQevt0gw4g/00pgy9adbFlTUD
a2HhPB7RIvXs8gYA6nVAT9jK1ST2pbeUgQNO4Ji4EjpPUkR2O7ISOlu5EV8Cj0eV
1Vs5B92Z7ORh7P2fFV2YBu+igd04+uYvei6slQl+F9cETvJv2Z9r37Yashvnn1in
uy/u1U4B1t4oOz81nHz6kxTixPpBOdJ6x8jLDgNGSsauJQfXT9xmB/rAr/NFq+7I
tbTNAoGBAMOgm3XXHWokmJnX9pfNj6ixNlrMuuez/yXMVwuxa2WFwAFN16tjJhBi
XOjestcvu/SRhOAMmYac5QdopJpLjO/FxO165r73eZhW/SJefyOHtfD29kHagA1u
JjcznU6tiA0O1owy6nuuaTfyVbDQj32PhVBx9ZwSI4778GFbjWl7AoGBAOrj4WCC
gTMaExpwNo+L+3VkM79YD1Obl13FcgtVoxjcoWjQeMx9D0k7adTV3xlchHFAjiD5
Gs/MZl8+seq+GDX3mODsmJkdRQbYId4g6IesiOnQ3Ug/Y282WZRnpB5h/BMnrcCZ
VoohnATA7f96c7XtPUgZyROmh24T7UIVwVdNAoGAbeeGT276TI6g2RWWqXRIOFrP
EbYhb1kViFPDt4MGtjOtSk5EUzpRwTSxw/aRfQmJS/6RKxqJCjKNDVuB1lmJpY9z
coPwrOr1+lssvalfPkPZOLZWZWrvNBxlBfBOeUxOuh9S89MLH08+N7tC3yJc6wq9
uBM+DF+4cHUkeF3qFY8CgYBzS+IwBj82/0CLRLNzaKnIqKPB846qYoA9NhLRv3ps
VLgiA9qXvXdIYhKDt2toPoKAOMjLJJtljpZdgB/C8wZdTyjKlzgcSEK+pk6RgyPA
nQ8jfjNwKDU9vLbh4rGrfDtIh7yBAoN5ECBOMQlh0xCDJ21iO834iFCH1t4qBxW9
LQKBgQC36adC2Gu+FJRvx4Mkm73fLmVdFbP6Do7qNwyVVyaG80PDVrFQrlWm4Dt7
AO9IwzaS1Lx+qmU1Fj1WfCtXuQa5nc9AzZ36TmM6+pAn8AC7PdNqc0qSdefVrIjj
zRGhUPaJV3A+sfO+xedBsAFnqNuX9oODYVGbTjuc2OWC30MGaw==
-----END RSA PRIVATE KEY-----
`)
================================================
FILE: internal/teste2e/build_images_test.go
================================================
//go:build enable_e2e_tests
package teste2e
import (
"os"
"os/exec"
"path/filepath"
"testing"
"github.com/stretchr/testify/require"
)
func buildImage(image string) error {
ecmd := exec.Command("docker", "build", filepath.Join("images", image),
"-t", "mediamtx-test-"+image)
ecmd.Stdout = nil
ecmd.Stderr = os.Stderr
return ecmd.Run()
}
func TestBuildImages(t *testing.T) {
files, err := os.ReadDir("images")
require.NoError(t, err)
for _, file := range files {
err := buildImage(file.Name())
require.NoError(t, err)
}
}
================================================
FILE: internal/teste2e/hls_manager_test.go
================================================
//go:build enable_e2e_tests
package teste2e
import (
"net/http"
"testing"
"time"
"github.com/stretchr/testify/require"
)
func TestHLSServerRead(t *testing.T) {
p, ok := newInstance("paths:\n" +
" all_others:\n")
require.Equal(t, true, ok)
defer p.Close()
cnt1, err := newContainer("ffmpeg", "source", []string{
"-re",
"-stream_loop", "-1",
"-i", "emptyvideo.mkv",
"-c", "copy",
"-f", "rtsp",
"rtsp://127.0.0.1:8554/test/stream",
})
require.NoError(t, err)
defer cnt1.close()
time.Sleep(1 * time.Second)
cnt2, err := newContainer("ffmpeg", "dest", []string{
"-i", "http://127.0.0.1:8888/test/stream/index.m3u8",
"-vframes", "1",
"-f", "image2",
"-y", "/dev/null",
})
require.NoError(t, err)
defer cnt2.close()
require.Equal(t, 0, cnt2.wait())
}
func TestHLSServerAuth(t *testing.T) {
for _, result := range []string{
"success",
"fail",
} {
t.Run(result, func(t *testing.T) {
cnf := "paths:\n" +
" all_others:\n" +
" readUser: testreader\n" +
" readPass: testpass\n" +
" readIPs: [127.0.0.0/16]\n"
p, ok := newInstance(cnf)
require.Equal(t, true, ok)
defer p.Close()
cnt1, err := newContainer("ffmpeg", "source", []string{
"-re",
"-stream_loop", "-1",
"-i", "emptyvideo.mkv",
"-c", "copy",
"-f", "rtsp",
"rtsp://testpublisher:testpass@127.0.0.1:8554/teststream?param=value",
})
require.NoError(t, err)
defer cnt1.close()
time.Sleep(1 * time.Second)
var usr string
if result == "success" {
usr = "testreader"
} else {
usr = "testreader2"
}
tr := &http.Transport{}
defer tr.CloseIdleConnections()
hc := &http.Client{Transport: tr}
res, err := hc.Get("http://" + usr + ":testpass@127.0.0.1:8888/teststream/index.m3u8?param=value")
require.NoError(t, err)
defer res.Body.Close()
if result == "success" {
require.Equal(t, http.StatusOK, res.StatusCode)
} else {
require.Equal(t, http.StatusUnauthorized, res.StatusCode)
}
})
}
}
================================================
FILE: internal/teste2e/images/ffmpeg/Dockerfile
================================================
FROM amd64/alpine:3.14
RUN apk add --no-cache \
ffmpeg
COPY *.mkv /
COPY start.sh /
RUN chmod +x /start.sh
ENTRYPOINT [ "/start.sh" ]
================================================
FILE: internal/teste2e/images/ffmpeg/start.sh
================================================
#!/bin/sh -e
exec ffmpeg -hide_banner -loglevel error $@ 2>&1
================================================
FILE: internal/teste2e/images/gstreamer/Dockerfile
================================================
######################################
FROM ubuntu:20.04 AS build
RUN apt update && apt install -y --no-install-recommends \
pkg-config \
gcc \
libgstreamer-plugins-base1.0-dev \
&& rm -rf /var/lib/apt/lists/*
COPY exitafterframe.c /s/
RUN cd /s \
&& gcc \
exitafterframe.c \
-o libexitafterframe.so \
-Ofast \
-s \
-Werror \
-Wall \
-Wextra \
-Wno-unused-parameter \
-fPIC \
-shared \
-Wl,--no-undefined \
$(pkg-config --cflags --libs gstreamer-1.0) \
&& mv libexitafterframe.so /usr/lib/x86_64-linux-gnu/gstreamer-1.0/ \
&& rm -rf /s
######################################
FROM ubuntu:20.04
RUN apt update && apt install -y --no-install-recommends \
gstreamer1.0-tools \
gstreamer1.0-plugins-good \
gstreamer1.0-plugins-bad \
gstreamer1.0-rtsp \
gstreamer1.0-libav \
&& rm -rf /var/lib/apt/lists/*
COPY --from=build /usr/lib/x86_64-linux-gnu/gstreamer-1.0/libexitafterframe.so /usr/lib/x86_64-linux-gnu/gstreamer-1.0/
COPY emptyvideo.mkv /
COPY start.sh /
RUN chmod +x /start.sh
ENTRYPOINT [ "/start.sh" ]
================================================
FILE: internal/teste2e/images/gstreamer/exitafterframe.c
================================================
#include
GType gst_exitafterframe_get_type ();
#define GST_TYPE_EXITAFTERFRAME (gst_exitafterframe_get_type())
#define GST_EXITAFTERFRAME(obj) (G_TYPE_CHECK_INSTANCE_CAST((obj),GST_TYPE_EXITAFTERFRAME,GstExitAfterFrame))
typedef struct
{
GstElement element;
GstPad *srcpad;
GstPad *sinkpad;
} GstExitAfterFrame;
typedef struct
{
GstElementClass parent_class;
} GstExitAfterFrameClass;
#define gst_exitafterframe_parent_class parent_class
G_DEFINE_TYPE (GstExitAfterFrame, gst_exitafterframe, GST_TYPE_ELEMENT);
static GstStaticPadTemplate sink_factory = GST_STATIC_PAD_TEMPLATE(
"sink",
GST_PAD_SINK,
GST_PAD_ALWAYS,
GST_STATIC_CAPS("video/x-raw")
);
static GstStaticPadTemplate src_factory = GST_STATIC_PAD_TEMPLATE(
"src",
GST_PAD_SRC,
GST_PAD_ALWAYS,
GST_STATIC_CAPS("video/x-raw")
);
static GstFlowReturn
gst_exitafterframe_chain (GstPad * pad, GstObject * parent, GstBuffer * buf)
{
GstExitAfterFrame *filter = GST_EXITAFTERFRAME (parent);
exit(0);
return gst_pad_push (filter->srcpad, buf);
}
static void
gst_exitafterframe_class_init(GstExitAfterFrameClass* klass) {
GstElementClass* element_class = (GstElementClass*)klass;
gst_element_class_set_details_simple(
element_class,
"Plugin",
"FIXME:Generic",
"FIXME:Generic Template Element",
"AUTHOR_NAME AUTHOR_EMAIL"
);
gst_element_class_add_pad_template(element_class,
gst_static_pad_template_get(&src_factory));
gst_element_class_add_pad_template(element_class,
gst_static_pad_template_get(&sink_factory));
}
static void
gst_exitafterframe_init (GstExitAfterFrame* filter)
{
GstElement* element = GST_ELEMENT(filter);
filter->sinkpad = gst_pad_new_from_static_template(&sink_factory, "sink");
gst_pad_set_chain_function(filter->sinkpad, gst_exitafterframe_chain);
GST_PAD_SET_PROXY_CAPS(filter->sinkpad);
gst_element_add_pad(element, filter->sinkpad);
filter->srcpad = gst_pad_new_from_static_template(&src_factory, "src");
GST_PAD_SET_PROXY_CAPS(filter->srcpad);
gst_element_add_pad(element, filter->srcpad);
}
static gboolean
plugin_init (GstPlugin * plugin)
{
return gst_element_register (plugin, "exitafterframe", GST_RANK_NONE,
GST_TYPE_EXITAFTERFRAME);
}
#define PACKAGE "exitafterframe"
GST_PLUGIN_DEFINE (GST_VERSION_MAJOR, GST_VERSION_MINOR, exitafterframe,
"exitafterframe", plugin_init, "1.0", "LGPL", "exitafterframe",
"http://example.com")
================================================
FILE: internal/teste2e/images/gstreamer/start.sh
================================================
#!/bin/sh -e
exec gst-launch-1.0 $@ 2>&1
================================================
FILE: internal/teste2e/images/vlc/Dockerfile
================================================
FROM amd64/alpine:3.14
RUN apk add --no-cache \
vlc
RUN adduser -D -H -s /bin/sh -u 9337 user
COPY start.sh /
RUN chmod +x /start.sh
RUN mkdir /out \
&& chown user:user /out
USER user
ENTRYPOINT [ "/start.sh" ]
================================================
FILE: internal/teste2e/images/vlc/start.sh
================================================
#!/bin/sh -e
cvlc --play-and-exit --no-audio --no-video --sout file/ts:/out/stream.ts -vvv $@ 2>&1 &
COUNTER=0
while true; do
sleep 1
if [ $(stat -c "%s" /out/stream.ts) -gt 0 ]; then
exit 0
fi
COUNTER=$(($COUNTER + 1))
if [ $COUNTER -ge 15 ]; then
exit 1
fi
done
================================================
FILE: internal/teste2e/rtsp_server_test.go
================================================
//go:build enable_e2e_tests
package teste2e
import (
"os"
"testing"
"time"
"github.com/bluenviron/mediamtx/internal/test"
"github.com/stretchr/testify/require"
)
func TestRTSPServerPublishRead(t *testing.T) {
for _, ca := range []struct {
publisherSoft string
publisherProto string
readerSoft string
readerProto string
}{
{"ffmpeg", "udp", "ffmpeg", "udp"},
{"ffmpeg", "udp", "ffmpeg", "multicast"},
{"ffmpeg", "udp", "ffmpeg", "tcp"},
{"ffmpeg", "udp", "gstreamer", "udp"},
{"ffmpeg", "udp", "gstreamer", "multicast"},
{"ffmpeg", "udp", "gstreamer", "tcp"},
{"ffmpeg", "udp", "vlc", "udp"},
{"ffmpeg", "udp", "vlc", "multicast"},
{"ffmpeg", "udp", "vlc", "tcp"},
{"ffmpeg", "tcp", "ffmpeg", "udp"},
{"gstreamer", "udp", "ffmpeg", "udp"},
{"gstreamer", "tcp", "ffmpeg", "udp"},
{"ffmpeg", "tls", "ffmpeg", "tls"},
{"ffmpeg", "tls", "gstreamer", "tls"},
{"gstreamer", "tls", "ffmpeg", "tls"},
} {
t.Run(ca.publisherSoft+"_"+ca.publisherProto+"_"+
ca.readerSoft+"_"+ca.readerProto, func(t *testing.T) {
var proto string
var port string
if ca.publisherProto != "tls" {
proto = "rtsp"
port = "8554"
p, ok := newInstance("rtmp: no\n" +
"hls: no\n" +
"webrtc: no\n" +
"readTimeout: 20s\n" +
"paths:\n" +
" all_others:\n")
require.Equal(t, true, ok)
defer p.Close()
} else {
proto = "rtsps"
port = "8322"
serverCertFpath, err := test.CreateTempFile(test.TLSCertPub)
require.NoError(t, err)
defer os.Remove(serverCertFpath)
serverKeyFpath, err := test.CreateTempFile(test.TLSCertKey)
require.NoError(t, err)
defer os.Remove(serverKeyFpath)
p, ok := newInstance("rtmp: no\n" +
"hls: no\n" +
"webrtc: no\n" +
"readTimeout: 20s\n" +
"rtspTransports: [tcp]\n" +
"rtspEncryption: \"yes\"\n" +
"rtspServerCert: " + serverCertFpath + "\n" +
"rtspServerKey: " + serverKeyFpath + "\n" +
"paths:\n" +
" all_others:\n")
require.Equal(t, true, ok)
defer p.Close()
}
switch ca.publisherSoft {
case "ffmpeg":
ps := func() string {
switch ca.publisherProto {
case "udp", "tcp":
return ca.publisherProto
default: // tls
return "tcp"
}
}()
cnt1, err := newContainer("ffmpeg", "source", []string{
"-re",
"-stream_loop", "-1",
"-i", "emptyvideo.mkv",
"-c", "copy",
"-f", "rtsp",
"-rtsp_transport",
ps,
proto + "://localhost:" + port + "/teststream",
})
require.NoError(t, err)
defer cnt1.close()
time.Sleep(1 * time.Second)
case "gstreamer":
ps := func() string {
switch ca.publisherProto {
case "udp", "tcp":
return ca.publisherProto
default: // tls
return "tcp"
}
}()
cnt1, err := newContainer("gstreamer", "source", []string{
"filesrc location=emptyvideo.mkv ! matroskademux ! video/x-h264 ! rtspclientsink " +
"location=" + proto + "://localhost:" + port + "/teststream " +
"protocols=" + ps + " tls-validation-flags=0 latency=0 timeout=0 rtx-time=0",
})
require.NoError(t, err)
defer cnt1.close()
time.Sleep(1 * time.Second)
}
time.Sleep(1 * time.Second)
switch ca.readerSoft {
case "ffmpeg":
ps := func() string {
switch ca.readerProto {
case "udp", "tcp":
return ca.publisherProto
case "multicast":
return "udp_multicast"
default: // tls
return "tcp"
}
}()
cnt2, err := newContainer("ffmpeg", "dest", []string{
"-rtsp_transport", ps,
"-i", proto + "://localhost:" + port + "/teststream",
"-vframes", "1",
"-f", "image2",
"-y", "/dev/null",
})
require.NoError(t, err)
defer cnt2.close()
require.Equal(t, 0, cnt2.wait())
case "gstreamer":
ps := func() string {
switch ca.readerProto {
case "udp", "tcp":
return ca.publisherProto
case "multicast":
return "udp-mcast"
default: // tls
return "tcp"
}
}()
cnt2, err := newContainer("gstreamer", "read", []string{
"rtspsrc location=" + proto + "://127.0.0.1:" + port + "/teststream " +
"protocols=" + ps + " " +
"tls-validation-flags=0 latency=0 " +
"! application/x-rtp,media=video ! decodebin ! exitafterframe ! fakesink",
})
require.NoError(t, err)
defer cnt2.close()
require.Equal(t, 0, cnt2.wait())
case "vlc":
args := []string{}
if ca.readerProto == "tcp" {
args = append(args, "--rtsp-tcp")
}
ur := proto + "://localhost:" + port + "/teststream"
if ca.readerProto == "multicast" {
ur += "?vlcmulticast"
}
args = append(args, ur)
cnt2, err := newContainer("vlc", "dest", args)
require.NoError(t, err)
defer cnt2.close()
require.Equal(t, 0, cnt2.wait())
}
})
}
}
func TestRTSPServerRedirect(t *testing.T) {
p1, ok := newInstance("rtmp: no\n" +
"hls: no\n" +
"webrtc: no\n" +
"paths:\n" +
" path1:\n" +
" source: redirect\n" +
" sourceRedirect: rtsp://localhost:8554/path2\n" +
" path2:\n")
require.Equal(t, true, ok)
defer p1.Close()
cnt1, err := newContainer("ffmpeg", "source", []string{
"-re",
"-stream_loop", "-1",
"-i", "emptyvideo.mkv",
"-c", "copy",
"-f", "rtsp",
"-rtsp_transport", "udp",
"rtsp://localhost:8554/path2",
})
require.NoError(t, err)
defer cnt1.close()
time.Sleep(1 * time.Second)
cnt2, err := newContainer("ffmpeg", "dest", []string{
"-rtsp_transport", "udp",
"-i", "rtsp://localhost:8554/path1",
"-vframes", "1",
"-f", "image2",
"-y", "/dev/null",
})
require.NoError(t, err)
defer cnt2.close()
require.Equal(t, 0, cnt2.wait())
}
================================================
FILE: internal/teste2e/tests_test.go
================================================
//go:build enable_e2e_tests
package teste2e
import (
"os"
"os/exec"
"strconv"
"time"
"github.com/bluenviron/mediamtx/internal/core"
"github.com/bluenviron/mediamtx/internal/test"
)
func newInstance(conf string) (*core.Core, bool) {
if conf == "" {
return core.New([]string{})
}
tmpf, err := test.CreateTempFile([]byte(conf))
if err != nil {
return nil, false
}
defer os.Remove(tmpf)
return core.New([]string{tmpf})
}
type container struct {
name string
}
func newContainer(image string, name string, args []string) (*container, error) {
c := &container{
name: name,
}
exec.Command("docker", "kill", "mediamtx-test-"+name).Run()
exec.Command("docker", "wait", "mediamtx-test-"+name).Run()
// --network=host is needed to test multicast
cmd := []string{
"docker", "run",
"--network=host",
"--name=mediamtx-test-" + name,
"mediamtx-test-" + image,
}
cmd = append(cmd, args...)
ecmd := exec.Command(cmd[0], cmd[1:]...)
ecmd.Stdout = nil
ecmd.Stderr = os.Stderr
err := ecmd.Start()
if err != nil {
return nil, err
}
time.Sleep(1 * time.Second)
return c, nil
}
func (c *container) close() {
exec.Command("docker", "kill", "mediamtx-test-"+c.name).Run()
exec.Command("docker", "wait", "mediamtx-test-"+c.name).Run()
exec.Command("docker", "rm", "mediamtx-test-"+c.name).Run()
}
func (c *container) wait() int {
exec.Command("docker", "wait", "mediamtx-test-"+c.name).Run()
out, _ := exec.Command("docker", "inspect", "mediamtx-test-"+c.name,
"-f", "{{.State.ExitCode}}").Output()
code, _ := strconv.ParseInt(string(out[:len(out)-1]), 10, 32)
return int(code)
}
================================================
FILE: internal/unit/payload.go
================================================
package unit
// Payload is a codec-dependent payload.
type Payload interface {
isPayload()
}
================================================
FILE: internal/unit/payload_ac3.go
================================================
package unit
// PayloadAC3 is the payload of an AC3 track.
type PayloadAC3 [][]byte
func (PayloadAC3) isPayload() {}
================================================
FILE: internal/unit/payload_av1.go
================================================
package unit
// PayloadAV1 is the payload of an AV1 track.
type PayloadAV1 [][]byte
func (PayloadAV1) isPayload() {}
================================================
FILE: internal/unit/payload_g711.go
================================================
package unit
// PayloadG711 is the payload of a G711 track.
type PayloadG711 []byte
func (PayloadG711) isPayload() {}
================================================
FILE: internal/unit/payload_h264.go
================================================
package unit
// PayloadH264 is the payload of a H264 track.
type PayloadH264 [][]byte
func (PayloadH264) isPayload() {}
================================================
FILE: internal/unit/payload_h265.go
================================================
package unit
// PayloadH265 is the payload of a H265 track.
type PayloadH265 [][]byte
func (PayloadH265) isPayload() {}
================================================
FILE: internal/unit/payload_klv.go
================================================
package unit
// PayloadKLV is the payload of a KLV track.
type PayloadKLV []byte
func (PayloadKLV) isPayload() {}
================================================
FILE: internal/unit/payload_lpcm.go
================================================
package unit
// PayloadLPCM is the payload of a LPCM track.
type PayloadLPCM []byte
func (PayloadLPCM) isPayload() {}
================================================
FILE: internal/unit/payload_mjpeg.go
================================================
package unit
// PayloadMJPEG is the payload of a MJPEG track.
type PayloadMJPEG []byte
func (PayloadMJPEG) isPayload() {}
================================================
FILE: internal/unit/payload_mpeg1_audio.go
================================================
package unit
// PayloadMPEG1Audio is the payload of a MPEG-1 Audio track.
type PayloadMPEG1Audio [][]byte
func (PayloadMPEG1Audio) isPayload() {}
================================================
FILE: internal/unit/payload_mpeg1_video.go
================================================
package unit
// PayloadMPEG1Video is the payload of a MPEG-1 Video track.
type PayloadMPEG1Video []byte
func (PayloadMPEG1Video) isPayload() {}
================================================
FILE: internal/unit/payload_mpeg4_audio.go
================================================
package unit
// PayloadMPEG4Audio is the payload of a MPEG-4 Audio track.
type PayloadMPEG4Audio [][]byte
func (PayloadMPEG4Audio) isPayload() {}
================================================
FILE: internal/unit/payload_mpeg4_audio_latm.go
================================================
package unit
// PayloadMPEG4AudioLATM is the payload of a MPEG-4 Audio LATM track.
type PayloadMPEG4AudioLATM []byte
func (PayloadMPEG4AudioLATM) isPayload() {}
================================================
FILE: internal/unit/payload_mpeg4_video.go
================================================
package unit
// PayloadMPEG4Video is the payload of a MPEG-4 Video track.
type PayloadMPEG4Video []byte
func (PayloadMPEG4Video) isPayload() {}
================================================
FILE: internal/unit/payload_opus.go
================================================
package unit
// PayloadOpus is the payload of a Opus track.
type PayloadOpus [][]byte
func (PayloadOpus) isPayload() {}
================================================
FILE: internal/unit/payload_vp8.go
================================================
package unit
// PayloadVP8 is the payload of a VP8 track.
type PayloadVP8 []byte
func (PayloadVP8) isPayload() {}
================================================
FILE: internal/unit/payload_vp9.go
================================================
package unit
// PayloadVP9 is the payload of a VP9 track.
type PayloadVP9 []byte
func (PayloadVP9) isPayload() {}
================================================
FILE: internal/unit/unit.go
================================================
// Package unit contains the unit definition.
package unit
import (
"reflect"
"time"
"github.com/pion/rtp"
)
// Unit is an atomic unit of a stream.
type Unit struct {
// relative time
PTS int64
// absolute time
NTP time.Time
// RTP packets
RTPPackets []*rtp.Packet
// codec-dependent payload
Payload Payload
}
// NilPayload checks whether the payload is nil.
func (u Unit) NilPayload() bool {
return u.Payload == nil || reflect.ValueOf(u.Payload).IsNil()
}
================================================
FILE: main.go
================================================
// main executable.
package main
import (
"os"
"github.com/bluenviron/mediamtx/internal/core"
)
func main() {
s, ok := core.New(os.Args[1:])
if !ok {
os.Exit(1)
}
s.Wait()
}
================================================
FILE: mediamtx.yml
================================================
###############################################
# Global settings
# Settings in this section are applied anywhere.
###############################################
# Global settings -> General
# Verbosity of the program; available values are "error", "warn", "info", "debug".
logLevel: info
# Destinations of log messages; available values are "stdout", "file" and "syslog".
logDestinations: [stdout]
# When destination is "stdout" or "file", emit logs in structured format (JSONL).
logStructured: false
# When "file" is in logDestinations, this is the file which will receive logs.
logFile: mediamtx.log
# When "syslog" is in logDestinations, use prefix for logs.
sysLogPrefix: mediamtx
# Dump packets to disk. This is useful for debugging.
dumpPackets: false
# Timeout of read operations.
readTimeout: 10s
# Timeout of write operations.
writeTimeout: 10s
# Size of the queue of outgoing packets.
# A higher value allows to increase throughput, a lower value allows to save RAM.
writeQueueSize: 512
# Maximum size of outgoing UDP payloads.
# It defaults to the maximum packet size on ethernet (1500) minus IPv6 and UDP headers (48).
# This can be decreased to avoid fragmentation on networks with a low MTU.
udpMaxPayloadSize: 1452
# Size of the read buffer of every UDP socket.
# This can be increased to decrease packet losses.
# It defaults to the default value of the operating system.
udpReadBufferSize: 0
# Command to run when a client connects to the server.
# This is terminated with SIGINT when a client disconnects from the server.
# The following environment variables are available:
# * MTX_CONN_TYPE: connection type
# * MTX_CONN_ID: connection ID
# * RTSP_PORT: RTSP server port
runOnConnect:
# Restart the command if it exits.
runOnConnectRestart: false
# Command to run when a client disconnects from the server.
# Environment variables are the same as runOnConnect.
runOnDisconnect:
###############################################
# Global settings -> Authentication
# Authentication method. Available values are:
# * internal: credentials are stored in the configuration file
# * http: an external HTTP URL is contacted to perform authentication
# * jwt: an external identity server provides authentication through JWTs
authMethod: internal
# Internal authentication.
# Enabled users.
authInternalUsers:
# Default unprivileged user.
# Username. 'any' means any user, including anonymous ones.
- user: any
# Password. Not used in case of 'any' user.
pass:
# IPs or networks allowed to use this user. An empty list means any IP.
ips: []
# Permissions.
permissions:
# Available actions are: publish, read, playback, api, metrics, pprof.
- action: publish
# Paths can be set to further restrict access to a specific path.
# An empty path means any path.
# Regular expressions can be used by using a tilde as prefix.
path:
- action: read
path:
- action: playback
path:
# Default administrator.
# This allows to use API, metrics and PPROF without authentication,
# if the IP is localhost.
- user: any
pass:
ips: ['127.0.0.1', '::1']
permissions:
- action: api
- action: metrics
- action: pprof
# HTTP-based authentication.
# URL called to perform authentication. Every time a user wants
# to authenticate, the server calls this URL with the POST method
# and a body containing:
# {
# "user": "user",
# "password": "password",
# "token": "token",
# "ip": "ip",
# "action": "publish|read|playback|api|metrics|pprof",
# "path": "path",
# "protocol": "rtsp|rtmp|hls|webrtc|srt",
# "id": "id",
# "query": "query"
# }
# If the response code is 20x, authentication is accepted, otherwise
# it is discarded.
authHTTPAddress:
# If the HTTP authentication URL has a self-signed or invalid certificate,
# you can provide the fingerprint of the certificate in order to
# validate it anyway. It can be obtained by running:
# openssl s_client -connect auth_http_domain:443 /dev/null | sed -n '/BEGIN/,/END/p' > server.crt
# openssl x509 -in server.crt -noout -fingerprint -sha256 | cut -d "=" -f2 | tr -d ':'
authHTTPFingerprint:
# Actions to exclude from HTTP-based authentication.
# Format is the same as the one of user permissions.
authHTTPExclude:
- action: api
- action: metrics
- action: pprof
# JWT-based authentication.
# Users have to log in through an external identity server and obtain a JWT.
# This JWT must contain the claim "mediamtx_permissions" with permissions,
# for instance:
# {
# "mediamtx_permissions": [
# {
# "action": "publish",
# "path": "somepath"
# }
# ]
# }
# Users are expected to pass the JWT in the Authorization header or as password.
# This is the JWKS URL that will be used to pull (once) the public key that allows
# to validate JWTs.
authJWTJWKS:
# If the JWKS URL has a self-signed or invalid certificate,
# you can provide the fingerprint of the certificate in order to
# validate it anyway. It can be obtained by running:
# openssl s_client -connect jwt_jwks_domain:443 /dev/null | sed -n '/BEGIN/,/END/p' > server.crt
# openssl x509 -in server.crt -noout -fingerprint -sha256 | cut -d "=" -f2 | tr -d ':'
authJWTJWKSFingerprint:
# name of the claim that contains permissions.
authJWTClaimKey: mediamtx_permissions
# Actions to exclude from JWT-based authentication.
# Format is the same as the one of user permissions.
authJWTExclude: []
# Allow passing the JWT through query parameters of HTTP requests (i.e. ?jwt=JWT).
# This is a security risk and will be disabled in the future.
# RTSP and RTMP always allow JWT in query even if disabled, since there is no alternative.
authJWTInHTTPQuery: true
# Expected issuer (iss) claim in the JWT. Leave empty to skip validation.
authJWTIssuer:
# Expected audience (aud) claim in the JWT. Leave empty to skip validation.
authJWTAudience:
###############################################
# Global settings -> Control API
# Enable controlling the server through the Control API.
api: false
# Address of the Control API listener.
apiAddress: :9997
# Enable HTTPS on the Control API server.
apiEncryption: false
# Path to the server key. This is needed only when encryption is yes.
# This can be generated with:
# openssl genrsa -out server.key 2048
# openssl req -new -x509 -sha256 -key server.key -out server.crt -days 3650
apiServerKey: server.key
# Path to the server certificate.
apiServerCert: server.crt
# Allowed CORS origins.
# Supports wildcards: ['http://*.example.com']
apiAllowOrigins: ['*']
# IPs or CIDRs of proxies placed before the HTTP server.
# These proxies can use the X-Forwarded-For header to set the real IP of clients,
# and the X-Forwarded-Proto header to set the original protocol.
apiTrustedProxies: []
###############################################
# Global settings -> Metrics
# Enable Prometheus-compatible metrics.
metrics: false
# Address of the metrics HTTP listener.
metricsAddress: :9998
# Enable HTTPS on the Metrics server.
metricsEncryption: false
# Path to the server key. This is needed only when encryption is yes.
# This can be generated with:
# openssl genrsa -out server.key 2048
# openssl req -new -x509 -sha256 -key server.key -out server.crt -days 3650
metricsServerKey: server.key
# Path to the server certificate.
metricsServerCert: server.crt
# Allowed CORS origins.
# Supports wildcards: ['http://*.example.com']
metricsAllowOrigins: ['*']
# IPs or CIDRs of proxies placed before the HTTP server.
# These proxies can use the X-Forwarded-For header to set the real IP of clients,
# and the X-Forwarded-Proto header to set the original protocol.
metricsTrustedProxies: []
###############################################
# Global settings -> PPROF
# Enable pprof-compatible endpoint to monitor performances.
pprof: false
# Address of the pprof listener.
pprofAddress: :9999
# Enable HTTPS on the pprof server.
pprofEncryption: false
# Path to the server key. This is needed only when encryption is yes.
# This can be generated with:
# openssl genrsa -out server.key 2048
# openssl req -new -x509 -sha256 -key server.key -out server.crt -days 3650
pprofServerKey: server.key
# Path to the server certificate.
pprofServerCert: server.crt
# Allowed CORS origins.
# Supports wildcards: ['http://*.example.com']
pprofAllowOrigins: ['*']
# IPs or CIDRs of proxies placed before the HTTP server.
# These proxies can use the X-Forwarded-For header to set the real IP of clients,
# and the X-Forwarded-Proto header to set the original protocol.
pprofTrustedProxies: []
###############################################
# Global settings -> Playback server
# Enable downloading recordings from the playback server.
playback: false
# Address of the playback server listener.
playbackAddress: :9996
# Enable HTTPS on the playback server.
playbackEncryption: false
# Path to the server key. This is needed only when encryption is yes.
# This can be generated with:
# openssl genrsa -out server.key 2048
# openssl req -new -x509 -sha256 -key server.key -out server.crt -days 3650
playbackServerKey: server.key
# Path to the server certificate.
playbackServerCert: server.crt
# Allowed CORS origins.
# Supports wildcards: ['http://*.example.com']
playbackAllowOrigins: ['*']
# IPs or CIDRs of proxies placed before the HTTP server.
# These proxies can use the X-Forwarded-For header to set the real IP of clients,
# and the X-Forwarded-Proto header to set the original protocol.
playbackTrustedProxies: []
###############################################
# Global settings -> RTSP server
# Enable publishing and reading streams with the RTSP protocol.
rtsp: true
# Enabled RTSP transport protocols. The handshake is always performed with TCP.
rtspTransports: [udp, multicast, tcp]
# Use secure protocol variants (RTSPS, SRTP, SRTCP).
# Available values are "no", "strict", "optional".
rtspEncryption: "no"
# Address of the TCP/RTSP listener. This is needed only when encryption is "no" or "optional".
rtspAddress: :8554
# Address of the TCP/RTSPS listener. This is needed only when encryption is "strict" or "optional".
rtspsAddress: :8322
# Address of the UDP/RTP listener. This is needed only when "udp" is in rtspTransports and encryption is "no" or "optional".
rtpAddress: :8000
# Address of the UDP/RTCP listener. This is needed only when "udp" is in rtspTransports and encryption is "no" or "optional".
rtcpAddress: :8001
# IP range of all UDP-multicast listeners. This is needed only when "multicast" is in rtspTransports and encryption is "no" or "optional".
multicastIPRange: 224.1.0.0/16
# Port of all UDP-multicast/RTP listeners. This is needed only when "multicast" is in rtspTransports and encryption is "no" or "optional".
multicastRTPPort: 8002
# Port of all UDP-multicast/RTCP listeners. This is needed only when "multicast" is in rtspTransports and encryption is "no" or "optional".
multicastRTCPPort: 8003
# Address of the UDP/SRTP listener. This is needed only when "udp" is in rtspTransports and encryption is "strict" or "optional".
srtpAddress: :8004
# Address of the UDP/SRTCP listener. This is needed only when "udp" is in rtspTransports and encryption is "strict" or "optional".
srtcpAddress: :8005
# Port of all UDP-multicast/SRTP listeners. This is needed only when "multicast" is in rtspTransports and encryption is "strict" or "optional".
multicastSRTPPort: 8006
# Port of all UDP-multicast/SRTCP listeners. This is needed only when "multicast" is in rtspTransports and encryption is "strict" or "optional".
multicastSRTCPPort: 8007
# Path to the server key. This is needed only when encryption is "strict" or "optional".
# This can be generated with:
# openssl genrsa -out server.key 2048
# openssl req -new -x509 -sha256 -key server.key -out server.crt -days 3650
rtspServerKey: server.key
# Path to the server certificate. This is needed only when encryption is "strict" or "optional".
rtspServerCert: server.crt
# Authentication methods. Available are "basic" and "digest".
# "digest" doesn't provide any additional security and is available for compatibility only.
rtspAuthMethods: [basic]
###############################################
# Global settings -> RTMP server
# Enable publishing and reading streams with the RTMP protocol.
rtmp: true
# Use the secure protocol variant (RTMPS).
# Available values are "no", "strict", "optional".
rtmpEncryption: "no"
# Address of the RTMP listener. This is needed only when encryption is "no" or "optional".
rtmpAddress: :1935
# Address of the RTMPS listener. This is needed only when encryption is "strict" or "optional".
rtmpsAddress: :1936
# Path to the server key. This is needed only when encryption is "strict" or "optional".
# This can be generated with:
# openssl genrsa -out server.key 2048
# openssl req -new -x509 -sha256 -key server.key -out server.crt -days 3650
rtmpServerKey: server.key
# Path to the server certificate. This is needed only when encryption is "strict" or "optional".
rtmpServerCert: server.crt
###############################################
# Global settings -> HLS server
# Enable reading streams with the HLS protocol.
hls: true
# Address of the HLS listener.
hlsAddress: :8888
# Enable HTTPS on the HLS server.
# This is required for Low-Latency HLS to function correctly on Apple devices.
hlsEncryption: false
# Path to the server key. This is needed only when encryption is yes.
# This can be generated with:
# openssl genrsa -out server.key 2048
# openssl req -new -x509 -sha256 -key server.key -out server.crt -days 3650
hlsServerKey: server.key
# Path to the server certificate.
hlsServerCert: server.crt
# Allowed CORS origins.
# Supports wildcards: ['http://*.example.com']
hlsAllowOrigins: ['*']
# IPs or CIDRs of proxies placed before the HLS server.
# If the server receives a request from one of these entries, IP in logs
# will be taken from the X-Forwarded-For header.
hlsTrustedProxies: []
# By default, HLS is generated only when requested by a user.
# This option allows to generate it always, avoiding the delay between request and generation.
hlsAlwaysRemux: false
# Variant of the HLS protocol to use. Available options are:
# * mpegts - uses MPEG-TS segments, for maximum compatibility.
# * fmp4 - uses fragmented MP4 segments, more efficient.
# * lowLatency - uses Low-Latency HLS.
hlsVariant: lowLatency
# Number of HLS segments to keep on the server.
# Segments allow to seek through the stream.
# Their number doesn't influence latency.
hlsSegmentCount: 7
# Minimum duration of each segment.
# A player usually puts 3 segments in a buffer before reproducing the stream.
# The final segment duration is also influenced by the interval between IDR frames,
# since the server changes the duration in order to include at least one IDR frame
# in each segment.
hlsSegmentDuration: 1s
# Minimum duration of each part.
# A player usually puts 3 parts in a buffer before reproducing the stream.
# Parts are used in Low-Latency HLS in place of segments.
# Part duration is influenced by the distance between video/audio samples
# and is adjusted in order to produce segments with a similar duration.
hlsPartDuration: 200ms
# Maximum size of each segment.
# This prevents RAM exhaustion.
hlsSegmentMaxSize: 50M
# Directory in which to save segments, instead of keeping them in the RAM.
# This decreases performance, since reading from disk is less performant than
# reading from RAM, but allows to save RAM.
hlsDirectory: ''
# The muxer will be closed when there are no
# reader requests and this amount of time has passed.
hlsMuxerCloseAfter: 60s
###############################################
# Global settings -> WebRTC server
# Enable publishing and reading streams with the WebRTC protocol.
webrtc: true
# Address of the WebRTC HTTP listener.
webrtcAddress: :8889
# Enable HTTPS on the WebRTC server.
# This covers only the WebRTC handshake and does not influence the encryption of WebRTC streams
# which are always encrypted, with a key that is exchanged during the WebRTC handshake.
webrtcEncryption: false
# Path to the server key.
# This can be generated with:
# openssl genrsa -out server.key 2048
# openssl req -new -x509 -sha256 -key server.key -out server.crt -days 3650
webrtcServerKey: server.key
# Path to the server certificate.
webrtcServerCert: server.crt
# Allowed CORS origins.
# Supports wildcards: ['http://*.example.com']
webrtcAllowOrigins: ['*']
# IPs or CIDRs of proxies placed before the WebRTC server.
# If the server receives a request from one of these entries, IP in logs
# will be taken from the X-Forwarded-For header.
webrtcTrustedProxies: []
# Address of a local UDP listener that will receive connections.
# Use a blank string to disable.
webrtcLocalUDPAddress: :8189
# Address of a local TCP listener that will receive connections.
# This is disabled by default since TCP is less efficient than UDP and
# introduces a progressive delay when network is congested.
webrtcLocalTCPAddress: ''
# WebRTC clients need to know the IP of the server.
# Gather IPs from interfaces and send them to clients.
webrtcIPsFromInterfaces: true
# Interfaces whose IPs will be sent to clients.
# An empty value means to use all available interfaces.
webrtcIPsFromInterfacesList: []
# Additional hosts or IPs to send to clients.
webrtcAdditionalHosts: []
# ICE servers. Needed only when local listeners can't be reached by clients.
# STUN servers allow to obtain and share the public IP of the server.
# TURN/TURNS servers force all traffic through them.
webrtcICEServers2: []
# - url: stun:stun.l.google.com:19302
# if user is "AUTH_SECRET", then authentication is secret based.
# the secret must be inserted into the password field.
# username: ''
# password: ''
# clientOnly: false
# Maximum time to gather STUN candidates.
webrtcSTUNGatherTimeout: 5s
# Time to wait for the WebRTC handshake to complete.
webrtcHandshakeTimeout: 10s
# Maximum time to gather tracks.
webrtcTrackGatherTimeout: 2s
###############################################
# Global settings -> SRT server
# Enable publishing and reading streams with the SRT protocol.
srt: true
# Address of the SRT listener.
srtAddress: :8890
###############################################
# Default path settings
# Settings in "pathDefaults" are applied anywhere,
# unless they are overridden in "paths".
pathDefaults:
###############################################
# Default path settings -> General
# Source of the stream. This can be:
# * publisher -> the stream is provided by a RTSP, RTMP, WebRTC or SRT client
# * rtsp://existing-url -> the stream is pulled from another RTSP server / camera
# * rtsps://existing-url -> the stream is pulled from another RTSP server / camera with RTSPS
# * rtsp+http://existing-url -> the stream is pulled from another RTSP server / camera, with HTTP tunneling
# * rtsps+http://existing-url -> the stream is pulled from another RTSP server / camera, with HTTPS tunneling
# * rtsp+ws://existing-url -> the stream is pulled from another RTSP server / camera, with WebSocket tunneling
# * rtsps+ws://existing-url -> the stream is pulled from another RTSP server / camera, with secure WebSocket tunneling
# * rtmp://existing-url -> the stream is pulled from another RTMP server / camera
# * rtmps://existing-url -> the stream is pulled from another RTMP server / camera with RTMPS
# * http://existing-url/stream.m3u8 -> the stream is pulled from another HLS server / camera
# * https://existing-url/stream.m3u8 -> the stream is pulled from another HLS server / camera with HTTPS
# * udp+mpegts://ip:port -> the stream is pulled from MPEG-TS over UDP, by listening on the specified address
# * unix+mpegts://socket -> the stream is pulled from MPEG-TS over Unix socket, by using the socket
# * udp+rtp://ip:port -> the stream is pulled from RTP over UDP, by listening on the specified address
# * srt://existing-url -> the stream is pulled from another SRT server / camera
# * whep://existing-url -> the stream is pulled from another WebRTC server / camera with HTTP+WHEP
# * wheps://existing-url -> the stream is pulled from another WebRTC server / camera with HTTPS+WHEP
# * redirect -> the stream is provided by another path or server
# * rpiCamera -> the stream is provided by a Raspberry Pi Camera
# The following variables can be used in the source string:
# * $MTX_QUERY: query parameters (passed by first reader)
# * $G1, $G2, ...: regular expression groups, if path name is
# a regular expression.
source: publisher
# If the source is a URL, and the source TLS certificate is self-signed
# or invalid, you can provide the fingerprint of the certificate in order to
# validate it anyway. It can be obtained by running:
# openssl s_client -connect source_ip:source_port /dev/null | sed -n '/BEGIN/,/END/p' > server.crt
# openssl x509 -in server.crt -noout -fingerprint -sha256 | cut -d "=" -f2 | tr -d ':'
sourceFingerprint:
# If the source is a URL, it will be pulled only when at least
# one reader is connected, saving bandwidth.
sourceOnDemand: false
# If sourceOnDemand is "yes", readers will be put on hold until the source is
# ready or until this amount of time has passed.
sourceOnDemandStartTimeout: 10s
# If sourceOnDemand is "yes", the source will be closed when there are no
# readers connected and this amount of time has passed.
sourceOnDemandCloseAfter: 10s
# Maximum number of readers. Zero means no limit.
maxReaders: 0
# SRT encryption passphrase required to read from this path.
srtReadPassphrase:
# Use absolute timestamp of frames, instead of replacing them with the current time.
useAbsoluteTimestamp: false
###############################################
# Default path settings -> Always available
# Enable always-available mode, in which an offline segment is played on repeat when the stream is not available.
alwaysAvailable: false
# Tracks of the default offline segment.
alwaysAvailableTracks: []
# Available values are: AV1, VP9, H265, H264, Opus, MPEG4Audio, G711, LPCM
# - codec: H264
# # in case of MPEG4Audio, G711, LPCM, sampleRate and ChannelCount must be provided too.
# sampleRate: 48000
# channelCount: 2
# # in case of G711, muLaw must be provided too.
# muLaw: false
# An MP4 file can be used instead of the default offline segment.
alwaysAvailableFile: ''
###############################################
# Default path settings -> Record
# Record streams to disk.
record: false
# Path of recording segments.
# Extension is added automatically.
# Available variables are %path (path name), %Y %m %d (year, month, day),
# %H %M %S (hours, minutes, seconds), %f (microseconds), %z (time zone), %s (unix epoch).
recordPath: ./recordings/%path/%Y-%m-%d_%H-%M-%S-%f
# Format of recorded segments.
# Available formats are "fmp4" (fragmented MP4) and "mpegts" (MPEG-TS).
recordFormat: fmp4
# fMP4 segments are concatenation of small MP4 files (parts), each with this duration.
# MPEG-TS segments are concatenation of 188-bytes packets, flushed to disk with this period.
# When a system failure occurs, the last part gets lost.
# Therefore, the part duration is equal to the RPO (recovery point objective).
recordPartDuration: 1s
# This prevents RAM exhaustion.
recordMaxPartSize: 50M
# Minimum duration of each segment.
recordSegmentDuration: 1h
# Delete segments after this timespan.
# Set to 0s to disable automatic deletion.
recordDeleteAfter: 1d
###############################################
# Default path settings -> Publisher source (when source is "publisher")
# Allow another client to disconnect the current publisher and publish in its place.
overridePublisher: true
# SRT encryption passphrase required to publish to this path.
srtPublishPassphrase:
# Demux MPEG-TS over RTSP into elementary streams.
# When enabled, RTSP publishers sending MP2T/90000 will be demultiplexed
# and their elementary streams (H.264, H.265, AAC, etc.) exposed as native tracks.
# This allows HLS, WebRTC, and other outputs to work transparently with MPEG-TS sources.
rtspDemuxMpegts: false
###############################################
# Default path settings -> RTSP source (when source is a RTSP or a RTSPS URL)
# Transport protocol used to pull the stream. available values are "automatic", "udp", "multicast", "tcp".
rtspTransport: automatic
# Support sources that don't provide server ports or use random server ports. This is a security issue
# and must be used only when interacting with sources that require it.
rtspAnyPort: false
# Range header to send to the source, in order to start streaming from the specified offset.
# available values:
# * clock: Absolute time
# * npt: Normal Play Time
# * smpte: SMPTE timestamps relative to the start of the recording
rtspRangeType:
# Available values:
# * clock: UTC ISO 8601 combined date and time string, e.g. 20230812T120000Z
# * npt: duration such as "300ms", "1.5m" or "2h45m", valid time units are "ns", "us" (or "µs"), "ms", "s", "m", "h"
# * smpte: duration such as "300ms", "1.5m" or "2h45m", valid time units are "ns", "us" (or "µs"), "ms", "s", "m", "h"
rtspRangeStart:
# Range of ports used as source port in outgoing UDP packets.
rtspUDPSourcePortRange: [10000, 65535]
###############################################
# Default path settings -> RTP source (when source is RTP)
# session description protocol (SDP) of the RTP stream.
rtpSDP:
###############################################
# Default path settings -> WebRTC / WHEP source (when source is WHEP)
# Token to insert in the Authorization: Bearer header.
whepBearerToken: ''
# Maximum time to gather STUN candidates.
whepSTUNGatherTimeout: 5s
# Time to wait for the WebRTC handshake to complete.
whepHandshakeTimeout: 10s
# Maximum time to gather tracks.
whepTrackGatherTimeout: 2s
###############################################
# Default path settings -> Redirect source (when source is "redirect")
# Path to which clients will be redirected.
# It can be a relative path (i.e. /otherstream) or an absolute RTSP URL.
sourceRedirect:
###############################################
# Default path settings -> Raspberry Pi Camera source (when source is "rpiCamera")
# ID of the camera.
rpiCameraCamID: 0
# Whether this is a secondary stream.
rpiCameraSecondary: false
# Width of frames.
rpiCameraWidth: 1920
# Height of frames.
rpiCameraHeight: 1080
# Flip horizontally.
rpiCameraHFlip: false
# Flip vertically.
rpiCameraVFlip: false
# Brightness [-1, 1].
rpiCameraBrightness: 0
# Contrast [0, 16].
rpiCameraContrast: 1
# Saturation [0, 16].
rpiCameraSaturation: 1
# Sharpness [0, 16].
rpiCameraSharpness: 1
# Exposure mode.
# values: normal, short, long, custom.
rpiCameraExposure: normal
# Auto-white-balance mode.
# (auto, incandescent, tungsten, fluorescent, indoor, daylight, cloudy or custom).
rpiCameraAWB: auto
# Auto-white-balance fixed gains. This can be used in place of rpiCameraAWB.
# format: [red,blue].
rpiCameraAWBGains: [0, 0]
# Denoise operating mode (off, cdn_off, cdn_fast, cdn_hq).
rpiCameraDenoise: "off"
# Fixed shutter speed, in microseconds.
rpiCameraShutter: 0
# Metering mode of the AEC/AGC algorithm (centre, spot, matrix or custom).
rpiCameraMetering: centre
# Fixed gain.
rpiCameraGain: 0
# EV compensation of the image in range [-10, 10].
rpiCameraEV: 0
# Region of interest, in format x,y,width,height (all normalized between 0 and 1).
rpiCameraROI:
# Whether to enable HDR on Raspberry Camera 3.
rpiCameraHDR: false
# Tuning file.
rpiCameraTuningFile:
# Sensor mode, in format [width]:[height]:[bit-depth]:[packing]
# bit-depth and packing are optional.
rpiCameraMode:
# frames per second.
rpiCameraFPS: 30
# Autofocus mode (auto, manual or continuous).
rpiCameraAfMode: continuous
# Autofocus range (normal, macro or full).
rpiCameraAfRange: normal
# Autofocus speed (normal or fast).
rpiCameraAfSpeed: normal
# Lens position (for manual autofocus only), will be set to focus to a specific distance
# calculated by the following formula: d = 1 / value
# Examples: 0 moves the lens to infinity.
# 0.5 moves the lens to focus on objects 2m away.
# 2 moves the lens to focus on objects 50cm away.
rpiCameraLensPosition: 0.0
# Autofocus window, in the form x,y,width,height where the coordinates
# are given as a proportion of the entire image.
rpiCameraAfWindow:
# Manual flicker correction period, in microseconds.
rpiCameraFlickerPeriod: 0
# Enables printing text on each frame.
rpiCameraTextOverlayEnable: false
# Text that is printed on each frame.
# format is the one of the strftime() function.
rpiCameraTextOverlay: '%Y-%m-%d %H:%M:%S - MediaMTX'
# Codec (auto, hardwareH264, softwareH264 or mjpeg).
# When is "auto" and stream is primary, it defaults to hardwareH264 (if available) or softwareH264.
# When is "auto" and stream is secondary, it defaults to mjpeg.
rpiCameraCodec: auto
# Period between IDR frames (when codec is hardwareH264 or softwareH264).
rpiCameraIDRPeriod: 60
# Bitrate (when codec is hardwareH264 or softwareH264).
rpiCameraBitrate: 5000000
# Hardware H264 profile (baseline, main or high) (when codec is hardwareH264).
rpiCameraHardwareH264Profile: main
# Hardware H264 level (4.0, 4.1 or 4.2) (when codec is hardwareH264).
rpiCameraHardwareH264Level: '4.1'
# Software H264 profile (baseline, main or high) (when codec is softwareH264).
rpiCameraSoftwareH264Profile: baseline
# Software H264 level (4.0, 4.1 or 4.2) (when codec is softwareH264).
rpiCameraSoftwareH264Level: '4.1'
# M-JPEG JPEG quality (when codec is mjpeg).
rpiCameraMJPEGQuality: 60
###############################################
# Default path settings -> Hooks
# Command to run when this path is initialized.
# This can be used to publish a stream when the server is launched.
# This is terminated with SIGINT when the program closes.
# The following environment variables are available:
# * MTX_PATH: path name
# * RTSP_PORT: RTSP server port
# * G1, G2, ...: regular expression groups, if path name is
# a regular expression.
runOnInit:
# Restart the command if it exits.
runOnInitRestart: false
# Command to run when this path is requested by a reader
# and no one is publishing to this path yet.
# This can be used to publish a stream on demand.
# This is terminated with SIGINT when there are no readers anymore.
# The following environment variables are available:
# * MTX_PATH: path name
# * MTX_QUERY: query parameters (passed by first reader)
# * RTSP_PORT: RTSP server port
# * G1, G2, ...: regular expression groups, if path name is
# a regular expression.
runOnDemand:
# Restart the command if it exits.
runOnDemandRestart: false
# Readers will be put on hold until the runOnDemand command starts publishing
# or until this amount of time has passed.
runOnDemandStartTimeout: 10s
# The command will be closed when there are no
# readers connected and this amount of time has passed.
runOnDemandCloseAfter: 10s
# Command to run when there are no readers anymore.
# Environment variables are the same as runOnDemand.
runOnUnDemand:
# Command to run when the stream is ready to be read, whenever it is
# published by a client or pulled from a server / camera.
# This is terminated with SIGINT when the stream is not ready anymore.
# The following environment variables are available:
# * MTX_PATH: path name
# * MTX_QUERY: query parameters (passed by publisher)
# * MTX_SOURCE_TYPE: source type
# * MTX_SOURCE_ID: source ID
# * RTSP_PORT: RTSP server port
# * G1, G2, ...: regular expression groups, if path name is
# a regular expression.
runOnReady:
# Restart the command if it exits.
runOnReadyRestart: false
# Command to run when the stream is not available anymore.
# Environment variables are the same as runOnReady.
runOnNotReady:
# Command to run when a client starts reading.
# This is terminated with SIGINT when a client stops reading.
# The following environment variables are available:
# * MTX_PATH: path name
# * MTX_QUERY: query parameters (passed by reader)
# * MTX_READER_TYPE: reader type
# * MTX_READER_ID: reader ID
# * RTSP_PORT: RTSP server port
# * G1, G2, ...: regular expression groups, if path name is
# a regular expression.
runOnRead:
# Restart the command if it exits.
runOnReadRestart: false
# Command to run when a client stops reading.
# Environment variables are the same as runOnRead.
runOnUnread:
# Command to run when a recording segment is created.
# The following environment variables are available:
# * MTX_PATH: path name
# * MTX_SEGMENT_PATH: segment file path
# * RTSP_PORT: RTSP server port
# * G1, G2, ...: regular expression groups, if path name is
# a regular expression.
runOnRecordSegmentCreate:
# Command to run when a recording segment is complete.
# The following environment variables are available:
# * MTX_PATH: path name
# * MTX_SEGMENT_PATH: segment file path
# * MTX_SEGMENT_DURATION: segment duration
# * RTSP_PORT: RTSP server port
# * G1, G2, ...: regular expression groups, if path name is
# a regular expression.
runOnRecordSegmentComplete:
###############################################
# Path settings
# Settings in "paths" are applied to specific paths, and the map key
# is the name of the path.
# Any setting in "pathDefaults" can be overridden here.
# It's possible to use regular expressions by using a tilde as prefix,
# for example "~^(test1|test2)$" will match both "test1" and "test2",
# for example "~^prefix" will match all paths that start with "prefix".
paths:
# example:
# my_camera:
# source: rtsp://my_camera
# Settings under path "all_others" are applied to all paths that
# do not match another entry.
all_others:
================================================
FILE: scripts/binaries.mk
================================================
BINARY_NAME = mediamtx
define DOCKERFILE_BINARIES
FROM $(BASE_IMAGE) AS build-base
RUN apk add --no-cache zip make git tar
WORKDIR /s
COPY go.mod go.sum ./
RUN go mod download
COPY . ./
ENV CGO_ENABLED=0
RUN rm -rf tmp binaries
RUN mkdir tmp binaries
RUN cp mediamtx.yml LICENSE tmp/
RUN go generate ./...
FROM build-base AS build-windows-amd64
RUN GOOS=windows GOARCH=amd64 go build -tags enable_upgrade -o "tmp/$(BINARY_NAME).exe"
RUN go install github.com/tc-hib/go-winres@v0.3.3
RUN go-winres patch --in scripts/winres.json --product-version "$$(git describe --tags --abbrev=0 | sed 's/^v//')" --file-version "$$(git describe --tags --abbrev=0 | sed 's/^v//')" tmp/mediamtx.exe
RUN cd tmp && zip -q "../binaries/$(BINARY_NAME)_$$(cat ../internal/core/VERSION)_windows_amd64.zip" "$(BINARY_NAME).exe" mediamtx.yml LICENSE
FROM build-base AS build-linux-amd64
RUN GOOS=linux GOARCH=amd64 go build -tags enable_upgrade -o "tmp/$(BINARY_NAME)"
RUN tar -C tmp -czf "binaries/$(BINARY_NAME)_$$(cat internal/core/VERSION)_linux_amd64.tar.gz" --owner=0 --group=0 "$(BINARY_NAME)" mediamtx.yml LICENSE
FROM build-base AS build-darwin-amd64
RUN GOOS=darwin GOARCH=amd64 go build -tags enable_upgrade -o "tmp/$(BINARY_NAME)"
RUN tar -C tmp -czf "binaries/$(BINARY_NAME)_$$(cat internal/core/VERSION)_darwin_amd64.tar.gz" --owner=0 --group=0 "$(BINARY_NAME)" mediamtx.yml LICENSE
FROM build-base AS build-darwin-arm64
RUN GOOS=darwin GOARCH=arm64 go build -tags enable_upgrade -o "tmp/$(BINARY_NAME)"
RUN tar -C tmp -czf "binaries/$(BINARY_NAME)_$$(cat internal/core/VERSION)_darwin_arm64.tar.gz" --owner=0 --group=0 "$(BINARY_NAME)" mediamtx.yml LICENSE
FROM build-base AS build-linux-armv6
RUN GOOS=linux GOARCH=arm GOARM=6 go build -tags enable_upgrade -o "tmp/$(BINARY_NAME)"
RUN tar -C tmp -czf "binaries/$(BINARY_NAME)_$$(cat internal/core/VERSION)_linux_armv6.tar.gz" --owner=0 --group=0 "$(BINARY_NAME)" mediamtx.yml LICENSE
FROM build-base AS build-linux-armv7
RUN GOOS=linux GOARCH=arm GOARM=7 go build -tags enable_upgrade -o "tmp/$(BINARY_NAME)"
RUN tar -C tmp -czf "binaries/$(BINARY_NAME)_$$(cat internal/core/VERSION)_linux_armv7.tar.gz" --owner=0 --group=0 "$(BINARY_NAME)" mediamtx.yml LICENSE
FROM build-base AS build-linux-arm64
RUN GOOS=linux GOARCH=arm64 go build -tags enable_upgrade -o "tmp/$(BINARY_NAME)"
RUN tar -C tmp -czf "binaries/$(BINARY_NAME)_$$(cat internal/core/VERSION)_linux_arm64.tar.gz" --owner=0 --group=0 "$(BINARY_NAME)" mediamtx.yml LICENSE
FROM $(BASE_IMAGE)
COPY --from=build-windows-amd64 /s/binaries /s/binaries
COPY --from=build-linux-amd64 /s/binaries /s/binaries
COPY --from=build-darwin-amd64 /s/binaries /s/binaries
COPY --from=build-darwin-arm64 /s/binaries /s/binaries
COPY --from=build-linux-armv6 /s/binaries /s/binaries
COPY --from=build-linux-armv7 /s/binaries /s/binaries
COPY --from=build-linux-arm64 /s/binaries /s/binaries
endef
export DOCKERFILE_BINARIES
binaries:
echo "$$DOCKERFILE_BINARIES" | docker build . -f - \
-t temp
docker run --rm -v "$(shell pwd):/out" \
temp sh -c "rm -rf /out/binaries && cp -r /s/binaries /out/"
sudo chown -R $(shell id -u):$(shell id -g) binaries
================================================
FILE: scripts/dockerhub.mk
================================================
DOCKER_REPOSITORY = bluenviron/mediamtx
dockerhub:
$(eval VERSION := $(shell git describe --tags | tr -d v))
docker login -u $(DOCKER_USER) -p $(DOCKER_PASSWORD)
docker buildx rm builder 2>/dev/null || true
docker buildx create --name=builder
docker build --builder=builder \
-f docker/ffmpeg-rpi.Dockerfile . \
--platform=linux/arm/v6,linux/arm/v7,linux/arm64 \
-t $(DOCKER_REPOSITORY):$(VERSION)-ffmpeg-rpi \
-t $(DOCKER_REPOSITORY):1-ffmpeg-rpi \
-t $(DOCKER_REPOSITORY):latest-ffmpeg-rpi \
--push
docker build --builder=builder \
-f docker/rpi.Dockerfile . \
--platform=linux/arm/v6,linux/arm/v7,linux/arm64 \
-t $(DOCKER_REPOSITORY):$(VERSION)-rpi \
-t $(DOCKER_REPOSITORY):1-rpi \
-t $(DOCKER_REPOSITORY):latest-rpi \
--push
docker build --builder=builder \
-f docker/ffmpeg.Dockerfile . \
--platform=linux/amd64,linux/arm/v6,linux/arm/v7,linux/arm64 \
-t $(DOCKER_REPOSITORY):$(VERSION)-ffmpeg \
-t $(DOCKER_REPOSITORY):1-ffmpeg \
-t $(DOCKER_REPOSITORY):latest-ffmpeg \
--push
docker build --builder=builder \
-f docker/standard.Dockerfile . \
--platform=linux/amd64,linux/arm/v6,linux/arm/v7,linux/arm64 \
-t $(DOCKER_REPOSITORY):$(VERSION) \
-t $(DOCKER_REPOSITORY):1 \
-t $(DOCKER_REPOSITORY):latest \
--push
docker buildx rm builder
================================================
FILE: scripts/format.mk
================================================
define DOCKERFILE_FORMAT
FROM $(BASE_IMAGE)
RUN go install mvdan.cc/gofumpt@v0.5.0
endef
export DOCKERFILE_FORMAT
format:
echo "$$DOCKERFILE_FORMAT" | docker build -q . -f - -t temp
docker run --rm -it -v "$(shell pwd):/s" -w /s temp \
sh -c "gofumpt -l -w ."
================================================
FILE: scripts/lint.mk
================================================
define DOCKERFILE_DOCS_LINT
FROM $(NODE_IMAGE)
RUN yarn global add prettier@3.6.2
endef
export DOCKERFILE_DOCS_LINT
define DOCKERFILE_API_DOCS_LINT
FROM $(NODE_IMAGE)
RUN yarn global add @redocly/cli@1.0.0-beta.123
endef
export DOCKERFILE_API_DOCS_LINT
lint-go:
docker run --rm -v "$(shell pwd):/app" -w /app \
$(GOLANGCI_LINT_IMAGE) \
golangci-lint run -v
lint-go-mod:
go mod tidy
git diff --exit-code
lint-conf:
go test -v -tags enable_linters ./internal/linters/conf
lint-go2api:
go test -v -tags enable_linters ./internal/linters/go2api
lint-docs:
echo "$$DOCKERFILE_DOCS_LINT" | docker build . -f - -t temp
docker run --rm -v "$(shell pwd)/docs:/s" -w /s temp \
sh -c "prettier --write ."
git diff --exit-code
lint-api-docs:
echo "$$DOCKERFILE_API_DOCS_LINT" | docker build . -f - -t temp
docker run --rm -v "$(shell pwd)/api:/s" -w /s temp \
sh -c "openapi lint openapi.yaml"
lint: lint-go lint-go-mod lint-conf lint-go2api lint-docs lint-api-docs
================================================
FILE: scripts/test-e2e.mk
================================================
test-e2e-nodocker:
go generate ./...
go test -v -race -tags enable_e2e_tests ./internal/teste2e
define DOCKERFILE_E2E_TEST
FROM $(BASE_IMAGE)
RUN apk add --no-cache make docker-cli gcc musl-dev
WORKDIR /s
COPY go.mod go.sum ./
RUN go mod download
COPY . ./
endef
export DOCKERFILE_E2E_TEST
test-e2e:
echo "$$DOCKERFILE_E2E_TEST" | docker build -q . -f - -t temp
docker run --rm -it \
-v /var/run/docker.sock:/var/run/docker.sock:ro \
--network=host \
temp \
make test-e2e-nodocker
================================================
FILE: scripts/test.mk
================================================
ifeq ($(shell getconf LONG_BIT),64)
RACE=-race
endif
test-internal:
go generate ./...
go test -v $(RACE) -coverprofile=coverage-internal.txt \
$$(go list ./internal/... | grep -v /core)
test-core:
go test -v $(RACE) -coverprofile=coverage-core.txt ./internal/core
test-nodocker: test-internal test-core
define DOCKERFILE_TEST
ARG ARCH
FROM $$ARCH/$(BASE_IMAGE)
RUN apk add --no-cache make gcc musl-dev
WORKDIR /s
COPY go.mod go.sum ./
RUN go mod download
endef
export DOCKERFILE_TEST
test:
echo "$$DOCKERFILE_TEST" | docker build -q . -f - -t temp --build-arg ARCH=amd64
docker run --rm \
-v "$(shell pwd):/s" \
temp \
make test-nodocker
test-32:
echo "$$DOCKERFILE_TEST" | docker build -q . -f - -t temp --build-arg ARCH=i386
docker run --rm \
-v "$(shell pwd):/s" \
temp \
make test-nodocker
================================================
FILE: scripts/winres.json
================================================
{
"RT_VERSION": {
"#1": {
"0000": {
"fixed": {
"file_version": "0.0.0.0",
"product_version": "0.0.0.0"
},
"info": {
"0409": {
"Comments": "",
"CompanyName": "",
"FileDescription": "MediaMTX",
"FileVersion": "",
"InternalName": "",
"LegalCopyright": "",
"LegalTrademarks": "",
"OriginalFilename": "",
"PrivateBuild": "",
"ProductName": "MediaMTX",
"ProductVersion": "",
"SpecialBuild": ""
}
}
}
}
}
}
