Skip to main content

Crate pocketstation

Crate pocketstation 

Source
Expand description

§PocketStation

Capture one desktop application in Rust, keep its audio identifiable, and use the same capture for processing, delivery, and recording. Add a microphone only when the application needs a second independent source.

crates.io docs.rs license

desktop application ─┐
system audio ────────┼─ Session ─┬─ your Rust code
microphone ──────────┤           ├─ Operator or Connector
application PCM ─────┘           └─ one recording file per stem

PocketStation is for applications that need direct control of desktop audio: voice systems, meeting tools, broadcast workflows, transcription, monitoring, and local media automation. It is not an AI model, conferencing service, or general codec framework.

§Capture a running application

You need Rust 1.95 or newer and one supported desktop application producing audio.

cargo add pocketstation@1.1.13
use pocketstation::{Session, Source};

let session = Session::new();
session
    .capture(Source::application("Spotify"))?
    .send(session.polled_audio()?)?;
let mut running = session.start()?;

Replace Spotify with the exact display name or application identifier of a running application. PocketStation rejects an ambiguous match instead of silently choosing a process. The declaration is the same on macOS, Windows, and Linux; operating-system permissions and native build dependencies differ.

This example opens no microphone and writes no file. The quickstart includes application discovery, frame polling, a 10-second media deadline, optional microphone and recording arguments, and joined shutdown.

Run it from this repository:

cargo run --release --example quickstart --locked

The command lists running applications and asks which one to capture. It stops after receiving audio from every requested source. Add --microphone or --record recordings only when you want those features.

§Keep sources separate

Application, system, microphone, and application-owned PCM enter a Session as different stems. Every frame identifies its source, stream, stem, sequence, timestamp, clock, and continuity state. Sending two stems to the same provider does not mix them or erase where they came from.

use pocketstation::{Session, Source};

let session = Session::builder().recording_root("recordings").build();
let application = session.capture(Source::application("Zoom"))?;
let microphone = session.capture(Source::microphone_default())?;

application.record("application")?;
microphone.record("microphone")?;

Recording starts with the Session and finishes during Session shutdown. The final recording outcome reports which stems completed or failed. PocketStation does not present a partial recording as a successful one.

§Use one capture for several jobs

The package includes built-in echo cancellation through Session::echo_cancel. The native engine is excluded from default builds. Enable the aec Cargo feature explicitly; aec_available() reports whether it is included. Callers select the microphone and playback reference; Session registers the processor and owns its worker. Same-clock PCM integration is tested; physical double-talk and device-clock adaptation are not yet qualified. See echo cancellation for the supported inputs and current limitations.

A stem can feed several destinations at once:

  • application code that reads frames;
  • an Operator that turns audio into another signal, such as a transcript;
  • a Connector that sends audio to an external service;
  • another Operator or Endpoint with its own delivery settings;
  • multistem recording.

Each destination has its own queue and failure outcome. Slow model or network work runs outside the capture callback, so it does not become part of the operating-system audio callback.

Use capture and route audio to add a second source or destination. Use record and observe to inspect delivery, discontinuities, and final outcomes.

§Send audio to your own service

A Connector sends Session audio to an API, socket, file, or provider. For a destination that needs one function, PocketStation owns the worker and calls your function away from realtime capture:

use pocketstation::connector::Connector;
use pocketstation::{Session, Source};

let session = Session::new();
let application = session.capture(Source::application("Spotify"))?;
let destination = session.destination(Connector::from_audio_fn(|frame| {
    publish(frame.samples())
})?)?;

application.send(destination)?;

Implement AudioConnector when one provider connection needs start, send, and stop. Use the driver API only for distributable packages that need typed configuration, named inputs, service status, or provider-specific observations. The Connector guide explains both forms.

Use an Operator, not a Connector, when audio becomes a transcript, event, or new audio stream. Use a Source when an external system sends media into the Session. The extension guide explains custom Sources, Operators, Endpoints, native libraries, and managed processes.

§Write PCM your application already owns

Generated speech, call audio, and decoded network media can enter through audio_input() and use the same routing and recording APIs as captured audio. The input reports Full, Closed, Cancelled, and invalid-buffer outcomes; it does not hide backpressure in an unbounded application queue.

See write application-owned audio for the preallocated writer API and selective removal of output that should no longer be delivered.

§Understand delivery and failure

PocketStation prepares every Source, Operator, Connector, Endpoint, and recording destination before it opens the Session start gate. A setup failure rolls back prepared resources. Stopping a running Session joins its workers and returns one result that includes component and recording failures.

Use SessionStartCancellation::observed() when a caller needs to inspect native startup while Session::start_cancellable is still running. The token exposes 64 current-call slots and the first 128 completed native calls without audio samples or source identifiers. Cancellation is cooperative: it cannot interrupt an in-flight operating-system call. SessionStartError::rollback_failures_total() reports cleanup failures so callers can keep resources reserved when cleanup is uncertain. See capture and route for the observation limits and recovery behavior.

Realtime callbacks and realtime processing are checked to remain:

allocation-free · lock-free · blocking-free · async-free · log-free · panic-free

Queues and pools have configured capacities. When a queue fills, its delivery policy decides whether a frame is rejected or dropped, and observations report the event. Read delivery and failure before choosing settings for voice, recording, or model work.

§Handle permissions and source changes

Your application owns consent UI and source selection. PocketStation reports permission state, source loss, source generation changes, discontinuities, queue pressure, and recording results.

Check permission without prompting when the platform supports it. Store a discovered source only for its reported persistence scope. If the application or microphone disappears, stop the Session, discover again, confirm the new selection, and start another Session. PocketStation does not switch to a different source without the application deciding to do so.

The platform operations guide lists permission states, source persistence, recovery steps, and native prerequisites.

§Platform support

PlatformAvailable sourcesPublished evidence
macOSsystem, application, and microphonephysical system, application, and microphone capture; 10 ms application and microphone capture; Relay, Chromium, and multistem recording
Windowssystem, application, and microphoneautomated Windows 11 ARM64 VM selection and 10 ms capture; physical-device and latency qualification remain separate
LinuxPipeWire application/system and ALSA microphoneautomated Ubuntu selection and 10 ms capture; physical-device qualification remains separate

These records establish only the named environment and test. They do not establish identical device behavior, WAN/TURN performance, or one latency number for every computer.

Native prerequisites:

  • macOS: Xcode command-line tools;

  • Windows: MSVC Rust toolchain and Windows SDK;

  • Debian or Ubuntu:

    sudo apt install build-essential cmake pkg-config \
      libasound2-dev libpipewire-0.3-dev

Disable native capture when a tool only needs PocketStation types or docs:

pocketstation = { version = "1.1.14", default-features = false }

§Continue from the task you have

TaskGuide
Run the complete first captureRust quickstart
Capture and route application or microphone audioCapture and route
Write generated or received PCMApplication audio
Record stems and inspect deliveryRecord and observe
Send audio to an external serviceConnectors
Add a Source, Operator, Endpoint, library, or processExtensions
Understand Session start and shutdownSession lifecycle
Understand signals, identity, and timeSignals and streams
Read events, metrics, outcomes, and errorsEvents and errors
Find a public Rust typeAPI map or docs.rs
Prepare or troubleshoot a hostPlatform support and troubleshooting
Check an upgradeCompatibility and release notes

§Verify a local change

cargo fmt --all -- --check
cargo clippy --all-targets --all-features --locked -- -D warnings
cargo test --all-targets --all-features --locked
cargo build --release --example quickstart --locked
bash scripts/check_protocol.sh

These commands verify source and component behavior. Physical devices, cross-network delivery, and platform performance require separately recorded tests in those environments.

§License

PocketStation is available under the MIT or Apache-2.0 license.

Re-exports§

pub use crate::graph::AsyncNode;
pub use crate::graph::AsyncNodeFuture;
pub use crate::graph::AsyncOperatorFactory;
pub use crate::graph::AsyncOperatorManifest;
pub use crate::graph::AsyncOperatorManifestError;
pub use crate::graph::AsyncOperatorPrepareContext;
pub use crate::graph::AudioCaps;
pub use crate::graph::BackpressurePolicy;
pub use crate::graph::BinaryFormat;
pub use crate::graph::ChannelLayout;
pub use crate::graph::ClockDomain;
pub use crate::graph::Codec;
pub use crate::graph::ConfigError;
pub use crate::graph::CopyPolicy;
pub use crate::graph::DeliveryPolicy;
pub use crate::graph::DeliverySemantics;
pub use crate::graph::EventFormat;
pub use crate::graph::ExecutionPartition;
pub use crate::graph::ExecutionSafety;
pub use crate::graph::LossPolicy;
pub use crate::graph::MediaCaps;
pub use crate::graph::MediaKind;
pub use crate::graph::Multiplicity;
pub use crate::graph::NodeConfig as OperatorConfiguration;
pub use crate::graph::NodeDefinition;
pub use crate::graph::NodeDescriptor;
pub use crate::graph::NodeError;
pub use crate::graph::NodeTypeId;
pub use crate::graph::OperatorCancellationPolicy;
pub use crate::graph::OperatorDeadlinePolicy;
pub use crate::graph::OperatorFailurePolicy;
pub use crate::graph::OperatorId;
pub use crate::graph::OperatorOutputRolePolicy;
pub use crate::graph::OperatorPermissionPolicy;
pub use crate::graph::PortDirection;
pub use crate::graph::PortPrepareContext;
pub use crate::graph::PortSpec;
pub use crate::graph::RouteObservability;
pub use crate::graph::RouteSettings;
pub use crate::graph::SchemaRef;
pub use crate::graph::SemanticRole;
pub use crate::graph::SignalClass;
pub use crate::graph::SignalContinuityError;
pub use crate::graph::SignalContinuityObservation;
pub use crate::graph::SignalContinuityTracker;
pub use crate::graph::SignalDerivation;
pub use crate::graph::SignalDerivationError;
pub use crate::graph::SignalEnvelope;
pub use crate::graph::SignalEnvelopeError;
pub use crate::graph::SignalId;
pub use crate::graph::SignalLineage;
pub use crate::graph::SignalLineageError;
pub use crate::graph::SignalPayload;
pub use crate::graph::SignalSpec;
pub use crate::graph::SignalSpecError;
pub use crate::graph::SignalTiming;
pub use crate::graph::SignalTimingError;
pub use crate::graph::TextFormat;

Modules§

connector
graph
Stable signal, port, capability, partition, and extension APIs.
native_extension
timing
Timing primitives owned by the PocketStation runtime.

Structs§

ApplicationProcessSet
A frozen, canonical selection; native opening must admit every member.
AsyncOperatorObservations
AudioBufferHandle
AudioBufferPool
AudioFrame
AudioHistory
Source-aware replay and bounded context windows over finalized recordings. Source-aware replay and bounded context windows over finalized recordings. Source-aware replay and bounded context windows over finalized recordings. Read recent independently routed audio while its Session runs.
AudioHistoryConfig
Source-aware replay and bounded context windows over finalized recordings. Source-aware replay and bounded context windows over finalized recordings. Source-aware replay and bounded context windows over finalized recordings. Limits shared by all stems in one history. Oldest buffers are evicted first. PCM bytes and buffer count are separate limits; endpoint queues are separate.
AudioHistoryObservations
Source-aware replay and bounded context windows over finalized recordings. Source-aware replay and bounded context windows over finalized recordings. Source-aware replay and bounded context windows over finalized recordings.
AudioInput
Feeds audio already owned by the embedding application into a Session.
AudioInputBuffer
AudioInputConfig
AudioInputObservations
AudioInputWriteError
AudioInputWriter
AudioOutputWriteError
AudioProcessing
The actual input consumed to produce an audio frame.
CaptureAuthorizationSnapshot
Point-in-time authorization evidence for opening one exact capture source.
CaptureDelivery
Callback delivery endpoints transferred to a prepared native backend.
CaptureNativeFormat
Exact native PCM format accepted by the operating-system capture stream.
CaptureObservationHandle
CaptureObservations
CaptureOpenCancellation
Cooperative cancellation of a control-thread capture open.
CapturePermissionLifecycle
Control-plane owner for one source’s observed authorization epoch.
CapturePermissionTransition
One authoritative authorization-state transition observed by the host.
CaptureProcessingObservationHandle
Read-only processing observations for one opened stream. Reads belong on control threads, never native audio callbacks.
CaptureProcessingObservations
Processing facts reported by the backend for one opened capture stream.
CaptureProcessingReporter
Backend-owned writer for stream processing facts.
CaptureRuntimeFailure
CaptureSource
CapturedFrameObservationHandle
CapturedFrameSender
Single-producer endpoint passed into a platform capture callback.
CapturedFrameStreamStats
ClockDomainId
ConnectionSpec
The single Session connection declaration used for every stream origin and every operator/endpoint destination.
ConnectorId
DerivedStreamHandle
DeviceId
EchoAudioInput
A Session-owned audio source selected for echo processing.
EchoCancellationObservations
Local processing observations, readable after the Session stops.
EchoCancelledAudio
Processed audio and retained observations from one echo-cancellation instance.
EchoInputProcessing
What is known about echo processing upstream of an input.
EdgeObservations
EndpointAudioFrame
Read-only audio frame delivered to an external endpoint.
EndpointAudioReceiver
Exclusive consumer for one bounded realtime-audio endpoint edge.
EndpointCancellationOutcome
EndpointConfiguration
EndpointDescriptor
EndpointDriverFinalization
EndpointDriverObservations
EndpointFailure
EndpointGroupId
Explicit Session-scoped grouping key for endpoints that share one lifecycle.
EndpointHandle
EndpointId
EndpointPortInput
EndpointPrepareContext
EndpointRouteContext
Typed Session route identity supplied to every endpoint input.
EndpointSignalReceiver
Exclusive consumer for one bounded asynchronous signal endpoint edge.
EndpointStartGate
Read-only one-way start barrier shared by endpoint drivers in one startup.
FrameLineage
LocalSourceProvider
NativeAecRequest
Explicit request to pair microphone processing with one playback device.
NativeAecRoute
Backend-observed configuration of one opened native microphone route.
NativeAecRouteHandle
Immutable route metadata and allocation-free, lock-free validity observation.
NativeAecRouteReporter
Backend-owned revocation of facts for exactly one opened capture.
NativeCallObservations
Bounded, independently coherent call records, rather than a global instant.
NativeCallSpan
One native-call fact in the process monotonic nanosecond domain.
NativePlaybackReference
Explicit permission to use one playback device’s output mix as a native reference. No additional application or output recording is created by this declaration.
ObservedProcessInstance
A process identity observed before declaration, including its start time.
Operator
OperatorInputHandle
OperatorInstanceHandle
OperatorInstanceId
OperatorInstanceSpec
OutputGeneration
Keeps replaceable output attached to the operation that produced it.
OutputGenerationId
Core assigns no user, turn, model, or conversation meaning to this ID.
PcmSource
Low-level PCM source ownership for integrations that separately retain the Session handles and producer writer.
PermissionEpoch
PlanSourceInputObservations
PlaybackReference
Explicit permission to use an already-declared stream as an echo reference. This never opens, records or sends another application’s audio.
PolledAudioBatchLease
PolledAudioFrame
PolledAudioObservations
PolledAudioReceipt
ProcessId
RecordedAudio
Source-aware replay and bounded context windows over finalized recordings. Source-aware replay and bounded context windows over finalized recordings. Source-aware replay and bounded context windows over finalized recordings. An inspected finalized recording. This owns the bounded original manifest; every extraction rechecks it and the selected WAV on the same open handle. The caller owns authorization for this directory and schedules blocking I/O.
RecordedStem
Source-aware replay and bounded context windows over finalized recordings. Source-aware replay and bounded context windows over finalized recordings. Source-aware replay and bounded context windows over finalized recordings. Exact persisted identity and format of one independently recorded stem.
RecordingClip
Source-aware replay and bounded context windows over finalized recordings. Source-aware replay and bounded context windows over finalized recordings. Source-aware replay and bounded context windows over finalized recordings. A bounded float32 WAV clip with its original source and timing observations.
RecordingClipWindow
Source-aware replay and bounded context windows over finalized recordings. Source-aware replay and bounded context windows over finalized recordings. Source-aware replay and bounded context windows over finalized recordings. A half-open interval in the recording’s Session clock, in nanoseconds. Any external audio, text, telemetry or control detector may supply this interval.
RecordingDiscontinuity
Source-aware replay and bounded context windows over finalized recordings. Source-aware replay and bounded context windows over finalized recordings. Source-aware replay and bounded context windows over finalized recordings.
RouteId
RunningSession
SampleSpec
Session
SessionAudioReentryMetrics
Exact boundedness and lifecycle accounting for one operator PCM output re-entering the Session audio lane.
SessionBuilder
Setup-time configuration for the public Rust Session.
SessionCancelResult
SessionCompileDiagnostic
Stable, language-neutral location facts for one Session compilation error.
SessionControlFailure
Typed control-plane failure without exposing an implementation error type.
SessionDerivedRouteMetrics
SessionEvent
Event emitted by the session lifecycle authority.
SessionEventQueueObservations
Point-in-time observations for a session’s bounded control-event queue.
SessionExternalSourceMetrics
SessionId
SessionMetricsSnapshot
Point-in-time observations for the current Session.
SessionOperatorInputMetrics
SessionOperatorMetrics
SessionRecordingObservations
SessionRecordingOutcome
SessionRecordingReceipt
SessionRecordingStemOutcome
SessionRouteDropObservations
Explicit numerator, denominator, interval, and typed reasons for one route.
SessionRouteLatencyObservations
Common-clock source timestamp to route-receive latency in nanoseconds.
SessionRouteMetrics
SessionSidecarMetrics
Exact bounded-queue and process-lifecycle accounting for one Session-owned language-neutral sidecar.
SessionSourceActivityEvaluation
SessionSourceActivityObservations
Raw process-clock activity observed after a built-in Source frame leaves the capture queue and reaches the canonical Session runtime.
SessionSourceActivityPolicy
Caller-owned deadlines for evaluating Source delivery activity.
SessionSourceMetrics
SessionSourceNativeFormatObservation
Native acquisition format observed when one built-in Source opened.
SessionSourceProcessingObservations
Processing observations bound to the currently attached physical capture. Replacement or detach invalidates observations from the previous open.
SessionSourceReplacement
Result of one explicit built-in microphone replacement inside a running Session. The logical stem and every compiled route remain unchanged while physical source lineage advances.
SessionSourceReplacementObservations
Control-path accounting for explicit physical-source replacement.
SessionSourceSignalEvaluation
SessionSourceSignalObservations
Latest delivered PCM-window measurements for one built-in Source.
SessionSourceSignalPolicy
Caller-owned thresholds for interpreting one Source signal observation.
SessionStartCancellation
Thread-safe cancellation request for a Session that has not reached Running yet.
SessionStartError
Stable façade error for Session startup.
SessionStopOutcome
SessionStopResult
SessionTimelineOrigin
One Session-owned anchor in PocketStation’s monotonic nanosecond clock.
SessionTrace
SessionTraceRecord
SessionTraceRecorder
SessionTraceRecorderOutcome
SessionTraceTerminal
SessionTraceValidation
SharedAudioBufferHandle
SharedAudioFrame
SidecarDeadlines
SidecarHostSnapshot
SidecarMessage
SidecarProcessSpec
SidecarProtocolLimits
SourceCancellation
SourceConfiguration
SourceEmission
SourceGeneration
SourceId
SourceInstanceHandle
SourceInstanceId
SourceInstanceSpec
SourceManifest
SourceOutputHandle
SourceOutputIdentity
SourceOutputSpec
SourcePrepareContext
SourceRuntimeEventObservationHandle
SourceRuntimeEventObservations
SourceRuntimeEventSender
SourceRuntimeObservations
SourceSessionContext
SourceTypeId
StableSourceId
StemHandle
StemId
Stream
Typed Rust declaration façade compiled into stable dynamic signal, schema, port, and RouteSettings. This wrapper carries no frames and is not a generic runtime queue.
StreamId
TypedOperator

Enums§

ApplicationPolicyObservation
ApplicationSelector
AudioBufferWriteError
AudioFrameBuildError
AudioFrameDuration
Fixed audio cadence used by capture and Session routing.
AudioHistoryDeclarationError
AudioHistoryError
Source-aware replay and bounded context windows over finalized recordings. Source-aware replay and bounded context windows over finalized recordings. Source-aware replay and bounded context windows over finalized recordings.
AudioHistoryState
Source-aware replay and bounded context windows over finalized recordings. Source-aware replay and bounded context windows over finalized recordings. Source-aware replay and bounded context windows over finalized recordings.
AudioInputBufferAcquireError
AudioInputBufferError
AudioInputConfigError
AudioInputError
AudioInputWriteErrorKind
AudioOutputWriteErrorKind
CaptureCapabilityState
CaptureError
CaptureMode
CaptureOpenFailure
Failed or cancelled acquisition, retaining a separate cleanup failure.
CaptureOpenOutcome
CaptureRuntimeFailureClass
CaptureSampleRepresentation
Native PCM representation opened by a capture backend before conversion to PocketStation’s canonical interleaved f32 signal.
CaptureScope
CaptureSessionGrant
CapturedFrameDelivery
ConnectionTarget
Stable destination of a declared Session connection.
DeviceSelector
EchoCancellationState
Processor lifecycle; Processing does not assert acoustic convergence.
EndpointFailureRetryability
Machine-readable recovery classification retained in Session outcomes.
EndpointFailureStage
EndpointInputOrigin
Provenance of one endpoint input, independent of its physical receiver.
EndpointPreparationGroup
Factory-owned decision for batching endpoint inputs into one lifecycle.
EndpointReceiver
EndpointShutdownMode
Session shutdown intent delivered to an active endpoint.
FrameLineageBuildError
InputDeviceSelector
NativeCallOperation
Static control-call names; values never contain source or device identity.
OutputCancelResult
OutputGenerationError
PermissionObservation
Platform
PolledAudioPollError
PolledAudioPollErrorCode
Stable language-neutral code for bounded polled-audio status.
ProcessSetError
Control-path failures for declaring and admitting an exact process set.
ProcessTreeScope
RecordingClipError
Source-aware replay and bounded context windows over finalized recordings. Source-aware replay and bounded context windows over finalized recordings. Source-aware replay and bounded context windows over finalized recordings. Typed failure of recording inspection or bounded clip extraction.
RecordingDiscontinuityKind
Source-aware replay and bounded context windows over finalized recordings. Source-aware replay and bounded context windows over finalized recordings. Source-aware replay and bounded context windows over finalized recordings.
RouteLatencyMeasurement
Identifies the timestamps used to calculate route latency.
SampleFormat
SelectorPersistenceScope
SessionCancelDisposition
SessionComponentId
Stable identity of the component that produced a session control failure.
SessionDeclarationErrorCode
Stable language-neutral code for a Session declaration failure.
SessionEndpointError
SessionError
SessionEventKind
Payload of one authoritative session event.
SessionEventReceive
Result of non-blocking event polling.
SessionLifecycleState
Public lifecycle states emitted by a running session.
SessionOperatorError
SessionRecordingErrorCode
Stable language-neutral code for a recording failure.
SessionRecordingState
SessionRouteLatencyUnit
SessionRouteObservationInterval
Interval covered by monotonic route counters.
SessionRuntimeError
SessionRuntimeErrorCode
Stable language-neutral code for a running-Session binding failure.
SessionSidecarError
SessionSourceActivityPolicyError
SessionSourceActivityState
SessionSourceError
SessionSourceReplacementError
SessionSourceSignalPolicyError
SessionSourceSignalState
SessionStartErrorCode
Stable language-neutral code for Session startup.
SessionStartErrorKind
SessionStopCode
Stable language-neutral status for an idempotent Session stop.
SessionStopDisposition
SessionStopFailureCode
Stable language-neutral cause retained by a failed Session stop.
SessionTerminalState
Final state carried by the terminal session event.
SessionTraceRecordKind
SessionTraceRecorderFinishError
SessionTraceRecorderStartError
SessionTraceValidationError
SidecarHostError
SidecarMessageKind
SidecarState
Source
SourceDriverError
SourceIdentityStrength
SourceKind
SourceLifecycleEventKind
SourceManifestError
SourceQuery
SourceRecoveryRequirement
SourceRegistrationError
SourceRuntimeEvent
SourceRuntimeEventDelivery
SourceState
SourceTypeIdError
StreamOrigin
Stable origin of a declared Session stream.
TypedStreamError

Constants§

DEFAULT_MULTISTEM_RECORDING_GROUP_ID
MAX_APPLICATION_PROCESS_SET_MEMBERS
Maximum number of independently observed processes in one exact capture.
MAX_RECORDING_CLIP_BYTES
Source-aware replay and bounded context windows over finalized recordings. Source-aware replay and bounded context windows over finalized recordings. Source-aware replay and bounded context windows over finalized recordings. Maximum encoded WAV bytes returned by one clip request (32 MiB).
NATIVE_CALL_COMPLETED_CAPACITY
First completed calls retained by one observed cancellation token.
NATIVE_CALL_CURRENT_CAPACITY
Maximum independently observed capture opens on one cancellation token.
PCM_SOURCE_TYPE_ID
Stable runtime identity of the underlying PCM source implementation.
SESSION_RECORDING_MANIFEST_FILE_NAME
SESSION_RECORDING_MANIFEST_SCHEMA_VERSION

Traits§

ActiveCaptureBackend
Native capture resources owned for exactly one active capture.
CallbackCaptureBackend
Platform-neutral prepare/open API for callback-oriented capture.
EndpointDriverFactory
PreparedCaptureBackend
Backend state that has passed validation but has not started delivery.
PreparedEndpointDriver
Prepared endpoint resources that have not started consuming their edge.
RunningEndpointDriver
Active endpoint resources owned until finalization.
SourceDriver
SourceFactory
SourceProvider
StreamSignal
Compile-time marker supplied by an SDK or external package.

Functions§

aec_available
Whether this build includes the AEC engine. This does not qualify a device route.
application_capture_available
Reports whether this host exposes the native application-capture facility.
capture_processing_observations
Creates an initially unknown observation pair for one capture open.
discover_process_instances
Discovers process instances with usable original start observations.
discover_sources
microphone_permission_observation
Reads the current microphone authorization state without prompting.
native_aec_route
Creates backend-owned configuration evidence for one opened capture.
polled_audio_poll_error_code
resolve_query
session_declaration_error_code
session_recording_outcome_error_code
session_start_failure_code

Type Aliases§

AsyncOperatorOutputObservations