repo stringlengths 6 65 | file_url stringlengths 81 311 | file_path stringlengths 6 227 | content stringlengths 0 32.8k | language stringclasses 1
value | license stringclasses 7
values | commit_sha stringlengths 40 40 | retrieved_at stringdate 2026-01-04 15:31:58 2026-01-04 20:25:31 | truncated bool 2
classes |
|---|---|---|---|---|---|---|---|---|
rerun-io/rerun | https://github.com/rerun-io/rerun/blob/910b1e72ca3ceb352b0bcf0d8d7de4f6bf4d19d0/crates/utils/re_memory/src/memory_limit.rs | crates/utils/re_memory/src/memory_limit.rs | use saturating_cast::SaturatingCast as _;
/// Represents a limit in how much RAM to use for the entire process.
///
/// Different systems can chose to heed the memory limit in different ways,
/// e.g. by dropping old data when it is exceeded.
///
/// It is recommended that they log using [`re_log::info_once`] when the... | rust | Apache-2.0 | 910b1e72ca3ceb352b0bcf0d8d7de4f6bf4d19d0 | 2026-01-04T15:43:37.979050Z | false |
rerun-io/rerun | https://github.com/rerun-io/rerun/blob/910b1e72ca3ceb352b0bcf0d8d7de4f6bf4d19d0/crates/utils/re_memory/src/lib.rs | crates/utils/re_memory/src/lib.rs | //! Run-time memory tracking and profiling.
//!
//! ## First steps
//!
//! Add `re_memory` to your `Cargo.toml`:
//!
//! ```toml
//! cargo add re_memory
//! ```
//!
//! Install the [`AccountingAllocator`] in your `main.rs`:
//! ```no_run
//! use re_memory::AccountingAllocator;
//!
//! #[global_allocator]
//! static GLO... | rust | Apache-2.0 | 910b1e72ca3ceb352b0bcf0d8d7de4f6bf4d19d0 | 2026-01-04T15:43:37.979050Z | false |
rerun-io/rerun | https://github.com/rerun-io/rerun/blob/910b1e72ca3ceb352b0bcf0d8d7de4f6bf4d19d0/crates/utils/re_memory/src/peak_memory_stats.rs | crates/utils/re_memory/src/peak_memory_stats.rs | //! Monitor memory use periodically, and capture the stacktraces at the high water mark.
use std::thread::JoinHandle;
use crossbeam::channel::{Receiver, Sender};
use crate::TrackingStatistics;
use crate::accounting_allocator::{self, is_tracking_callstacks};
struct Shutdown;
/// Collects [`TrackingStatistics`] at t... | rust | Apache-2.0 | 910b1e72ca3ceb352b0bcf0d8d7de4f6bf4d19d0 | 2026-01-04T15:43:37.979050Z | false |
rerun-io/rerun | https://github.com/rerun-io/rerun/blob/910b1e72ca3ceb352b0bcf0d8d7de4f6bf4d19d0/crates/utils/re_memory/src/util.rs | crates/utils/re_memory/src/util.rs | //! Utitility functions
/// Returns monotonically increasing time in seconds.
#[inline]
pub fn sec_since_start() -> f64 {
use web_time::Instant;
static START_INSTANT: std::sync::LazyLock<Instant> = std::sync::LazyLock::new(Instant::now);
START_INSTANT.elapsed().as_nanos() as f64 / 1e9
}
| rust | Apache-2.0 | 910b1e72ca3ceb352b0bcf0d8d7de4f6bf4d19d0 | 2026-01-04T15:43:37.979050Z | false |
rerun-io/rerun | https://github.com/rerun-io/rerun/blob/910b1e72ca3ceb352b0bcf0d8d7de4f6bf4d19d0/crates/utils/re_memory/src/backtrace_web.rs | crates/utils/re_memory/src/backtrace_web.rs | use wasm_bindgen::prelude::*;
#[wasm_bindgen]
extern "C" {
#[wasm_bindgen(js_namespace = console)]
fn error(msg: String);
type Error;
#[wasm_bindgen(constructor)]
fn new() -> Error;
#[wasm_bindgen(structural, method, getter)]
fn stack(error: &Error) -> String;
}
#[derive(Hash)]
pub(crat... | rust | Apache-2.0 | 910b1e72ca3ceb352b0bcf0d8d7de4f6bf4d19d0 | 2026-01-04T15:43:37.979050Z | false |
rerun-io/rerun | https://github.com/rerun-io/rerun/blob/910b1e72ca3ceb352b0bcf0d8d7de4f6bf4d19d0/crates/utils/re_memory/src/ram_warner.rs | crates/utils/re_memory/src/ram_warner.rs | /// Amount of available RAM on this machine.
#[cfg(not(target_arch = "wasm32"))]
pub fn total_ram_in_bytes() -> Option<u64> {
re_tracing::profile_function!();
let mut sys = sysinfo::System::new_with_specifics(
sysinfo::RefreshKind::new().with_memory(sysinfo::MemoryRefreshKind::new().with_ram()),
);... | rust | Apache-2.0 | 910b1e72ca3ceb352b0bcf0d8d7de4f6bf4d19d0 | 2026-01-04T15:43:37.979050Z | false |
rerun-io/rerun | https://github.com/rerun-io/rerun/blob/910b1e72ca3ceb352b0bcf0d8d7de4f6bf4d19d0/crates/utils/re_memory/src/allocation_tracker.rs | crates/utils/re_memory/src/allocation_tracker.rs | use std::sync::Arc;
use crate::{Backtrace, BacktraceHash, CountAndSize};
// ----------------------------------------------------------------------------
/// A hash of a pointer address.
#[derive(Copy, Clone, Debug, Hash, PartialEq, Eq)]
pub struct PtrHash(u64);
impl nohash_hasher::IsEnabled for PtrHash {}
impl Ptr... | rust | Apache-2.0 | 910b1e72ca3ceb352b0bcf0d8d7de4f6bf4d19d0 | 2026-01-04T15:43:37.979050Z | false |
rerun-io/rerun | https://github.com/rerun-io/rerun/blob/910b1e72ca3ceb352b0bcf0d8d7de4f6bf4d19d0/crates/utils/re_memory/src/accounting_allocator.rs | crates/utils/re_memory/src/accounting_allocator.rs | //! Track allocations and memory use.
use std::sync::LazyLock;
use std::sync::atomic::Ordering::Relaxed;
use std::sync::atomic::{AtomicBool, AtomicUsize};
use parking_lot::Mutex;
use crate::CountAndSize;
use crate::allocation_tracker::{AllocationTracker, CallstackStatistics, PtrHash};
// TODO(emilk): yet another ti... | rust | Apache-2.0 | 910b1e72ca3ceb352b0bcf0d8d7de4f6bf4d19d0 | 2026-01-04T15:43:37.979050Z | false |
rerun-io/rerun | https://github.com/rerun-io/rerun/blob/910b1e72ca3ceb352b0bcf0d8d7de4f6bf4d19d0/crates/utils/re_memory/src/backtrace_native.rs | crates/utils/re_memory/src/backtrace_native.rs | use std::sync::Arc;
pub(crate) struct Backtrace(backtrace::Backtrace);
impl Backtrace {
pub fn new_unresolved() -> Self {
Self(backtrace::Backtrace::new_unresolved())
}
pub fn format(&mut self) -> Arc<str> {
self.0.resolve();
let stack = backtrace_to_string(&self.0);
trim_... | rust | Apache-2.0 | 910b1e72ca3ceb352b0bcf0d8d7de4f6bf4d19d0 | 2026-01-04T15:43:37.979050Z | false |
rerun-io/rerun | https://github.com/rerun-io/rerun/blob/910b1e72ca3ceb352b0bcf0d8d7de4f6bf4d19d0/crates/utils/re_capabilities/src/main_thread_token.rs | crates/utils/re_capabilities/src/main_thread_token.rs | use static_assertions::assert_not_impl_any;
/// A token that (almost) proves we are on the main thread.
///
/// Certain operations are only allowed on the main thread.
/// These operations should require this token.
/// For instance, any function using file dialogs (e.g. using [`rfd`](https://docs.rs/rfd/latest/rfd/))... | rust | Apache-2.0 | 910b1e72ca3ceb352b0bcf0d8d7de4f6bf4d19d0 | 2026-01-04T15:43:37.979050Z | false |
rerun-io/rerun | https://github.com/rerun-io/rerun/blob/910b1e72ca3ceb352b0bcf0d8d7de4f6bf4d19d0/crates/utils/re_capabilities/src/lib.rs | crates/utils/re_capabilities/src/lib.rs | //! Specifies capability tokens, required by different parts of the code base.
//! These are tokens passed down the call tree, to explicitly allow different capabilities in different parts of the code base.
//!
//! For instance, the [`MainThreadToken`] is taken by argument in functions that needs to run on the main thr... | rust | Apache-2.0 | 910b1e72ca3ceb352b0bcf0d8d7de4f6bf4d19d0 | 2026-01-04T15:43:37.979050Z | false |
rerun-io/rerun | https://github.com/rerun-io/rerun/blob/910b1e72ca3ceb352b0bcf0d8d7de4f6bf4d19d0/crates/utils/re_byte_size/src/lib.rs | crates/utils/re_byte_size/src/lib.rs | //! Calculate the heap-allocated size of values at runtime.
mod arrow_sizes;
mod primitive_sizes;
mod smallvec_sizes;
mod std_sizes;
mod tuple_sizes;
// ---
/// Approximations of stack and heap size for both internal and external types.
///
/// Motly used for statistics and triggering events such as garbage collecti... | rust | Apache-2.0 | 910b1e72ca3ceb352b0bcf0d8d7de4f6bf4d19d0 | 2026-01-04T15:43:37.979050Z | false |
rerun-io/rerun | https://github.com/rerun-io/rerun/blob/910b1e72ca3ceb352b0bcf0d8d7de4f6bf4d19d0/crates/utils/re_byte_size/src/std_sizes.rs | crates/utils/re_byte_size/src/std_sizes.rs | //! Implement [`SizeBytes`] for things in the standard library.
use std::collections::{BTreeMap, BTreeSet, HashMap, HashSet, VecDeque};
use std::sync::Arc;
use crate::SizeBytes;
impl SizeBytes for String {
#[inline]
fn heap_size_bytes(&self) -> u64 {
self.capacity() as u64
}
}
impl<K: SizeBytes,... | rust | Apache-2.0 | 910b1e72ca3ceb352b0bcf0d8d7de4f6bf4d19d0 | 2026-01-04T15:43:37.979050Z | false |
rerun-io/rerun | https://github.com/rerun-io/rerun/blob/910b1e72ca3ceb352b0bcf0d8d7de4f6bf4d19d0/crates/utils/re_byte_size/src/tuple_sizes.rs | crates/utils/re_byte_size/src/tuple_sizes.rs | use crate::SizeBytes;
impl<T, U> SizeBytes for (T, U)
where
T: SizeBytes,
U: SizeBytes,
{
#[inline]
fn heap_size_bytes(&self) -> u64 {
let (a, b) = self;
a.heap_size_bytes() + b.heap_size_bytes()
}
#[inline]
fn is_pod() -> bool {
T::is_pod() && U::is_pod()
}
}
... | rust | Apache-2.0 | 910b1e72ca3ceb352b0bcf0d8d7de4f6bf4d19d0 | 2026-01-04T15:43:37.979050Z | false |
rerun-io/rerun | https://github.com/rerun-io/rerun/blob/910b1e72ca3ceb352b0bcf0d8d7de4f6bf4d19d0/crates/utils/re_byte_size/src/primitive_sizes.rs | crates/utils/re_byte_size/src/primitive_sizes.rs | use crate::SizeBytes;
// TODO(rust-lang/rust#31844): This isn't happening without specialization.
// impl<T> SizeBytes for T where T: bytemuck::Pod { … }
// TODO(rust-lang/rust#31844): `impl<T: bytemuck::Pod> SizeBytesExt for T {}` would be nice but
// violates orphan rules.
macro_rules! impl_size_bytes_pod {
($t... | rust | Apache-2.0 | 910b1e72ca3ceb352b0bcf0d8d7de4f6bf4d19d0 | 2026-01-04T15:43:37.979050Z | false |
rerun-io/rerun | https://github.com/rerun-io/rerun/blob/910b1e72ca3ceb352b0bcf0d8d7de4f6bf4d19d0/crates/utils/re_byte_size/src/smallvec_sizes.rs | crates/utils/re_byte_size/src/smallvec_sizes.rs | use smallvec::SmallVec;
use crate::SizeBytes;
impl<T: SizeBytes, const N: usize> SizeBytes for SmallVec<[T; N]> {
/// Does not take capacity into account.
#[inline]
fn heap_size_bytes(&self) -> u64 {
if self.len() <= N {
// The `SmallVec` is still smaller than the threshold so no heap ... | rust | Apache-2.0 | 910b1e72ca3ceb352b0bcf0d8d7de4f6bf4d19d0 | 2026-01-04T15:43:37.979050Z | false |
rerun-io/rerun | https://github.com/rerun-io/rerun/blob/910b1e72ca3ceb352b0bcf0d8d7de4f6bf4d19d0/crates/utils/re_byte_size/src/arrow_sizes.rs | crates/utils/re_byte_size/src/arrow_sizes.rs | use arrow::array::{Array, ArrayRef, ListArray, RecordBatch};
use arrow::buffer::ScalarBuffer;
use arrow::datatypes::{ArrowNativeType, DataType, Field, Fields, Schema, UnionFields};
use super::SizeBytes;
impl SizeBytes for dyn Array {
#[inline]
fn heap_size_bytes(&self) -> u64 {
array_slice_memory_size... | rust | Apache-2.0 | 910b1e72ca3ceb352b0bcf0d8d7de4f6bf4d19d0 | 2026-01-04T15:43:37.979050Z | false |
rerun-io/rerun | https://github.com/rerun-io/rerun/blob/910b1e72ca3ceb352b0bcf0d8d7de4f6bf4d19d0/crates/utils/re_tracing/src/lib.rs | crates/utils/re_tracing/src/lib.rs | //! Helpers for tracing/spans/flamegraphs and such.
#[cfg(not(target_arch = "wasm32"))]
#[cfg(feature = "server")]
mod server;
#[cfg(not(target_arch = "wasm32"))]
#[cfg(feature = "server")]
pub use server::Profiler;
pub mod reexports {
#[cfg(not(target_arch = "wasm32"))]
pub use puffin;
}
/// Create a profi... | rust | Apache-2.0 | 910b1e72ca3ceb352b0bcf0d8d7de4f6bf4d19d0 | 2026-01-04T15:43:37.979050Z | false |
rerun-io/rerun | https://github.com/rerun-io/rerun/blob/910b1e72ca3ceb352b0bcf0d8d7de4f6bf4d19d0/crates/utils/re_tracing/src/server.rs | crates/utils/re_tracing/src/server.rs | const PORT: u16 = puffin_http::DEFAULT_PORT;
/// Wraps a connection to a [`puffin`] viewer.
#[derive(Default)]
pub struct Profiler {
server: Option<puffin_http::Server>,
}
impl Drop for Profiler {
fn drop(&mut self) {
// Commit the last stuff:
puffin::GlobalProfiler::lock().new_frame();
}
... | rust | Apache-2.0 | 910b1e72ca3ceb352b0bcf0d8d7de4f6bf4d19d0 | 2026-01-04T15:43:37.979050Z | false |
rerun-io/rerun | https://github.com/rerun-io/rerun/blob/910b1e72ca3ceb352b0bcf0d8d7de4f6bf4d19d0/crates/utils/re_analytics/src/event.rs | crates/utils/re_analytics/src/event.rs | // This file is linked to in a number of places, do not move/rename it without updating all the links!
//! All analytics events collected by the Rerun viewer are defined in this file.
//!
//! Analytics can be completely disabled with `rerun analytics disable`,
//! or by compiling rerun without the `analytics` feature ... | rust | Apache-2.0 | 910b1e72ca3ceb352b0bcf0d8d7de4f6bf4d19d0 | 2026-01-04T15:43:37.979050Z | false |
rerun-io/rerun | https://github.com/rerun-io/rerun/blob/910b1e72ca3ceb352b0bcf0d8d7de4f6bf4d19d0/crates/utils/re_analytics/src/posthog.rs | crates/utils/re_analytics/src/posthog.rs | use std::collections::HashMap;
use jiff::Timestamp;
use crate::{AnalyticsEvent, Property};
/// The "public" API key can be obtained at <https://eu.posthog.com/project/settings#project-api-key>.
/// Make sure you are logged in to the right organization and have the correct project open.
/// Unfortunately that stuff i... | rust | Apache-2.0 | 910b1e72ca3ceb352b0bcf0d8d7de4f6bf4d19d0 | 2026-01-04T15:43:37.979050Z | false |
rerun-io/rerun | https://github.com/rerun-io/rerun/blob/910b1e72ca3ceb352b0bcf0d8d7de4f6bf4d19d0/crates/utils/re_analytics/src/lib.rs | crates/utils/re_analytics/src/lib.rs | //! Rerun's analytics SDK.
//!
//! We never collect any personal identifiable information.
//! You can always opt-out with `rerun analytics disable`.
//!
//! No analytics will be collected the first time you start the Rerun viewer,
//! giving you an opportunity to opt-out first if you wish.
//!
//! All the data we coll... | rust | Apache-2.0 | 910b1e72ca3ceb352b0bcf0d8d7de4f6bf4d19d0 | 2026-01-04T15:43:37.979050Z | false |
rerun-io/rerun | https://github.com/rerun-io/rerun/blob/910b1e72ca3ceb352b0bcf0d8d7de4f6bf4d19d0/crates/utils/re_analytics/src/cli.rs | crates/utils/re_analytics/src/cli.rs | use std::path::Path;
use crate::{AnalyticsError, Config, ConfigError, Property};
// ---
#[derive(thiserror::Error, Debug)]
pub enum CliError {
#[error(transparent)]
Config(#[from] ConfigError),
#[error(transparent)]
Analytics(#[from] AnalyticsError),
#[error(transparent)]
Io(#[from] std::io... | rust | Apache-2.0 | 910b1e72ca3ceb352b0bcf0d8d7de4f6bf4d19d0 | 2026-01-04T15:43:37.979050Z | false |
rerun-io/rerun | https://github.com/rerun-io/rerun/blob/910b1e72ca3ceb352b0bcf0d8d7de4f6bf4d19d0/crates/utils/re_analytics/src/native/config.rs | crates/utils/re_analytics/src/native/config.rs | use std::collections::HashMap;
use std::fs::File;
use std::io::BufReader;
use std::path::{Path, PathBuf};
use directories::ProjectDirs;
use uuid::Uuid;
use crate::Property;
#[derive(thiserror::Error, Debug)]
pub enum ConfigError {
#[error("Couldn't compute config location")]
UnknownLocation,
#[error(tra... | rust | Apache-2.0 | 910b1e72ca3ceb352b0bcf0d8d7de4f6bf4d19d0 | 2026-01-04T15:43:37.979050Z | false |
rerun-io/rerun | https://github.com/rerun-io/rerun/blob/910b1e72ca3ceb352b0bcf0d8d7de4f6bf4d19d0/crates/utils/re_analytics/src/native/sink.rs | crates/utils/re_analytics/src/native/sink.rs | use std::sync::Arc;
use super::AbortSignal;
use crate::{AnalyticsEvent, PostHogBatch, PostHogEvent};
#[derive(Default, Debug, Clone)]
pub(crate) struct PostHogSink {}
impl PostHogSink {
/// Our public telemetry endpoint.
const URL: &'static str = "https://tel.rerun.io";
#[expect(clippy::unused_self)]
... | rust | Apache-2.0 | 910b1e72ca3ceb352b0bcf0d8d7de4f6bf4d19d0 | 2026-01-04T15:43:37.979050Z | false |
rerun-io/rerun | https://github.com/rerun-io/rerun/blob/910b1e72ca3ceb352b0bcf0d8d7de4f6bf4d19d0/crates/utils/re_analytics/src/native/mod.rs | crates/utils/re_analytics/src/native/mod.rs | mod config;
mod pipeline;
mod sink;
use std::sync::Arc;
use std::sync::atomic::{AtomicBool, Ordering};
pub use config::{Config, ConfigError};
pub use pipeline::{Pipeline, PipelineError};
#[derive(Default, Clone)]
pub(crate) struct AbortSignal {
aborted: Arc<AtomicBool>,
}
impl AbortSignal {
pub(crate) fn ne... | rust | Apache-2.0 | 910b1e72ca3ceb352b0bcf0d8d7de4f6bf4d19d0 | 2026-01-04T15:43:37.979050Z | false |
rerun-io/rerun | https://github.com/rerun-io/rerun/blob/910b1e72ca3ceb352b0bcf0d8d7de4f6bf4d19d0/crates/utils/re_analytics/src/native/pipeline.rs | crates/utils/re_analytics/src/native/pipeline.rs | use std::fs::{File, OpenOptions};
use std::io::{BufRead as _, BufReader, Seek as _, Write as _};
use std::sync::Arc;
use std::time::Duration;
use crossbeam::{channel, select};
use super::AbortSignal;
use super::sink::PostHogSink;
use crate::{AnalyticsEvent, Config, FlushError};
// This is the environment variable th... | rust | Apache-2.0 | 910b1e72ca3ceb352b0bcf0d8d7de4f6bf4d19d0 | 2026-01-04T15:43:37.979050Z | false |
rerun-io/rerun | https://github.com/rerun-io/rerun/blob/910b1e72ca3ceb352b0bcf0d8d7de4f6bf4d19d0/crates/utils/re_analytics/src/web/config.rs | crates/utils/re_analytics/src/web/config.rs | #![expect(clippy::unused_self)]
use std::collections::HashMap;
use uuid::Uuid;
use web_sys::Storage;
use crate::Property;
#[derive(thiserror::Error, Debug)]
pub enum ConfigError {
#[error("failed to get localStorage")]
NoStorage,
#[error("{0}")]
Storage(String),
#[error(transparent)]
Io(#[... | rust | Apache-2.0 | 910b1e72ca3ceb352b0bcf0d8d7de4f6bf4d19d0 | 2026-01-04T15:43:37.979050Z | false |
rerun-io/rerun | https://github.com/rerun-io/rerun/blob/910b1e72ca3ceb352b0bcf0d8d7de4f6bf4d19d0/crates/utils/re_analytics/src/web/mod.rs | crates/utils/re_analytics/src/web/mod.rs | mod config;
mod pipeline;
pub use config::{Config, ConfigError};
pub use pipeline::{Pipeline, PipelineError};
| rust | Apache-2.0 | 910b1e72ca3ceb352b0bcf0d8d7de4f6bf4d19d0 | 2026-01-04T15:43:37.979050Z | false |
rerun-io/rerun | https://github.com/rerun-io/rerun/blob/910b1e72ca3ceb352b0bcf0d8d7de4f6bf4d19d0/crates/utils/re_analytics/src/web/pipeline.rs | crates/utils/re_analytics/src/web/pipeline.rs | #![expect(clippy::needless_pass_by_value, clippy::unnecessary_wraps)]
use std::sync::Arc;
use std::time::Duration;
use crate::{AnalyticsEvent, Config, PostHogBatch, PostHogEvent};
#[derive(thiserror::Error, Debug)]
pub enum PipelineError {
#[error(transparent)]
Io(#[from] std::io::Error),
#[error(transp... | rust | Apache-2.0 | 910b1e72ca3ceb352b0bcf0d8d7de4f6bf4d19d0 | 2026-01-04T15:43:37.979050Z | false |
rerun-io/rerun | https://github.com/rerun-io/rerun/blob/910b1e72ca3ceb352b0bcf0d8d7de4f6bf4d19d0/crates/utils/re_analytics/examples/end_to_end.rs | crates/utils/re_analytics/examples/end_to_end.rs | use re_analytics::{Analytics, AnalyticsEvent, Event, Properties};
fn main() -> Result<(), Box<dyn std::error::Error>> {
re_log::setup_logging();
let analytics = Analytics::global_or_init().expect("Failed to initialize analytics");
let application_id = "end_to_end_example".to_owned();
let recording_id ... | rust | Apache-2.0 | 910b1e72ca3ceb352b0bcf0d8d7de4f6bf4d19d0 | 2026-01-04T15:43:37.979050Z | false |
rerun-io/rerun | https://github.com/rerun-io/rerun/blob/910b1e72ca3ceb352b0bcf0d8d7de4f6bf4d19d0/crates/utils/re_tuid/src/lib.rs | crates/utils/re_tuid/src/lib.rs | //! TUID: Time-based Unique Identifiers.
//!
//! Time-ordered unique 128-bit identifiers.
//!
//! ## Format
//! The default string format is big-endian hex, e.g. `182342300C5F8C327a7b4a6e5a379ac4`.
//! This means the string representation sorts the same.
//!
//! ## Namespace prefix
//! It is common to prefix an TUID wi... | rust | Apache-2.0 | 910b1e72ca3ceb352b0bcf0d8d7de4f6bf4d19d0 | 2026-01-04T15:43:37.979050Z | false |
rerun-io/rerun | https://github.com/rerun-io/rerun/blob/910b1e72ca3ceb352b0bcf0d8d7de4f6bf4d19d0/crates/utils/re_tuid/benches/bench_tuid.rs | crates/utils/re_tuid/benches/bench_tuid.rs | use criterion::{Criterion, criterion_group, criterion_main};
fn bench_tuid(c: &mut Criterion) {
let mut group = c.benchmark_group("tuid");
group.throughput(criterion::Throughput::Elements(1));
group.bench_function("Tuid::new", |b| {
b.iter(|| criterion::black_box(re_tuid::Tuid::new()));
});
... | rust | Apache-2.0 | 910b1e72ca3ceb352b0bcf0d8d7de4f6bf4d19d0 | 2026-01-04T15:43:37.979050Z | false |
rerun-io/rerun | https://github.com/rerun-io/rerun/blob/910b1e72ca3ceb352b0bcf0d8d7de4f6bf4d19d0/crates/utils/re_perf_telemetry/src/tracestate.rs | crates/utils/re_perf_telemetry/src/tracestate.rs | use std::collections::HashMap;
use opentelemetry::Context;
use opentelemetry::propagation::{Extractor, Injector, TextMapPropagator};
use opentelemetry::trace::TraceContextExt as _;
/// A propagator that enriches `tracestate` with additional key-value pairs
#[derive(Debug, Clone)]
pub struct TraceStateEnricher {
a... | rust | Apache-2.0 | 910b1e72ca3ceb352b0bcf0d8d7de4f6bf4d19d0 | 2026-01-04T15:43:37.979050Z | false |
rerun-io/rerun | https://github.com/rerun-io/rerun/blob/910b1e72ca3ceb352b0bcf0d8d7de4f6bf4d19d0/crates/utils/re_perf_telemetry/src/grpc.rs | crates/utils/re_perf_telemetry/src/grpc.rs | // Some well-known headers that we want to re-surface all the way up to the root of the active trace.
//
// See `re_protos::headers`.
const RERUN_HTTP_HEADER_ENTRY_ID: &str = "x-rerun-entry-id";
const RERUN_HTTP_HEADER_CLIENT_VERSION: &str = "x-rerun-client-version";
const RERUN_HTTP_HEADER_SERVER_VERSION: &str = "x-r... | rust | Apache-2.0 | 910b1e72ca3ceb352b0bcf0d8d7de4f6bf4d19d0 | 2026-01-04T15:43:37.979050Z | false |
rerun-io/rerun | https://github.com/rerun-io/rerun/blob/910b1e72ca3ceb352b0bcf0d8d7de4f6bf4d19d0/crates/utils/re_perf_telemetry/src/lib.rs | crates/utils/re_perf_telemetry/src/lib.rs | //! Everything needed to set up telemetry (logs, traces, metrics) for both clients and servers.
//!
//! Despite the name `re_perf_telemetry`, this actually handles _all_ forms of telemetry,
//! including all log output.
//!
//! This sort of telemetry is always disabled on our OSS binaries, and is only used for
//! * Th... | rust | Apache-2.0 | 910b1e72ca3ceb352b0bcf0d8d7de4f6bf4d19d0 | 2026-01-04T15:43:37.979050Z | false |
rerun-io/rerun | https://github.com/rerun-io/rerun/blob/910b1e72ca3ceb352b0bcf0d8d7de4f6bf4d19d0/crates/utils/re_perf_telemetry/src/memory_telemetry.rs | crates/utils/re_perf_telemetry/src/memory_telemetry.rs | pub fn install_memory_use_meters() {
let meter = opentelemetry::global::meter("memory-use");
meter
.i64_observable_gauge("memory_resident_set_size_bytes")
.with_description("Resident Set Size")
.with_unit("B")
.with_callback(|observer| {
#[expect(clippy::cast_possibl... | rust | Apache-2.0 | 910b1e72ca3ceb352b0bcf0d8d7de4f6bf4d19d0 | 2026-01-04T15:43:37.979050Z | false |
rerun-io/rerun | https://github.com/rerun-io/rerun/blob/910b1e72ca3ceb352b0bcf0d8d7de4f6bf4d19d0/crates/utils/re_perf_telemetry/src/shared_reader.rs | crates/utils/re_perf_telemetry/src/shared_reader.rs | use std::sync::{Arc, Weak};
use std::time::Duration;
use opentelemetry_sdk::error::OTelSdkResult;
use opentelemetry_sdk::metrics::data::ResourceMetrics;
use opentelemetry_sdk::metrics::reader::MetricReader;
use opentelemetry_sdk::metrics::{ManualReader, Pipeline, Temporality};
/// A wrapper that allows sharing a `Man... | rust | Apache-2.0 | 910b1e72ca3ceb352b0bcf0d8d7de4f6bf4d19d0 | 2026-01-04T15:43:37.979050Z | false |
rerun-io/rerun | https://github.com/rerun-io/rerun/blob/910b1e72ca3ceb352b0bcf0d8d7de4f6bf4d19d0/crates/utils/re_perf_telemetry/src/telemetry.rs | crates/utils/re_perf_telemetry/src/telemetry.rs | use std::sync::Arc;
use opentelemetry::trace::TracerProvider as _;
use opentelemetry_otlp::WithTonicConfig as _;
use opentelemetry_sdk::logs::SdkLoggerProvider;
use opentelemetry_sdk::metrics::SdkMeterProvider;
use opentelemetry_sdk::trace::{BatchConfigBuilder, BatchSpanProcessor, SdkTracerProvider};
use tracing_subsc... | rust | Apache-2.0 | 910b1e72ca3ceb352b0bcf0d8d7de4f6bf4d19d0 | 2026-01-04T15:43:37.979050Z | false |
rerun-io/rerun | https://github.com/rerun-io/rerun/blob/910b1e72ca3ceb352b0bcf0d8d7de4f6bf4d19d0/crates/utils/re_perf_telemetry/src/args.rs | crates/utils/re_perf_telemetry/src/args.rs | #[derive(Debug, Clone, PartialEq, Eq)]
pub enum LogFormat {
Pretty,
Compact,
Json,
}
impl std::fmt::Display for LogFormat {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.write_str(match self {
Self::Pretty => "pretty",
Self::Compact => "compact",... | rust | Apache-2.0 | 910b1e72ca3ceb352b0bcf0d8d7de4f6bf4d19d0 | 2026-01-04T15:43:37.979050Z | false |
rerun-io/rerun | https://github.com/rerun-io/rerun/blob/910b1e72ca3ceb352b0bcf0d8d7de4f6bf4d19d0/crates/utils/re_perf_telemetry/src/utils.rs | crates/utils/re_perf_telemetry/src/utils.rs | //! Utility functions for various telemetry-related tasks.
/// Displays a possibly long list of items to a length limited list of items.
///
/// ### Examples
/// ```
/// use re_perf_telemetry::to_short_str;
///
/// let long_list = [1, 2, 3, 4, 5];
/// let max_len = 3;
/// let result = to_short_str(long_list, max_len);... | rust | Apache-2.0 | 910b1e72ca3ceb352b0bcf0d8d7de4f6bf4d19d0 | 2026-01-04T15:43:37.979050Z | false |
rerun-io/rerun | https://github.com/rerun-io/rerun/blob/910b1e72ca3ceb352b0bcf0d8d7de4f6bf4d19d0/crates/utils/re_perf_telemetry/src/prometheus.rs | crates/utils/re_perf_telemetry/src/prometheus.rs | //! Prometheus-specific metric conversion and encoding utilities
#![expect(clippy::cast_possible_wrap)] // u64 -> i64
use std::collections::HashMap;
use std::fmt::Write as _;
use std::sync::Arc;
use opentelemetry::KeyValue;
use opentelemetry_sdk::metrics::data::ResourceMetrics;
use parking_lot::Mutex;
use prometheus... | rust | Apache-2.0 | 910b1e72ca3ceb352b0bcf0d8d7de4f6bf4d19d0 | 2026-01-04T15:43:37.979050Z | false |
rerun-io/rerun | https://github.com/rerun-io/rerun/blob/910b1e72ca3ceb352b0bcf0d8d7de4f6bf4d19d0/crates/utils/re_perf_telemetry/src/metrics_server.rs | crates/utils/re_perf_telemetry/src/metrics_server.rs | //! HTTP server for metrics collection and exposition
use std::net::SocketAddr;
use std::sync::Arc;
use axum::Router;
use axum::extract::State;
use axum::http::{StatusCode, header};
use axum::response::IntoResponse;
use axum::routing::get;
use opentelemetry_sdk::metrics::ManualReader;
use opentelemetry_sdk::metrics::... | rust | Apache-2.0 | 910b1e72ca3ceb352b0bcf0d8d7de4f6bf4d19d0 | 2026-01-04T15:43:37.979050Z | false |
rerun-io/rerun | https://github.com/rerun-io/rerun/blob/910b1e72ca3ceb352b0bcf0d8d7de4f6bf4d19d0/crates/utils/re_crash_handler/src/lib.rs | crates/utils/re_crash_handler/src/lib.rs | //! Detect and handle signals, panics, and other crashes, making sure to log them and optionally send them off to analytics.
pub mod sigint;
#[cfg(not(target_os = "windows"))]
use parking_lot::Mutex;
use re_build_info::BuildInfo;
// The easiest way to pass this to our signal handler.
#[cfg(not(target_os = "windows")... | rust | Apache-2.0 | 910b1e72ca3ceb352b0bcf0d8d7de4f6bf4d19d0 | 2026-01-04T15:43:37.979050Z | false |
rerun-io/rerun | https://github.com/rerun-io/rerun/blob/910b1e72ca3ceb352b0bcf0d8d7de4f6bf4d19d0/crates/utils/re_crash_handler/src/sigint.rs | crates/utils/re_crash_handler/src/sigint.rs | use std::sync::atomic::AtomicBool;
// ---
static SIGINT_RECEIVED: AtomicBool = AtomicBool::new(false);
/// Call this to start tracking `SIGINT`s.
///
/// You can then call [`was_sigint_ever_caught`] at any point in time.
#[cfg(not(any(target_os = "windows", target_arch = "wasm32")))]
#[expect(unsafe_code)]
#[expect(... | rust | Apache-2.0 | 910b1e72ca3ceb352b0bcf0d8d7de4f6bf4d19d0 | 2026-01-04T15:43:37.979050Z | false |
rerun-io/rerun | https://github.com/rerun-io/rerun/blob/910b1e72ca3ceb352b0bcf0d8d7de4f6bf4d19d0/crates/utils/re_ros_msg/src/lib.rs | crates/utils/re_ros_msg/src/lib.rs | //! Minimal ROS 2 `.msg` reflection parser (messages only).
//!
//! This module parses the textual ROS 2 message definition format (aka `.msg`)
//! into a typed, reflection-friendly representation. It is intentionally kept
//! generic and does not rely on any pre-baked message definitions, so it can be
//! used to pars... | rust | Apache-2.0 | 910b1e72ca3ceb352b0bcf0d8d7de4f6bf4d19d0 | 2026-01-04T15:43:37.979050Z | false |
rerun-io/rerun | https://github.com/rerun-io/rerun/blob/910b1e72ca3ceb352b0bcf0d8d7de4f6bf4d19d0/crates/utils/re_ros_msg/src/message_spec.rs | crates/utils/re_ros_msg/src/message_spec.rs | use thiserror::Error;
#[derive(Error, Debug)]
pub enum ParseError {
/// Bad text/shape: missing tokens, bad delimiters, malformed constructs
#[error("syntax error: {0}")]
Syntax(String),
/// Type names/annotations: unknown/invalid types, bad bounds, array forms
#[error("type error: {0}")]
Type... | rust | Apache-2.0 | 910b1e72ca3ceb352b0bcf0d8d7de4f6bf4d19d0 | 2026-01-04T15:43:37.979050Z | false |
rerun-io/rerun | https://github.com/rerun-io/rerun/blob/910b1e72ca3ceb352b0bcf0d8d7de4f6bf4d19d0/crates/utils/re_ros_msg/src/deserialize/primitive_array.rs | crates/utils/re_ros_msg/src/deserialize/primitive_array.rs | use std::fmt;
use serde::de::{self, DeserializeSeed, Visitor};
use crate::message_spec::BuiltInType;
#[derive(Clone, PartialEq)]
pub enum PrimitiveArray {
Bool(Vec<bool>),
I8(Vec<i8>),
U8(Vec<u8>),
I16(Vec<i16>),
U16(Vec<u16>),
I32(Vec<i32>),
U32(Vec<u32>),
I64(Vec<i64>),
U64(Vec<... | rust | Apache-2.0 | 910b1e72ca3ceb352b0bcf0d8d7de4f6bf4d19d0 | 2026-01-04T15:43:37.979050Z | false |
rerun-io/rerun | https://github.com/rerun-io/rerun/blob/910b1e72ca3ceb352b0bcf0d8d7de4f6bf4d19d0/crates/utils/re_ros_msg/src/deserialize/primitive.rs | crates/utils/re_ros_msg/src/deserialize/primitive.rs | use std::fmt;
use serde::de::{self, Visitor};
pub(super) struct PrimitiveVisitor<T>(std::marker::PhantomData<T>);
impl<T> PrimitiveVisitor<T> {
pub fn new() -> Self {
Self(std::marker::PhantomData)
}
}
macro_rules! impl_primitive_visitor {
($t:ty, $m:ident) => {
impl Visitor<'_> for Prim... | rust | Apache-2.0 | 910b1e72ca3ceb352b0bcf0d8d7de4f6bf4d19d0 | 2026-01-04T15:43:37.979050Z | false |
rerun-io/rerun | https://github.com/rerun-io/rerun/blob/910b1e72ca3ceb352b0bcf0d8d7de4f6bf4d19d0/crates/utils/re_ros_msg/src/deserialize/mod.rs | crates/utils/re_ros_msg/src/deserialize/mod.rs | use std::collections::{BTreeMap, HashMap};
use serde::de::{self, DeserializeSeed};
use crate::deserialize::primitive_array::PrimitiveArraySeed;
use crate::message_spec::{ComplexType, MessageSpecification, Type};
pub mod primitive;
pub mod primitive_array;
use primitive::{PrimitiveVisitor, StringVisitor};
/// A sin... | rust | Apache-2.0 | 910b1e72ca3ceb352b0bcf0d8d7de4f6bf4d19d0 | 2026-01-04T15:43:37.979050Z | false |
rerun-io/rerun | https://github.com/rerun-io/rerun/blob/910b1e72ca3ceb352b0bcf0d8d7de4f6bf4d19d0/crates/utils/re_int_histogram/src/lib.rs | crates/utils/re_int_histogram/src/lib.rs | //! A histogram with `i64` keys and `u32` counts, supporting both sparse and dense uses.
//!
//! It supports high-level summaries of the histogram, so that you can quickly
//! get a birds-eye view of the data without having to visit every point in the histogram.
//!
//! You can also think of the histogram as a multi-se... | rust | Apache-2.0 | 910b1e72ca3ceb352b0bcf0d8d7de4f6bf4d19d0 | 2026-01-04T15:43:37.979050Z | false |
rerun-io/rerun | https://github.com/rerun-io/rerun/blob/910b1e72ca3ceb352b0bcf0d8d7de4f6bf4d19d0/crates/utils/re_int_histogram/src/tree.rs | crates/utils/re_int_histogram/src/tree.rs | //! The histogram is implemented as a trie.
//!
//! Each node in the trie stores a count of a key/address sharing a prefix up to `depth * LEVEL_STEP` bits.
//! The key/address is always 64 bits.
//!
//! There are branch nodes, and two types of leaf nodes: dense, and sparse.
//! Dense leaves are only found at the very b... | rust | Apache-2.0 | 910b1e72ca3ceb352b0bcf0d8d7de4f6bf4d19d0 | 2026-01-04T15:43:37.979050Z | true |
rerun-io/rerun | https://github.com/rerun-io/rerun/blob/910b1e72ca3ceb352b0bcf0d8d7de4f6bf4d19d0/crates/utils/re_int_histogram/tests/memory_test.rs | crates/utils/re_int_histogram/tests/memory_test.rs | use std::sync::atomic::AtomicUsize;
use std::sync::atomic::Ordering::Relaxed;
thread_local! {
static LIVE_BYTES_IN_THREAD: AtomicUsize = const { AtomicUsize::new(0) };
}
pub struct TrackingAllocator {
allocator: std::alloc::System,
}
#[global_allocator]
pub static GLOBAL_ALLOCATOR: TrackingAllocator = Tracki... | rust | Apache-2.0 | 910b1e72ca3ceb352b0bcf0d8d7de4f6bf4d19d0 | 2026-01-04T15:43:37.979050Z | false |
rerun-io/rerun | https://github.com/rerun-io/rerun/blob/910b1e72ca3ceb352b0bcf0d8d7de4f6bf4d19d0/crates/utils/re_int_histogram/benches/int_histogram_benchmark.rs | crates/utils/re_int_histogram/benches/int_histogram_benchmark.rs | #![expect(clippy::cast_possible_wrap)] // u64 -> i64 is fine
#[global_allocator]
static GLOBAL: mimalloc::MiMalloc = mimalloc::MiMalloc;
use criterion::{Criterion, criterion_group, criterion_main};
// ----------------
#[cfg(not(debug_assertions))]
const COUNT: u64 = 100_000;
// `cargo test` also runs the benchmark... | rust | Apache-2.0 | 910b1e72ca3ceb352b0bcf0d8d7de4f6bf4d19d0 | 2026-01-04T15:43:37.979050Z | false |
rerun-io/rerun | https://github.com/rerun-io/rerun/blob/910b1e72ca3ceb352b0bcf0d8d7de4f6bf4d19d0/crates/utils/re_case/src/lib.rs | crates/utils/re_case/src/lib.rs | //! Case conversions, the way Rerun likes them.
/// Converts a snake or pascal case input into a snake case output.
///
/// If the input contains multiple parts separated by dots, only the last part is converted.
pub fn to_snake_case(s: &str) -> String {
use convert_case::{Boundary, Converter, Pattern};
let r... | rust | Apache-2.0 | 910b1e72ca3ceb352b0bcf0d8d7de4f6bf4d19d0 | 2026-01-04T15:43:37.979050Z | false |
rerun-io/rerun | https://github.com/rerun-io/rerun/blob/910b1e72ca3ceb352b0bcf0d8d7de4f6bf4d19d0/crates/utils/re_span/src/lib.rs | crates/utils/re_span/src/lib.rs | //! An integer range that always has a non-negative length.
//!
//! The standard [`std::ops::Range`] can have `start > end`
//! Taking a `Range` by argument thus means the callee must check for this eventuality and return an error.
//!
//! In contrast, [`Span`] always has a non-negative length, i.e. `len >= 0`.
use st... | rust | Apache-2.0 | 910b1e72ca3ceb352b0bcf0d8d7de4f6bf4d19d0 | 2026-01-04T15:43:37.979050Z | false |
rerun-io/rerun | https://github.com/rerun-io/rerun/blob/910b1e72ca3ceb352b0bcf0d8d7de4f6bf4d19d0/crates/utils/re_arrow_util/src/lib.rs | crates/utils/re_arrow_util/src/lib.rs | //! Helpers for working with arrow
mod arrays;
mod batches;
mod compare;
mod format;
mod format_data_type;
mod test_extensions;
// ----------------------------------------------------------------
use std::sync::Arc;
use arrow::array::{Array as _, AsArray as _, ListArray};
use arrow::datatypes::{DataType, Field};
pu... | rust | Apache-2.0 | 910b1e72ca3ceb352b0bcf0d8d7de4f6bf4d19d0 | 2026-01-04T15:43:37.979050Z | false |
rerun-io/rerun | https://github.com/rerun-io/rerun/blob/910b1e72ca3ceb352b0bcf0d8d7de4f6bf4d19d0/crates/utils/re_arrow_util/src/arrays.rs | crates/utils/re_arrow_util/src/arrays.rs | use std::iter::repeat_n;
use std::sync::Arc;
use arrow::array::{
Array, ArrayRef, ArrowPrimitiveType, BooleanArray, FixedSizeListArray, ListArray,
PrimitiveArray, UInt32Array, new_empty_array,
};
use arrow::buffer::{NullBuffer, OffsetBuffer};
use arrow::datatypes::{DataType, Field};
use arrow::error::ArrowErro... | rust | Apache-2.0 | 910b1e72ca3ceb352b0bcf0d8d7de4f6bf4d19d0 | 2026-01-04T15:43:37.979050Z | false |
rerun-io/rerun | https://github.com/rerun-io/rerun/blob/910b1e72ca3ceb352b0bcf0d8d7de4f6bf4d19d0/crates/utils/re_arrow_util/src/test_extensions.rs | crates/utils/re_arrow_util/src/test_extensions.rs | use std::collections::HashSet;
use std::sync::Arc;
use arrow::array::{Array as _, ArrayRef, ListArray, RecordBatchOptions, StringArray};
use arrow::compute::SortOptions;
use arrow::datatypes::{DataType, Field, Fields};
use datafusion::common::DataFusionError;
use datafusion::physical_expr::expressions::col;
use datafu... | rust | Apache-2.0 | 910b1e72ca3ceb352b0bcf0d8d7de4f6bf4d19d0 | 2026-01-04T15:43:37.979050Z | false |
rerun-io/rerun | https://github.com/rerun-io/rerun/blob/910b1e72ca3ceb352b0bcf0d8d7de4f6bf4d19d0/crates/utils/re_arrow_util/src/batches.rs | crates/utils/re_arrow_util/src/batches.rs | use std::collections::HashSet;
use std::sync::Arc;
use arrow::array::{ArrayRef, RecordBatch, RecordBatchOptions};
use arrow::datatypes::{Field, Schema, SchemaBuilder};
use itertools::Itertools as _;
use crate::MissingColumnError;
// ---
/// Concatenates the given [`RecordBatch`]es, regardless of their respective sc... | rust | Apache-2.0 | 910b1e72ca3ceb352b0bcf0d8d7de4f6bf4d19d0 | 2026-01-04T15:43:37.979050Z | true |
rerun-io/rerun | https://github.com/rerun-io/rerun/blob/910b1e72ca3ceb352b0bcf0d8d7de4f6bf4d19d0/crates/utils/re_arrow_util/src/format.rs | crates/utils/re_arrow_util/src/format.rs | //! Formatting for tables of Arrow arrays
use std::fmt::Formatter;
use arrow::array::{Array, ArrayRef, AsArray as _, ListArray};
use arrow::datatypes::{DataType, Field, Fields};
use arrow::util::display::{ArrayFormatter, FormatOptions};
use comfy_table::{Cell, Row, Table, presets};
use itertools::{Either, Itertools a... | rust | Apache-2.0 | 910b1e72ca3ceb352b0bcf0d8d7de4f6bf4d19d0 | 2026-01-04T15:43:37.979050Z | false |
rerun-io/rerun | https://github.com/rerun-io/rerun/blob/910b1e72ca3ceb352b0bcf0d8d7de4f6bf4d19d0/crates/utils/re_arrow_util/src/format_data_type.rs | crates/utils/re_arrow_util/src/format_data_type.rs | //! `arrow` has `ToString` implemented, but it is way too verbose.
use std::fmt::Formatter;
use arrow::datatypes::{DataType, Field, IntervalUnit, TimeUnit};
/// Compact format of an arrow data type.
///
/// TODO(emilk): upstream this to `arrow` instead.
pub fn format_data_type(data_type: &DataType) -> String {
D... | rust | Apache-2.0 | 910b1e72ca3ceb352b0bcf0d8d7de4f6bf4d19d0 | 2026-01-04T15:43:37.979050Z | false |
rerun-io/rerun | https://github.com/rerun-io/rerun/blob/910b1e72ca3ceb352b0bcf0d8d7de4f6bf4d19d0/crates/utils/re_arrow_util/src/compare.rs | crates/utils/re_arrow_util/src/compare.rs | use anyhow::{Context as _, bail, ensure};
use half::f16;
use itertools::izip;
use crate::format_data_type;
/// Are two arrays equal, ignoring small numeric differences?
///
/// Returns `Ok` if similar.
/// If there is a difference, a description of that difference is returned in `Err`.
/// We use [`anyhow`] to provid... | rust | Apache-2.0 | 910b1e72ca3ceb352b0bcf0d8d7de4f6bf4d19d0 | 2026-01-04T15:43:37.979050Z | false |
rerun-io/rerun | https://github.com/rerun-io/rerun/blob/910b1e72ca3ceb352b0bcf0d8d7de4f6bf4d19d0/crates/utils/re_log/src/setup.rs | crates/utils/re_log/src/setup.rs | //! Function to setup logging in binaries and web apps.
use std::sync::atomic::AtomicIsize;
// This can be useful to enable to figure out what is causing a log message.
#[cfg(not(target_arch = "wasm32"))]
const LOG_FILE_LINE: bool = false;
/// Sets up logging for the current process using default log filter as defin... | rust | Apache-2.0 | 910b1e72ca3ceb352b0bcf0d8d7de4f6bf4d19d0 | 2026-01-04T15:43:37.979050Z | false |
rerun-io/rerun | https://github.com/rerun-io/rerun/blob/910b1e72ca3ceb352b0bcf0d8d7de4f6bf4d19d0/crates/utils/re_log/src/lib.rs | crates/utils/re_log/src/lib.rs | //! Text logging (nothing to do with rerun logging) for use in rerun libraries.
//!
//! Provides helpers for adding multiple loggers,
//! and for setting up logging on native and on web.
//!
//! * `trace`: spammy things
//! * `debug`: things that might be useful when debugging
//! * `info`: things that we want to show ... | rust | Apache-2.0 | 910b1e72ca3ceb352b0bcf0d8d7de4f6bf4d19d0 | 2026-01-04T15:43:37.979050Z | false |
rerun-io/rerun | https://github.com/rerun-io/rerun/blob/910b1e72ca3ceb352b0bcf0d8d7de4f6bf4d19d0/crates/utils/re_log/src/result_extensions.rs | crates/utils/re_log/src/result_extensions.rs | pub trait ResultExt<T, E> {
/// Logs an error if the result is an error and returns the result.
fn ok_or_log_error(self) -> Option<T>;
/// Logs an error if the result is an error and returns the result, but only once.
fn ok_or_log_error_once(self) -> Option<T>;
/// Log a warning if there is an `Er... | rust | Apache-2.0 | 910b1e72ca3ceb352b0bcf0d8d7de4f6bf4d19d0 | 2026-01-04T15:43:37.979050Z | false |
rerun-io/rerun | https://github.com/rerun-io/rerun/blob/910b1e72ca3ceb352b0bcf0d8d7de4f6bf4d19d0/crates/utils/re_log/src/channel_logger.rs | crates/utils/re_log/src/channel_logger.rs | //! Capture log messages and send them to some receiver over a channel.
#[derive(Clone)]
pub struct LogMsg {
/// The verbosity level.
pub level: log::Level,
/// The module, starting with the crate name.
pub target: String,
/// The contents of the log message.
pub msg: String,
}
/// Pipe log ... | rust | Apache-2.0 | 910b1e72ca3ceb352b0bcf0d8d7de4f6bf4d19d0 | 2026-01-04T15:43:37.979050Z | false |
rerun-io/rerun | https://github.com/rerun-io/rerun/blob/910b1e72ca3ceb352b0bcf0d8d7de4f6bf4d19d0/crates/utils/re_log/src/multi_logger.rs | crates/utils/re_log/src/multi_logger.rs | //! Have multiple loggers implementing [`log::Log`] at once.
use std::sync::atomic::AtomicBool;
use std::sync::atomic::Ordering::SeqCst;
static MULTI_LOGGER: MultiLogger = MultiLogger::new();
static HAS_MULTI_LOGGER: AtomicBool = AtomicBool::new(false);
/// Produced when trying to install additional loggers when [`... | rust | Apache-2.0 | 910b1e72ca3ceb352b0bcf0d8d7de4f6bf4d19d0 | 2026-01-04T15:43:37.979050Z | false |
rerun-io/rerun | https://github.com/rerun-io/rerun/blob/910b1e72ca3ceb352b0bcf0d8d7de4f6bf4d19d0/crates/utils/re_log/src/web_logger.rs | crates/utils/re_log/src/web_logger.rs | /// Implements [`log::Log`] to log messages to `console.log`, `console.warn`, etc.
pub struct WebLogger {
filter: log::LevelFilter,
}
impl WebLogger {
pub fn new(filter: log::LevelFilter) -> Self {
Self { filter }
}
}
impl log::Log for WebLogger {
fn enabled(&self, metadata: &log::Metadata<'_>... | rust | Apache-2.0 | 910b1e72ca3ceb352b0bcf0d8d7de4f6bf4d19d0 | 2026-01-04T15:43:37.979050Z | false |
rerun-io/rerun | https://github.com/rerun-io/rerun/blob/910b1e72ca3ceb352b0bcf0d8d7de4f6bf4d19d0/crates/utils/re_auth/src/user.rs | crates/utils/re_auth/src/user.rs | pub struct UserContext {
pub user_id: String,
}
| rust | Apache-2.0 | 910b1e72ca3ceb352b0bcf0d8d7de4f6bf4d19d0 | 2026-01-04T15:43:37.979050Z | false |
rerun-io/rerun | https://github.com/rerun-io/rerun/blob/910b1e72ca3ceb352b0bcf0d8d7de4f6bf4d19d0/crates/utils/re_auth/src/lib.rs | crates/utils/re_auth/src/lib.rs | //! Basic authentication helpers for Rerun.
//!
//! Currently, this crate provides a simple [`Jwt`]-based authentication scheme on
//! top of a rudimentary [`RedapProvider`] that uses a symmetric key to _both_
//! generate and sign tokens.
//!
//! **Warning!** This approach should only be seen as a stop-gap until we ha... | rust | Apache-2.0 | 910b1e72ca3ceb352b0bcf0d8d7de4f6bf4d19d0 | 2026-01-04T15:43:37.979050Z | false |
rerun-io/rerun | https://github.com/rerun-io/rerun/blob/910b1e72ca3ceb352b0bcf0d8d7de4f6bf4d19d0/crates/utils/re_auth/src/wasm_compat.rs | crates/utils/re_auth/src/wasm_compat.rs | //! Some parts of `re_auth` deal with `async`, `dyn Future`, and `Send`.
//! On Wasm, these things are a nightmare. So we use hacks to force futures to be `Send`.
//!
//! In theory, everything is `Send` on `wasm32`, because it's single-threaded.
//! If Wasm ever gets threads, it will be under a different `target_os`, s... | rust | Apache-2.0 | 910b1e72ca3ceb352b0bcf0d8d7de4f6bf4d19d0 | 2026-01-04T15:43:37.979050Z | false |
rerun-io/rerun | https://github.com/rerun-io/rerun/blob/910b1e72ca3ceb352b0bcf0d8d7de4f6bf4d19d0/crates/utils/re_auth/src/cli.rs | crates/utils/re_auth/src/cli.rs | use std::time::Duration;
use indicatif::ProgressBar;
pub use crate::callback_server::Error;
use crate::oauth::api::{GenerateToken, send_async};
use crate::oauth::login_flow::OauthLoginFlowState;
use crate::{OauthLoginFlow, oauth};
pub struct LoginOptions {
pub open_browser: bool,
pub force_login: bool,
}
#[... | rust | Apache-2.0 | 910b1e72ca3ceb352b0bcf0d8d7de4f6bf4d19d0 | 2026-01-04T15:43:37.979050Z | false |
rerun-io/rerun | https://github.com/rerun-io/rerun/blob/910b1e72ca3ceb352b0bcf0d8d7de4f6bf4d19d0/crates/utils/re_auth/src/error.rs | crates/utils/re_auth/src/error.rs | /// Handles errors for the `re_auth` crate.
#[derive(Debug, thiserror::Error)]
pub enum Error {
#[error("transparent")]
Jwt(#[from] jsonwebtoken::errors::Error),
#[error("transparent")]
Base64Decode(#[from] base64::DecodeError),
#[error("transparent")]
SystemTime(#[from] std::time::SystemTimeE... | rust | Apache-2.0 | 910b1e72ca3ceb352b0bcf0d8d7de4f6bf4d19d0 | 2026-01-04T15:43:37.979050Z | false |
rerun-io/rerun | https://github.com/rerun-io/rerun/blob/910b1e72ca3ceb352b0bcf0d8d7de4f6bf4d19d0/crates/utils/re_auth/src/oauth.rs | crates/utils/re_auth/src/oauth.rs | use base64::Engine as _;
use base64::prelude::BASE64_URL_SAFE_NO_PAD;
use serde::{Deserialize, Serialize};
use crate::Jwt;
pub mod api;
mod storage;
#[cfg(not(target_arch = "wasm32"))]
pub mod login_flow;
/// Tokens with fewer than this number of seconds left before expiration
/// are considered expired. This ensur... | rust | Apache-2.0 | 910b1e72ca3ceb352b0bcf0d8d7de4f6bf4d19d0 | 2026-01-04T15:43:37.979050Z | false |
rerun-io/rerun | https://github.com/rerun-io/rerun/blob/910b1e72ca3ceb352b0bcf0d8d7de4f6bf4d19d0/crates/utils/re_auth/src/callback_server.rs | crates/utils/re_auth/src/callback_server.rs | use std::borrow::Cow;
use uuid::Uuid;
use crate::oauth::api::{Pkce, authorization_url};
use crate::oauth::{CredentialsStoreError, MalformedTokenError};
pub struct OauthCallbackServer {
server: tiny_http::Server,
state: String,
auth_url: String,
}
/// This is a range of ports that's allowlisted on the a... | rust | Apache-2.0 | 910b1e72ca3ceb352b0bcf0d8d7de4f6bf4d19d0 | 2026-01-04T15:43:37.979050Z | false |
rerun-io/rerun | https://github.com/rerun-io/rerun/blob/910b1e72ca3ceb352b0bcf0d8d7de4f6bf4d19d0/crates/utils/re_auth/src/credentials.rs | crates/utils/re_auth/src/credentials.rs | use crate::Jwt;
#[derive(Debug, thiserror::Error)]
pub enum CredentialsProviderError {
#[error("session expired; please login using `rerun auth login`")]
SessionExpired,
#[error("{0}")]
Custom(#[from] Box<dyn std::error::Error + Send + Sync + 'static>),
}
impl CredentialsProviderError {
pub fn cu... | rust | Apache-2.0 | 910b1e72ca3ceb352b0bcf0d8d7de4f6bf4d19d0 | 2026-01-04T15:43:37.979050Z | false |
rerun-io/rerun | https://github.com/rerun-io/rerun/blob/910b1e72ca3ceb352b0bcf0d8d7de4f6bf4d19d0/crates/utils/re_auth/src/provider.rs | crates/utils/re_auth/src/provider.rs | use std::time::Duration;
use base64::Engine as _;
use base64::engine::general_purpose;
use jsonwebtoken::{Algorithm, DecodingKey, EncodingKey, Header, Validation, decode, encode};
use crate::{Error, Jwt};
/// Identifies who should be the consumer of a token. In our case, this is the Rerun storage node.
const AUDIENC... | rust | Apache-2.0 | 910b1e72ca3ceb352b0bcf0d8d7de4f6bf4d19d0 | 2026-01-04T15:43:37.979050Z | false |
rerun-io/rerun | https://github.com/rerun-io/rerun/blob/910b1e72ca3ceb352b0bcf0d8d7de4f6bf4d19d0/crates/utils/re_auth/src/token.rs | crates/utils/re_auth/src/token.rs | use jsonwebtoken::decode_header;
#[derive(Debug, thiserror::Error)]
pub enum TokenError {
#[error("token does not seem to be a valid JWT token: {0}")]
MalformedToken(#[source] jsonwebtoken::errors::Error),
}
/// A JWT that is used to authenticate the client.
#[derive(Debug, Clone, PartialEq, Eq, Hash)]
#[repr... | rust | Apache-2.0 | 910b1e72ca3ceb352b0bcf0d8d7de4f6bf4d19d0 | 2026-01-04T15:43:37.979050Z | false |
rerun-io/rerun | https://github.com/rerun-io/rerun/blob/910b1e72ca3ceb352b0bcf0d8d7de4f6bf4d19d0/crates/utils/re_auth/src/service/client.rs | crates/utils/re_auth/src/service/client.rs | use std::pin::Pin;
use std::sync::Arc;
use std::task::{Context, Poll};
use http::header::InvalidHeaderValue;
use tower::{Layer, Service};
use super::{AUTHORIZATION_KEY, TOKEN_PREFIX};
use crate::Jwt;
use crate::credentials::{CredentialsProvider, StaticCredentialsProvider};
/// Client-side async auth layer (replaces ... | rust | Apache-2.0 | 910b1e72ca3ceb352b0bcf0d8d7de4f6bf4d19d0 | 2026-01-04T15:43:37.979050Z | false |
rerun-io/rerun | https://github.com/rerun-io/rerun/blob/910b1e72ca3ceb352b0bcf0d8d7de4f6bf4d19d0/crates/utils/re_auth/src/service/mod.rs | crates/utils/re_auth/src/service/mod.rs | //! This module contains auth middleware for [`tonic`] services.
pub mod client;
#[cfg(not(target_arch = "wasm32"))]
pub mod server;
/// The metadata key used in the metadata of the gRPC request to store the token.
const AUTHORIZATION_KEY: &str = "authorization";
/// The prefix for the token in the metadata of the ... | rust | Apache-2.0 | 910b1e72ca3ceb352b0bcf0d8d7de4f6bf4d19d0 | 2026-01-04T15:43:37.979050Z | false |
rerun-io/rerun | https://github.com/rerun-io/rerun/blob/910b1e72ca3ceb352b0bcf0d8d7de4f6bf4d19d0/crates/utils/re_auth/src/service/server.rs | crates/utils/re_auth/src/service/server.rs | use tonic::metadata::{Ascii, MetadataValue};
use tonic::service::Interceptor;
use tonic::{Request, Status};
use super::{AUTHORIZATION_KEY, TOKEN_PREFIX};
use crate::provider::VerificationOptions;
use crate::{Error, Jwt, RedapProvider};
#[derive(Debug, Clone)]
pub struct UserContext {
pub user_id: String,
#[c... | rust | Apache-2.0 | 910b1e72ca3ceb352b0bcf0d8d7de4f6bf4d19d0 | 2026-01-04T15:43:37.979050Z | false |
rerun-io/rerun | https://github.com/rerun-io/rerun/blob/910b1e72ca3ceb352b0bcf0d8d7de4f6bf4d19d0/crates/utils/re_auth/src/oauth/login_flow.rs | crates/utils/re_auth/src/oauth/login_flow.rs | use std::time::Duration;
use crate::callback_server::{Error, OauthCallbackServer};
use crate::oauth;
use crate::oauth::Credentials;
use crate::oauth::api::{AuthenticateWithCode, Pkce, send_async};
use super::OAUTH_CLIENT_ID;
use super::api::{
AuthenticateWithDeviceCode, AuthenticateWithDeviceCodeResponse, DeviceC... | rust | Apache-2.0 | 910b1e72ca3ceb352b0bcf0d8d7de4f6bf4d19d0 | 2026-01-04T15:43:37.979050Z | false |
rerun-io/rerun | https://github.com/rerun-io/rerun/blob/910b1e72ca3ceb352b0bcf0d8d7de4f6bf4d19d0/crates/utils/re_auth/src/oauth/storage.rs | crates/utils/re_auth/src/oauth/storage.rs | //! Load/store abstraction for credentials on native and Wasm.
use super::Credentials;
#[derive(Debug, thiserror::Error)]
pub enum LoadError {
#[error("failed to read credentials: {0}")]
Io(#[from] std::io::Error),
#[error("failed to deserialize credentials: {0}")]
Serde(#[from] serde_json::Error),
... | rust | Apache-2.0 | 910b1e72ca3ceb352b0bcf0d8d7de4f6bf4d19d0 | 2026-01-04T15:43:37.979050Z | false |
rerun-io/rerun | https://github.com/rerun-io/rerun/blob/910b1e72ca3ceb352b0bcf0d8d7de4f6bf4d19d0/crates/utils/re_auth/src/oauth/api.rs | crates/utils/re_auth/src/oauth/api.rs | //! HTTP Client for Rerun's Auth API.
use std::sync::LazyLock;
use base64::Engine as _;
use base64::prelude::BASE64_URL_SAFE_NO_PAD;
use sha2::{Digest as _, Sha256};
use super::RefreshToken;
use crate::oauth::OAUTH_CLIENT_ID;
static WORKOS_API: LazyLock<String> = LazyLock::new(|| {
std::env::var("RERUN_OAUTH_SE... | rust | Apache-2.0 | 910b1e72ca3ceb352b0bcf0d8d7de4f6bf4d19d0 | 2026-01-04T15:43:37.979050Z | false |
rerun-io/rerun | https://github.com/rerun-io/rerun/blob/910b1e72ca3ceb352b0bcf0d8d7de4f6bf4d19d0/crates/utils/re_auth/tests/tokens.rs | crates/utils/re_auth/tests/tokens.rs | use std::time::Duration;
use rand::rngs::ThreadRng;
use re_auth::{Error, RedapProvider, SecretKey, VerificationOptions};
const KEY: &str = "CKxq6b4Hy3xdjDOWwaShOJab+eu6jcsFso4rbLjJuZ8=";
#[test]
fn key_base64_round_trip() {
let expected = SecretKey::generate(ThreadRng::default());
let base64 = expected.to_ba... | rust | Apache-2.0 | 910b1e72ca3ceb352b0bcf0d8d7de4f6bf4d19d0 | 2026-01-04T15:43:37.979050Z | false |
rerun-io/rerun | https://github.com/rerun-io/rerun/blob/910b1e72ca3ceb352b0bcf0d8d7de4f6bf4d19d0/crates/utils/re_video/build.rs | crates/utils/re_video/build.rs | fn main() {
cfg_aliases::cfg_aliases! {
native: { not(target_arch = "wasm32") },
linux_arm64: { all(target_os = "linux", target_arch = "aarch64") },
with_dav1d: { all(feature = "av1", native, not(linux_arm64)) }, // https://github.com/rerun-io/rerun/issues/7755
with_ffmpeg: { all(fea... | rust | Apache-2.0 | 910b1e72ca3ceb352b0bcf0d8d7de4f6bf4d19d0 | 2026-01-04T15:43:37.979050Z | false |
rerun-io/rerun | https://github.com/rerun-io/rerun/blob/910b1e72ca3ceb352b0bcf0d8d7de4f6bf4d19d0/crates/utils/re_video/src/lib.rs | crates/utils/re_video/src/lib.rs | //! Video decoding library.
mod av1;
mod decode;
mod demux;
mod gop_detection;
mod h264;
mod h265;
mod nalu;
mod stable_index_deque;
mod time;
pub use decode::{
AsyncDecoder, Chunk, DecodeError, DecodeHardwareAcceleration, DecodeSettings, Frame,
FrameContent, FrameInfo, FrameResult, PixelFormat, Result as Dec... | rust | Apache-2.0 | 910b1e72ca3ceb352b0bcf0d8d7de4f6bf4d19d0 | 2026-01-04T15:43:37.979050Z | false |
rerun-io/rerun | https://github.com/rerun-io/rerun/blob/910b1e72ca3ceb352b0bcf0d8d7de4f6bf4d19d0/crates/utils/re_video/src/h265.rs | crates/utils/re_video/src/h265.rs | //! General H.265 utilities.
//!
use cros_codecs::codec::h264::nalu::Header as _;
use cros_codecs::codec::h265::parser::{Nalu, NaluType, Parser, ProfileTierLevel, Sps};
use crate::nalu::{
ANNEXB_NAL_START_CODE, AnnexBStreamState, AnnexBStreamWriteError,
write_length_prefixed_nalus_to_annexb_stream,
};
use crat... | rust | Apache-2.0 | 910b1e72ca3ceb352b0bcf0d8d7de4f6bf4d19d0 | 2026-01-04T15:43:37.979050Z | false |
rerun-io/rerun | https://github.com/rerun-io/rerun/blob/910b1e72ca3ceb352b0bcf0d8d7de4f6bf4d19d0/crates/utils/re_video/src/nalu.rs | crates/utils/re_video/src/nalu.rs | #[derive(Default)]
pub struct AnnexBStreamState {
pub previous_frame_was_idr: bool,
}
/// In Annex-B before every NAL unit is a NAL start code.
///
/// This is used in Annex-B byte stream formats such as h264 files.
/// Packet transform systems (RTP) may omit these.
///
/// Note that there's also a less commonly u... | rust | Apache-2.0 | 910b1e72ca3ceb352b0bcf0d8d7de4f6bf4d19d0 | 2026-01-04T15:43:37.979050Z | false |
rerun-io/rerun | https://github.com/rerun-io/rerun/blob/910b1e72ca3ceb352b0bcf0d8d7de4f6bf4d19d0/crates/utils/re_video/src/gop_detection.rs | crates/utils/re_video/src/gop_detection.rs | use crate::av1::detect_av1_keyframe_start;
use crate::h264::detect_h264_annexb_gop;
use crate::h265::detect_h265_annexb_gop;
use crate::{VideoCodec, VideoEncodingDetails};
/// Failure reason for [`detect_gop_start`].
#[derive(thiserror::Error, Debug)]
pub enum DetectGopStartError {
#[error("Detection not supported... | rust | Apache-2.0 | 910b1e72ca3ceb352b0bcf0d8d7de4f6bf4d19d0 | 2026-01-04T15:43:37.979050Z | false |
rerun-io/rerun | https://github.com/rerun-io/rerun/blob/910b1e72ca3ceb352b0bcf0d8d7de4f6bf4d19d0/crates/utils/re_video/src/time.rs | crates/utils/re_video/src/time.rs | /// The number of time units per second.
#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
pub struct Timescale(u64);
impl Timescale {
pub const NANOSECOND: Self = Self(1_000_000_000);
pub const fn new(v: u64) -> Self {
Self(v)
}
}
/// A value in time units.
#[derive(Default, Cl... | rust | Apache-2.0 | 910b1e72ca3ceb352b0bcf0d8d7de4f6bf4d19d0 | 2026-01-04T15:43:37.979050Z | false |
rerun-io/rerun | https://github.com/rerun-io/rerun/blob/910b1e72ca3ceb352b0bcf0d8d7de4f6bf4d19d0/crates/utils/re_video/src/stable_index_deque.rs | crates/utils/re_video/src/stable_index_deque.rs | use std::collections::VecDeque;
/// A deque with an offset that allows indices into it to stay valid.
///
/// Does not expose the underlying [`VecDeque`] directly to guarantee that all operations are valid.
/// This is useful to use stable indices for addressing in a growing/shrinking deque
/// without having to resor... | rust | Apache-2.0 | 910b1e72ca3ceb352b0bcf0d8d7de4f6bf4d19d0 | 2026-01-04T15:43:37.979050Z | false |
rerun-io/rerun | https://github.com/rerun-io/rerun/blob/910b1e72ca3ceb352b0bcf0d8d7de4f6bf4d19d0/crates/utils/re_video/src/av1.rs | crates/utils/re_video/src/av1.rs | use std::io;
use std::io::{Cursor, SeekFrom};
use scuffle_av1::seq::SequenceHeaderObu;
use scuffle_av1::{ObuHeader, ObuType};
use scuffle_bytes_util::BitReader;
use crate::{ChromaSubsamplingModes, DetectGopStartError, GopStartDetection, VideoEncodingDetails};
/// Try to determine whether an AV1 frame chunk is the st... | rust | Apache-2.0 | 910b1e72ca3ceb352b0bcf0d8d7de4f6bf4d19d0 | 2026-01-04T15:43:37.979050Z | false |
rerun-io/rerun | https://github.com/rerun-io/rerun/blob/910b1e72ca3ceb352b0bcf0d8d7de4f6bf4d19d0/crates/utils/re_video/src/h264.rs | crates/utils/re_video/src/h264.rs | //! General H.264 utilities.
use h264_reader::annexb::AnnexBReader;
use h264_reader::nal::{self, Nal as _};
use h264_reader::push::NalInterest;
use crate::nalu::{
ANNEXB_NAL_START_CODE, AnnexBStreamState, AnnexBStreamWriteError,
write_length_prefixed_nalus_to_annexb_stream,
};
use crate::{
ChromaSubsampli... | rust | Apache-2.0 | 910b1e72ca3ceb352b0bcf0d8d7de4f6bf4d19d0 | 2026-01-04T15:43:37.979050Z | false |
rerun-io/rerun | https://github.com/rerun-io/rerun/blob/910b1e72ca3ceb352b0bcf0d8d7de4f6bf4d19d0/crates/utils/re_video/src/decode/webcodecs.rs | crates/utils/re_video/src/decode/webcodecs.rs | use std::collections::hash_map::Entry;
use std::sync::LazyLock;
use ahash::HashMap;
use crossbeam::channel::Sender;
use js_sys::{Function, Uint8Array};
use re_mp4::StsdBoxContent;
use smallvec::SmallVec;
use wasm_bindgen::JsCast as _;
use wasm_bindgen::closure::Closure;
use web_sys::{
EncodedVideoChunk, EncodedVid... | rust | Apache-2.0 | 910b1e72ca3ceb352b0bcf0d8d7de4f6bf4d19d0 | 2026-01-04T15:43:37.979050Z | false |
rerun-io/rerun | https://github.com/rerun-io/rerun/blob/910b1e72ca3ceb352b0bcf0d8d7de4f6bf4d19d0/crates/utils/re_video/src/decode/mod.rs | crates/utils/re_video/src/decode/mod.rs | //! Video frame decoding.
//! =========================
//!
//! Whirlwind tour of how to interpret picture data (from a Video perspective)
//! ---------------------------------------------------------------------------------
//!
//! Extracted from the [av1 codec wiki](https://wiki.x266.mov/docs/colorimetry/intro) and o... | rust | Apache-2.0 | 910b1e72ca3ceb352b0bcf0d8d7de4f6bf4d19d0 | 2026-01-04T15:43:37.979050Z | false |
rerun-io/rerun | https://github.com/rerun-io/rerun/blob/910b1e72ca3ceb352b0bcf0d8d7de4f6bf4d19d0/crates/utils/re_video/src/decode/av1.rs | crates/utils/re_video/src/decode/av1.rs | //! AV1 support.
use std::sync::atomic::{AtomicBool, Ordering};
use dav1d::{PixelLayout, PlanarImageComponent};
use super::async_decoder_wrapper::SyncDecoder;
use super::{
Chunk, DecodeError, Frame, FrameContent, FrameInfo, PixelFormat, Result, YuvMatrixCoefficients,
YuvPixelLayout, YuvRange,
};
use crate::d... | rust | Apache-2.0 | 910b1e72ca3ceb352b0bcf0d8d7de4f6bf4d19d0 | 2026-01-04T15:43:37.979050Z | false |
rerun-io/rerun | https://github.com/rerun-io/rerun/blob/910b1e72ca3ceb352b0bcf0d8d7de4f6bf4d19d0/crates/utils/re_video/src/decode/async_decoder_wrapper.rs | crates/utils/re_video/src/decode/async_decoder_wrapper.rs | use std::sync::Arc;
use std::sync::atomic::{AtomicBool, AtomicU64, Ordering};
use crossbeam::channel::{Receiver, Sender, unbounded};
use super::{AsyncDecoder, Chunk, Result};
#[cfg(with_dav1d)]
use crate::{VideoDataDescription, decode::FrameResult};
enum Command {
Chunk(Chunk),
// Boxed, because `VideoDataD... | rust | Apache-2.0 | 910b1e72ca3ceb352b0bcf0d8d7de4f6bf4d19d0 | 2026-01-04T15:43:37.979050Z | false |
rerun-io/rerun | https://github.com/rerun-io/rerun/blob/910b1e72ca3ceb352b0bcf0d8d7de4f6bf4d19d0/crates/utils/re_video/src/decode/ffmpeg_cli/version.rs | crates/utils/re_video/src/decode/ffmpeg_cli/version.rs | use std::collections::HashMap;
use std::path::PathBuf;
use std::task::Poll;
use parking_lot::Mutex;
use poll_promise::Promise;
// FFmpeg 5.1 "Riemann" is from 2022-07-22.
// It's simply the oldest I tested manually as of writing. We might be able to go lower.
// However, we also know that FFmpeg 4.4 is already no lon... | rust | Apache-2.0 | 910b1e72ca3ceb352b0bcf0d8d7de4f6bf4d19d0 | 2026-01-04T15:43:37.979050Z | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.