HaishinKit/HaishinKit.swift

HaishinKit is a Swift-based media streaming library that enables publishing and playback of audio and video across iOS, macOS, tvOS, and visionOS. It supports multiple transport protocols including RTMP, SRT, WHIP/WHEP, and MoQT, while providing robust infrastructure for audio/video codec handling, multi-track mixing, and screen capture. The system offers a unified session-based API for managing connections and includes comprehensive tooling for testing, documentation, and cross-platform example applications.

32 changes.

The project underwent a comprehensive migration from legacy Swift 1.x code to modern Swift 6, introducing Swift Package Manager support and expanding platform coverage to include visionOS and tvOS. This period saw the implementation of new streaming protocols, specifically SRT and the MoQT draft7 standard, alongside a complete rewrite of the audio/video codec and mixer subsystems for improved stability and multi-track support.

17 changes.

The project introduced new streaming protocols including SRT, RTMP (with HEVC/Opus support), and WHIP/WHEP via RTCHaishinKit, while unifying connection management through a new StreamSession abstraction. Concurrently, the codebase expanded its media handling capabilities with MPEG-2 Transport Stream parsing, async audio playback, and comprehensive test coverage for these new features.

This change introduces new source files in the ISO module to handle parsing and representation of ISO base media formats. It adds \H264NALUnit\ and \HEVCNALUnit\ structs to parse NAL units for H.264 and HEVC video streams, respectively, along with an \AudioSpecificConfig\ struct for MPEG-4 AAC audio configuration. Supporting utilities include \NALUnitReader\ for extracting NAL units from data buffers and CMSampleBuffers, \ISOTypeBufferUtil\ for converting between byte stream and NAL file formats, and a \NALUnit\ protocol to standardize these types. This provides the foundational parsing logic for these specific media codecs within the library.

HaishinKit/Sources/ISO · high confidence

New view components have been added to the View module: MTHKView, a Metal-based view for displaying video streams, and PiPHKView, which uses AVSampleBufferDisplayLayer. Both views support video track selection, video gravity configuration, and registration of video effects. To facilitate integration with modern Apple UI frameworks, SwiftUI wrappers (MTHKViewRepresentable and PiPHKViewRepresentable) are now available for iOS, tvOS, macOS, and visionOS, allowing developers to embed these video views directly in SwiftUI hierarchies.

HaishinKit/Sources/View · high confidence

The Examples directory now includes a .swiftlint.yml file to enforce code style rules (such as disabling identifier\_name and enabling array\_init) and a new Preference.swift file that provides a Sendable configuration struct for managing stream URIs and names in the example applications.

Examples · high confidence

The tvOS example project has been initialized with a basic SwiftUI application structure, including the main app entry point, a content view with playback and preference tabs, and the necessary asset catalog configurations for app icons and top-shelf images.

Examples/tvOS · high confidence

Added a new visionOS example app that demonstrates video playback and streaming capabilities. The app registers RTMP and SRT session factories for ingest and includes a basic SwiftUI view for playback.

Examples/visionOS · high confidence

New source files have been added to the TS module to provide full support for reading and writing MPEG-2 Transport Streams. This includes low-level utilities for binary data handling (ByteArray), checksums (CRC32), and ADTS audio parsing, alongside complete implementations of the TS protocol structures such as TSPacket, TSAdaptationField, and Program-Specific Information (TSProgram, TSProgramAssociation, TSProgramMap). High-level consumers (TSReader, TSWriter) now allow applications to ingest transport stream data and emit CMSampleBuffers, or accept audio and video buffers to generate valid TS output with proper PAT/PMT tables and timestamps.

SRTHaishinKit/Sources/TS · high confidence

Introduced a new fastlane configuration (Appfile, Fastfile, and README) to automate two key workflows: the 'review' lane, which runs Swift Package Manager tests for HaishinKit and SRTHaishinKit and executes Danger checks on pull requests, and the 'document' lane, which generates Swift-DocC documentation for a specified version and pushes it to the documentation repository.

fastlane · high confidence

The RTMPHaishinKit utility layer now includes new foundational components: a ByteArray class for reading and writing binary data (including various integer, float, and string types), an HKAtomic struct for thread-safe value access, an MD5 enum for message digest calculations, and a Constants file defining the kit's identifier and logger. These additions provide the underlying infrastructure for binary serialization and secure hashing within the RTMP stream handling.

RTMPHaishinKit/Sources/Util · high confidence

New extension methods have been added to the SRTHaishinKit to facilitate the creation of CoreMedia format descriptions from raw video data. The \AVCNALUnit\ and \HEVCNALUnit\ extensions now provide \makeFormatDescription\ functions that parse H.264 (SPS/PPS) and HEVC (VPS/SPS/PPS) parameter sets, respectively. A corresponding \NALUnitReader\ extension unifies this logic by dispatching to the correct codec handler based on the \ESStreamType\, while a \CMFormatDescription\ extension maps media subtypes to stream types.

SRTHaishinKit/Sources/Extension · high confidence

The DebugDescription module now provides human-readable debug strings for AVFoundation audio types. AVAudioCommonFormat and AudioFormatID enums now display readable names (e.g., "float32", "kAudioFormatAC3") instead of raw values. AudioStreamBasicDescription now includes readable format IDs (e.g., "LinearPCM") and parsed format flags (e.g., "pcm\_IsFloat \| pcm\_IsSignedInteger") in its debug output. AudioNode now exposes a detailed description including bus counts, per-bus volume and format information for mixer nodes, and a list of global audio unit parameters with their names, IDs, min/max/default values, and units.

DebugDescription · high confidence

MoQTHaishinKit now provides a Swift implementation of the MoQT protocol based on draft7, enabling developers to build applications using this standard. This release introduces the core control message types required for session management and subscription, including CLIENT\_SETUP, SERVER\_SETUP, ANNOUNCE, SUBSCRIBE, and their corresponding OK/Error responses, as well as SUBSCRIBE\_ANNOUNCES variants. It also includes the data stream structures for OBJECT and STREAM\_HEADER\_SUBGROUP, along with the underlying MoQTPayload serialization logic and MoQTConnection actor for handling QUIC-based networking. While this establishes the foundational protocol layer, live streaming and viewing features are noted as not yet implemented.

MoQTHaishinKit · high confidence

This change establishes the foundational repository structure by adding the BSD 3-Clause license, a comprehensive README with installation and usage instructions, and essential configuration files. It introduces SwiftLint rules for code quality, a Dangerfile for CI checks, a .ruby-version file specifying Ruby 3.4.4, and a .gitignore file to exclude build artifacts and IDE-specific files.

(repo-wide) · high confidence

The RTMPHaishinKit library now includes dedicated source files for Action Message Format (AMF) and codec configuration handling. In the AMF module, new \AMF0Serializer\ and \AMF3Serializer\ classes, along with \AMFFoundation\ types (such as \AMFArray\, \AMFObject\, and \AMFXMLDocument\), provide the ability to serialize and deserialize AMF0 and AMF3 data structures. In the Codec module, \AVCDecoderConfigurationRecord\ and \HEVCDecoderConfigurationRecord\ structs have been added to parse H.264 and HEVC decoder configuration data and generate Core Media format descriptions, while \OpusHeaderPacket\ handles Opus audio header generation.

RTMPHaishinKit/Sources/AMF, RTMPHaishinKit/Sources/Codec · high confidence

Adds the RTCHaishinKit module, a new Swift-based WHIP/WHEP protocol stack that enables H.264 and Opus publishing and playback. The kit provides a high-level Session API for managing connections, an HTTP transport layer for signaling, and a full WebRTC implementation (PeerConnection, Tracks, DataChannels) built on libdatachannel.

RTCHaishinKit · high confidence

Users can now capture and restore the complete state of the screen object hierarchy using the new ScreenObjectSnapshot type. This change adds a serializable, Sendable value type that records layout properties (size, alignment, margins), visibility, and child relationships, along with a ScreenObjectFactory to reconstruct ScreenObject instances from these snapshots. This enables features like state persistence, debugging, and inter-process communication for the screen rendering system.

HaishinKit/Sources/Screen · high confidence

The library adds a new actor-based audio playback system (AudioPlayer, AudioPlayerNode) and refactors the streaming core to use AsyncStream for frame ordering and media linking. This enables precise audio synchronization via AVAudioTime, allows attaching an audio player to incoming streams for local playback, and provides a new StreamRecorder actor for capturing media output to MP4/MOV files.

HaishinKit/Sources/Stream · high confidence

This change introduces a new SRT (Secure Reliable Transport) streaming implementation within SRTHaishinKit. It adds a new \SRTConnection\ actor to handle low-level SRT socket operations, including support for caller, listener, and rendezvous connection modes, as well as IPv6. A new \SRTSession\ and \SRTSessionFactory\ provide a high-level session API that manages connection lifecycle, retry logic with exponential backoff, and state reporting. The implementation includes a new \SRTSocketOption\ API allowing configuration of SRT-specific parameters (such as latency, bandwidth, and encryption) via URL query parameters or direct setters. Additionally, it adds an \SRTLogger\ for controlling SRT library logging levels and functional areas, and an \SRTPerformanceData\ struct to expose network performance statistics.

SRTHaishinKit/Sources/SRT · high confidence

This change introduces a new internal network monitoring system within the Network layer, adding a \NetworkMonitor\ actor that periodically collects bandwidth statistics (bytes in/out, queue size) and emits \NetworkMonitorEvent\ events. It defines the \NetworkConnection\ protocol as the foundation for RTMP connections, along with supporting data structures like \NetworkMonitorReport\ and \NetworkTransportReport\ to carry statistical data, and a \NetworkTransportReporter\ protocol to facilitate the creation of these monitoring components.

HaishinKit/Sources/Network · high confidence

This change introduces three new extension files to the RTMPHaishinKit library. CMVideoFormatDescription+Extension adds methods to extract configuration boxes (avcC/hvcC) and generate decoder configuration records for H.264 and HEVC streams. IncomingStream+Extension provides a convenience method to append RTMP video messages as sample buffers. URL+Extension adds utilities to strip authentication credentials and query strings from URLs, and to parse query parameters into a dictionary.

RTMPHaishinKit/Sources/Extension · high confidence

This update introduces a suite of new utility components in the Util module to support core streaming functionality. AVAudioUtil now handles audio format conversion and channel layout mapping, while AudioTime provides interoperability between AVAudioTime and CMTime for accurate timestamping. Concurrency is improved with AsyncStreamed and AsyncStreamedFlow property wrappers and a new AsyncRunner protocol for actor-based lifecycle management. Binary data handling is standardized via ByteArray and DataConvertible, and device orientation and headphone connection states are exposed through DeviceUtil. Additionally, TypedBlockQueue offers a type-safe buffer queue for CMSampleBuffer management, and FrameTracker assists in monitoring frame rates.

HaishinKit/Sources/Util · high confidence

The iOS example app has been completely rewritten using SwiftUI, replacing the previous implementation. This update introduces a modern tab-based interface with dedicated views for Preferences, Publishing, Playback, and UVC Camera support. Key new features include a robust audio capture system using AVAudioEngine with stereo support, a new Playback view for receiving streams, and the ability to record local video files while publishing. The app now supports advanced streaming settings such as HDR video, low-latency rate control, and variable bitrate modes, along with improved error handling and a help guide for configuration options.

Examples/iOS · high confidence

The library has removed several core source files that were part of the initial Swift 1.x implementation, including \AMFSerializer.swift\, \AVCaptureSessionManager.swift\, \ByteArray.swift\, \EventDispatcher.swift\, \FLVFile.swift\, \MP4Encoder.swift\, \MP4File.swift\, \MP4Sampler.swift\, \RTMPChunk.swift\, \RTMPConnection.swift\, \RTMPMessage.swift\, and \RTMPMuxer.swift\. This cleanup eliminates the old AMF serialization, raw byte handling, event dispatching, FLV/MP4 file parsing, MP4 encoding, and RTMP streaming logic, likely as part of a broader refactoring or migration to a newer Swift version.

lf · high confidence

The legacy \lf.xcodeproj\ directory has been removed, including the \project.pbxproj\ build settings, user-specific breakpoint lists, and scheme management files. This cleanup eliminates obsolete project configuration artifacts that are no longer part of the active build system.

lf.xcodeproj · high confidence

The library now supports IPv6 addresses when connecting via the SRT protocol. This is enabled by new utility files in the Util directory: AddrInfo.swift provides address resolution logic using getaddrinfo with AF\_UNSPEC to handle both IPv4 and IPv6, and Constants.swift adds a logger identifier for the kit.

SRTHaishinKit/Sources/Util · high confidence

The audio mixing and capture subsystems have been rewritten to improve stability and enable advanced features. The new \AudioCaptureUnit\ and \AudioDeviceUnit\ classes manage audio inputs, supporting multi-track mixing via \AudioMixerByMultiTrack\ (using Core Audio units) or single-track mixing, which resolves previous heap-use-after-free and memory-leak issues. \AudioMixerSettings\ are now \Codable\ and allow per-track configuration (volume, mute, channel mapping). The \CaptureSession\ implementation now supports multi-camera sessions (\AVCaptureMultiCamSession\) on iOS/tvOS, enables camera access during multitasking, and uses \synchronizationClock\ for better frame alignment. These changes provide a more robust foundation for audio/video capture with improved error handling and resource management.

HaishinKit/Sources/Mixer · high confidence

The Xcode project workspace and schemes have been upgraded to version 1.7 with a LastUpgradeVersion of 1610 (Xcode 16.1). The project has been renamed from 'lf' to 'Examples', updating the workspace reference and scheme targets for iOS, macOS, tvOS, and visionOS to build 'Example iOS.app', 'Example macOS.app', 'Example tvOS.app', and 'Example visionOS.app' respectively. The macOS scheme was migrated from a user-local scheme to a shared scheme, and the Screencast app extension scheme was added. These changes ensure the example projects compile and run correctly in the latest Xcode version.

Examples/Examples.xcodeproj/xcshareddata · high confidence

The library introduces a new \StreamSession\ protocol and a builder-based factory system (\StreamSessionBuilderFactory\, \StreamSessionBuilder\) to unify streaming connections. This change adds validation that rejects malformed streaming URLs (missing scheme or host) before attempting to connect, improving error handling for invalid inputs. It also provides a common API foundation for various streaming services like RTMP and SRT through registered factories.

HaishinKit/Sources/Session · high confidence

This update introduces a comprehensive suite of Swift extensions for the \HaishinKit\ library's core media types. It adds thread-safety conformance for \AVAudioBuffer\ and \CMSampleBuffer\, and implements helper methods for audio processing, including copying, cloning, muting, and converting \AVAudioPCMBuffer\ and \AVAudioCompressedBuffer\ to Core Media sample buffers. Video handling is enhanced with extensions for \CVPixelBuffer\ (copying, locking, and CIImage conversion), \VTCompressionSession\, and \VTDecompressionSession\ to streamline frame encoding and decoding. Additionally, new utilities support camera configuration by providing frame-rate and multi-camera support checks for \AVCaptureDevice\, and add convenience properties for video dimensions and layer gravity scaling.

HaishinKit/Sources/Extension · high confidence

The codec layer has been replaced with new \AudioCodec\ and \VideoCodec\ classes that support OPUS audio in addition to AAC and PCM, and allow per-stream sample rate configuration. Video encoding now exposes a variable bit rate mode (available on iOS 26+/macOS 26+), a low-latency rate control option, and an optional expected frame rate setting to optimize power consumption. The audio pipeline includes channel conversion and mapping capabilities, while the video pipeline uses a refactored \VTSessionMode\ architecture for compression and decompression sessions.

HaishinKit/Sources/Codec · high confidence

The RTMP implementation has been completely rewritten to use a new \RTMPSession\ and \RTMPSessionFactory\ architecture, replacing the previous \RTMPConnection\-centric design. This change introduces built-in retry logic with exponential backoff for connection failures and adds support for RTMP authentication (San Jose and Adobe modes). The library now supports HEVC video and Opus audio codecs, and allows RTMP URLs to include query parameters. Additionally, the \RTMPStream\ now throws explicit errors for unsupported codecs and includes the framerate in the onMetaData output.

RTMPHaishinKit/Sources/RTMP · high confidence

The iOS Screencast example has been updated to use the redesigned StreamSession API and a new MediaMixer that supports multi-track audio mixing. The broadcast extension now registers RTMP, SRT, and HTTP session factories, allowing users to test streaming via multiple protocols. Audio handling has changed to explicitly mix microphone (track 0) and app audio (track 1) inputs, with the app audio volume synchronized to the system volume slider. Video processing now uses a passthrough mode with dynamic configuration based on the incoming sample buffer dimensions.

Examples/iOS/Screencast · high confidence

The test suite has removed the old \EventDispatcherTests.swift\, \lfTests.swift\, and \Info.plist\ files, which were written for Swift 1.x (evidenced by the use of \println\ and Objective-C-style selectors). This cleanup aligns with the project's migration to Swift 2.0 and the adoption of modern testing practices, such as using \@testable import\ and the CryptoSwift library, ensuring the test target is consistent with the updated codebase.

lfTests · high confidence

The Xcode project's user-specific settings have been updated to reflect the current development environment. The scheme management list now includes explicit ordering hints for various example targets (such as iOS, macOS, tvOS, visionOS, and specific library schemes like HaishinKit and SRT), ensuring consistent build and run configurations. Additionally, a new breakpoint configuration file has been added, defining a disabled file breakpoint in the iOS AppDelegate.

Examples/Examples.xcodeproj/xcuserdata · high confidence

The Examples project configuration has been updated to support building for iOS, macOS, tvOS, and visionOS. The project now includes specific framework dependencies for each platform, such as ReplayKit for iOS screen recording, and integrates various HaishinKit modules (RTMP, SRT, RTC, MoQT) across the different example targets. Additionally, the project structure has been adjusted to handle platform-specific file references and build phases, ensuring that each example app is correctly configured for its respective operating system.

Examples/Examples.xcodeproj · high confidence

The macOS example application has been completely rewritten to use SwiftUI, replacing the previous implementation with a new main entry point (HaishinApp) and a tabbed interface for Playback, Publish, and Preference views. The app now utilizes a unified StreamSessionBuilderFactory to register and manage RTMP, SRT, and HTTP session factories, aligning the macOS example with other platforms. The Publish view demonstrates enhanced capabilities, including configurable frame rates (15/30/60 FPS), video effects (monochrome), and picture-in-picture support via AssetScreenObject and ImageScreenObject overlays on the screen capture mixer.

Examples/macOS · high confidence

Added test coverage for SRT connection, socket options, URL parsing, and stream validation; Added test infrastructure for audio and video sample buffers; Added tests for ByteArray utility and HLS sample asset; Added tests for NAL unit parsing and Data extension; Added tests for StreamRecorder initialization and file path handling; Added tests for StreamSessionBuilderFactory URL validation; Added unit tests for ADTSReader; Added unit tests for HaishinKit Mixer components; Added unit tests for ISO media parsing and extension utilities; Added unit tests for RTMPHaishinKit core components; Added unit tests for ScreenObject layout and hierarchy; Added unit tests for TS parsing components; Added unit tests for audio codec sample rate and channel handling.

The project now officially supports Swift Package Manager (SPM) via new Package.swift and Package.resolved files, allowing developers to integrate HaishinKit and its sub-libraries (RTMP, SRT, MoQT, RTC) directly into their Swift projects. This update raises the minimum supported platforms to iOS/tvOS 15, macOS 12, and visionOS 1.3, and upgrades key dependencies including libdatachannel to 0.24.6, libsrt to 1.5.7, Logboard to 2.6.0, and the Swift DocC plugin to 1.4.5. The SPM manifest also configures Swift 6 and 5 language modes and enables concurrency features for modern Swift compatibility.

(dependencies) · high confidence

Written by watchdog.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

• CAI 72 → 71 (-0.7)
• Rubric changed (rubric-2026.09.11 → rubric-2026.09.18) — scores are not directly comparable.

• Code Health 92 → 91 (-0.9)
• Architecture 94 → 90 (-4.5)
• Maturity 82 → 82 (+0.0)
• Readiness 64 → 66 (+2.0)
• Security 68 → 78 (+10.8)
• Performance 68 (new)

• Documentation: no installation or build instructions (README.md)
• Documentation: no usage examples (README.md)
• Outdated: fastlane
• Outdated: rubocop

• AudioNode.description (cognitive 24) (HaishinKit/Sources/Mixer/AudioNode.swift)
• CVPixelBuffer.copy (cognitive 18) (HaishinKit/Sources/Extension/CVPixelBuffer+Extension.swift)
• Coverage not measured — Swift suite
• Duplicated block (10 lines × 3) (RTCHaishinKit/Sources/RTC/RTCDataChannel.swift)
• Duplicated block (10 lines × 4) (HaishinKit/Sources/Util/ByteArray.swift)
• Duplicated block (11 lines × 2) (Examples/iOS/InfoGuideView.swift)
• Duplicated block (11–12 lines × 2) (HaishinKit/Sources/Extension/CVPixelBuffer+Extension.swift)
• Duplicated block (13 lines × 2) (Examples/iOS/PublishView.swift)
• Duplicated block (18 lines × 2) (HaishinKit/Sources/Screen/TextScreenObject.swift)
• Duplicated block (6 lines × 2) (HaishinKit/Sources/Screen/TextScreenObject.swift)
• Duplicated block (9 lines × 2) (Examples/iOS/UVCView.swift)
• MethodTooLong: Format.cValue (HaishinKit/Sources/Codec/AudioCodecSettings.swift)
• MoQTSubscribe.payload (cognitive 18) (MoQTHaishinKit/Sources/ControlMessage/MoQTSubscribe.swift)
• No direct assertions: acceptsValidAuthority (HaishinKit/Tests/Session/StreamSessionBuilderFactoryTests.swift)
• No direct assertions: rejectsInvalidURL (HaishinKit/Tests/Session/StreamSessionBuilderFactoryTests.swift)
• No direct assertions: unsupportedScheme (HaishinKit/Tests/Session/StreamSessionBuilderFactoryTests.swift)
• Off the main sequence: HaishinKit
• Outdated: swift-docc-plugin
• Projects may be oversized for their cohesion
• Typographical error in property and parameter names: 'mamimum' instead of 'maximum'. This appears in both properties and the initializer parameter.
• …and 4 more

• 12 commits — 12 feature/other, 0 fixes

• (repo) — 5 commits
• (root) — 5 commits
• .github/workflows — 1 commit
• RTMPHaishinKit/Sources — 1 commit

• change: Bump fastlane from 2.238.0 to 2.240.1
• change: Bump rubocop from 1.90.0 to 1.91.0
• change: Clarify current Mac Catalyst support and build limitation
• change: Merge pull request #1942 from HaishinKit/dependabot/bundler/fastlane-2.240.1
• change: Merge pull request #1943 from HaishinKit/dependabot/bundler/rubocop-1.91.0
• change: Merge pull request #1947 from HaishinKit/codex/update-libsrt-1.5.7
• change: Merge pull request #1948 from HaishinKit/codex/update-libdatachannel-0.24.6
• change: Merge pull request #1950 from HaishinKit/codex/reject-malformed-stream-urls
• change: Reject malformed streaming URLs before connecting
• change: Update libdatachannel to 0.24.6 through its Swift package
• change: Update libsrt to 1.5.7 through its Swift package
• change: ci: update GitHub Actions and migrate to Xcode 26.6

Written by watchdog.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

HaishinKit/HaishinKit.swift was measured the same way every project in this corpus was: the same rubric, at a pinned commit, with the result published in full. Point a surveyor at a repository you know and see whether you agree with it.