How do I convert flicks to seconds in C++?

Since flicks are a std::chrono::duration, use std::chrono::duration_cast to convert to seconds. For example, std::chrono::duration_cast (some_flicks) gives the duration, but note flicks are defined as 1/705600000 seconds for precise integer math.

Flicks or nanoseconds for video editing software?

Flicks are better for video editing because they exactly represent common frame rates without approximation errors. Nanoseconds can cause drift over time when accumulating frames, whereas flicks provide integer precision for media timelines, as explained in the motivation.

Does flicks support 144Hz monitors?

Yes, the README mentions that 144Hz works correctly with flicks, even though it wasn't part of the original design criteria, because the unit's definition allows exact representation for this refresh rate.

How to handle audio processing with flicks?

Flicks exactly match common audio sample rates like 44.1kHz and 48kHz. Use flicks to represent sample durations and accumulate them without error, ensuring perfect synchronization in audio-video applications, as listed in the supported rates.

What are the drawbacks of using flicks for NTSC video?

Flicks use 1000/1001 approximations for NTSC rates like 23.976fps, which is sufficient for many applications but doesn't handle the true variable frame rate of NTSC. For precise broadcast standards, additional logic may be needed, as cautioned in the README.

Can I use flicks in a real-time game engine?

Flicks can be used in game engines for timing physics simulations or frame pacing, especially if targeting media-standard frame rates. However, for arbitrary or very high refresh rates, ensure compatibility as flicks are optimized for specific rates, and performance should be tested against nanoseconds.

Open-Awesome

Flicks

NOASSERTIONC++

A C++ time unit for exact representation of common media framerates and audio sample rates using std::chrono.

GitHub

1.4k stars75 forks0 contributors

What is Flicks?

Flicks is a C++ time unit library that defines a 'frame-tick' as 1/705600000 of a second. It provides exact integer representations for common media framerates and audio sample rates, solving floating-point accumulation errors in time-sensitive simulations and media processing.

Target Audience

C++ developers working in visual effects, film, television, game development, or audio processing who need precise time management for simulations and media integration.

Value Proposition

Developers choose Flicks because it offers guaranteed temporal accuracy through integer math, seamless integration with std::chrono, and exact support for industry-standard frame and sample rates without approximation errors.

Overview

A unit of time defined in C++.

Use Cases

Best For

Accumulating simulated time in visual effects pipelines without floating-point drift
Synchronizing audio and video processing at exact sample and frame rates
Implementing frame-accurate media playback in C++ applications
Developing game engines that require precise timing for physics simulations
Creating tools for film and television post-production workflows
Building media converters that maintain exact temporal relationships

Not Ideal For

Applications requiring precise handling of NTSC's true variable frame rate beyond the 1000/1001 approximation
Projects in programming languages other than C++ that cannot easily integrate std::chrono-based libraries
Simple simulations or media players where floating-point time accumulation errors are negligible and added complexity isn't justified

Pros & Cons

Pros

Exact Integer Timing

Represents common frame rates like 24Hz and audio sample rates like 44.1kHz as integer flicks, eliminating floating-point drift in time accumulation, as detailed in the motivation and examples.

Seamless std::chrono Integration

Implemented as a std::chrono::duration type, allowing direct use with C++'s timing utilities and high-resolution clocks, mentioned in the basics and installation sections.

Header-Only Simplicity

Single-header library that can be included directly or defined in one line of code, minimizing integration overhead, as highlighted in the installation notes.

Broad Media Format Support

Covers a wide range of film, TV, and audio rates including approximations for NTSC, with specific integer values listed for each supported rate in the details section.

Cons

Approximate NTSC Handling

Uses 1000/1001 ratios for NTSC rates, which the README admits doesn't cover all nuances of variable frame rate playback, limiting precision for broadcast-standard applications.

Fixed Rate Limitations

Only supports a pre-defined set of frame and sample rates; arbitrary or emerging standards may not be exactly representable without modifying the base unit, as noted in the non-exhaustive list.

C++-Locked Implementation

Tightly coupled to C++'s std::chrono, making it unsuitable for non-C++ projects without significant adaptation, restricting its use to C++ ecosystems.

Frequently Asked Questions

Related Projects

stb

stb single-file public domain libraries for C/C++

Stars34,612

Forks8,088

Last commit1 month ago

{fmt}

A modern formatting library

Stars25,655

Forks3,045

Last commit13 hours ago

xxHash

Extremely fast non-cryptographic hash algorithm

Stars11,242

Forks914