From 52e69591add6a65a538614379cd6c2a3c4c92240 Mon Sep 17 00:00:00 2001
From: Greg Beard <gmbeard@googlemail.com>
Date: Sat, 2 Dec 2023 09:01:58 +0000
Subject: [PATCH] feat(performance) Multiple performance improvements and other
 fixes

Performance:
- Adds dedicated thread for dequeueing and writing encoded packets
- Use native (BGRA) colourspace for NVFBC capture
  Using the native colourspace means NVFBC doesn't have to perform any
  conversion. In theory, this will improve capture performance
- Allow NvFBC to wait up to a maximum time for a new frame

Fixes:
- Adds eventfd for cancelling contexts without timers
  Contexts without timers require this to be cancellable with
  `request_stop()`.
- Fixes memory leak in h/w frame context initialization

Other:
- Adds metrics for video and audio encoding frame times
- Adds performance report generator script
- Allows NvFBC adjusted FPS to be enabled/disabled with ENV var
  `SHADOW_CAST_STRICT_FPS`. Defaults to `1`.
- Add FAQ
---
 .gitignore                              |   1 +
 .versioning/changes/DyxXCHexJS.minor.md |   1 +
 .versioning/changes/S9GbUeHXdB.minor.md |   2 +-
 .versioning/changes/UaFV3jPgO3.minor.md |   1 +
 .versioning/changes/wekMseGz7z.patch.md |   1 +
 README.md                               |  19 +-
 doc/faq.md                              |  24 +++
 src/CMakeLists.txt                      |   5 +-
 src/av/codec.cpp                        |  19 +-
 src/av/codec.hpp                        |   2 +-
 src/handlers/audio_chunk_writer.cpp     |  26 ++-
 src/handlers/audio_chunk_writer.hpp     |  10 +-
 src/handlers/drm_video_frame_writer.cpp |  69 +++----
 src/handlers/drm_video_frame_writer.hpp |  14 +-
 src/handlers/video_frame_writer.cpp     |  71 +++----
 src/handlers/video_frame_writer.hpp     |  16 +-
 src/main.cpp                            | 243 ++++++++++++++++--------
 src/nvidia.cpp                          |   7 +-
 src/nvidia.hpp                          |   2 +-
 src/services.hpp                        |   2 +
 src/services/audio_service.cpp          |   3 +-
 src/services/context.cpp                |  47 ++++-
 src/services/context.hpp                |   5 +-
 src/services/drm_video_service.cpp      |   4 +-
 src/services/drm_video_service.hpp      |   5 +-
 src/services/encoder.cpp                |  37 ++++
 src/services/encoder.hpp                |  27 +++
 src/services/encoder_service.cpp        | 151 +++++++++++++++
 src/services/encoder_service.hpp        |  83 ++++++++
 src/services/video_service.cpp          |  14 +-
 src/services/video_service.hpp          |   3 +-
 src/utils.hpp                           |   1 +
 src/utils/cmd_line.cpp                  |  20 +-
 src/utils/cmd_line.hpp                  |   4 +-
 src/utils/frame_time.cpp                |  49 +++++
 src/utils/frame_time.hpp                |  26 +++
 src/utils/pool.hpp                      |  50 ++++-
 tools/make-dist                         |   1 +
 tools/metrics/average                   |  10 +-
 tools/metrics/percentile                |  12 +-
 tools/metrics/plot                      |  19 +-
 tools/next-version                      |  25 +++
 tools/performance-report                |  97 ++++++++++
 43 files changed, 974 insertions(+), 254 deletions(-)
 create mode 100644 .versioning/changes/DyxXCHexJS.minor.md
 create mode 100644 .versioning/changes/UaFV3jPgO3.minor.md
 create mode 100644 .versioning/changes/wekMseGz7z.patch.md
 create mode 100644 doc/faq.md
 create mode 100644 src/services/encoder.cpp
 create mode 100644 src/services/encoder.hpp
 create mode 100644 src/services/encoder_service.cpp
 create mode 100644 src/services/encoder_service.hpp
 create mode 100644 src/utils/frame_time.cpp
 create mode 100644 src/utils/frame_time.hpp
 create mode 100755 tools/next-version
 create mode 100755 tools/performance-report

diff --git a/.gitignore b/.gitignore
index 272d0fd..57fae5c 100644
--- a/.gitignore
+++ b/.gitignore
@@ -3,3 +3,4 @@ build/
 .private/
 experimental/
 dist/
+report/
diff --git a/.versioning/changes/DyxXCHexJS.minor.md b/.versioning/changes/DyxXCHexJS.minor.md
new file mode 100644
index 0000000..5bbb8f9
--- /dev/null
+++ b/.versioning/changes/DyxXCHexJS.minor.md
@@ -0,0 +1 @@
+Improves encoding performance by using a dedicated thread
diff --git a/.versioning/changes/S9GbUeHXdB.minor.md b/.versioning/changes/S9GbUeHXdB.minor.md
index 1ece5ab..d243ce9 100644
--- a/.versioning/changes/S9GbUeHXdB.minor.md
+++ b/.versioning/changes/S9GbUeHXdB.minor.md
@@ -1 +1 @@
-Adds a build-time option to enable timing metric collection for audio & video
+Adds a build-time option to enable frame time metric collection
diff --git a/.versioning/changes/UaFV3jPgO3.minor.md b/.versioning/changes/UaFV3jPgO3.minor.md
new file mode 100644
index 0000000..c72f8d1
--- /dev/null
+++ b/.versioning/changes/UaFV3jPgO3.minor.md
@@ -0,0 +1 @@
+Reduces frame "jitter" when capturing certain games in X11
diff --git a/.versioning/changes/wekMseGz7z.patch.md b/.versioning/changes/wekMseGz7z.patch.md
new file mode 100644
index 0000000..c4b2067
--- /dev/null
+++ b/.versioning/changes/wekMseGz7z.patch.md
@@ -0,0 +1 @@
+Fixes a memory leak in H/W encoding pipeline
diff --git a/README.md b/README.md
index c32a385..51c9319 100644
--- a/README.md
+++ b/README.md
@@ -9,6 +9,7 @@ Typical screen capture utilities copy the framebuffer data between host and GPU
 - [Building from source](#building-from-source)
 - [Installing](#installing)
 - [Alternative projects](#some-alternative-projects)
+- [FAQ](doc/faq.md)
 
 #### Example - Cyberpunk 2077
 [![Cyberpunk 2077](http://i3.ytimg.com/vi/frXGxrdgTLY/hqdefault.jpg)](https://www.youtube.com/watch?v=frXGxrdgTLY)
@@ -26,21 +27,15 @@ The resulting media/container type is determined by the extension of `<OUTPUT FI
 
 If no `OPTIONS` are specified then *Shadow Cast* will pick some sensible defaults for the audio/video encoders and sample/frame rates, but these can be changed by specifying the following `OPTIONS` on the command line...
 
-- `-A <AUDIO ENCODER>` - All options available to `ffmpeg` should work here. Defaults to `libopus`
-- `-V <VIDEO ENCODER>` - Available options are `h264_nvenc` and `hevc_nvenc`. Defaults to `hevc_nvenc`
-- `-f <FRAME RATE>` - Values from `20` to `60` are accepted. Defaults to `60`
-- `-s <SAMPLE RATE>` - Defaults to `48000` (_NOTE: Some encoders will only support certain sample rates. Shadow Cast will display an error if your chosen sample rate isn't supported_)
+| Option                    | Description   |
+|---------                  |------------   |
+| `-A <AUDIO ENCODER>`      | Audio encoder. All options available to `ffmpeg` should work here. Defaults to `libopus` |
+| `-V <VIDEO ENCODER>`      | Video encoder. Available options are `h264_nvenc` and `hevc_nvenc`. defaults to `hevc_nvenc` |
+| `-f <FRAMES PER SECOND>`  | Capture FPS. values from `20` to `70` are accepted. defaults to `60`  |
+| `-s <SAMPLE RATE>`        | Audio sample rate. Defaults to `48000` (_NOTE: Some encoders will only support certain sample rates. Shadow Cast will display an error if your chosen sample rate isn't supported_) |
 
 Ctrl+C / SIGINT will stop the capture session and finalize the output media.
 
-### Help. I'm getting the following error
-
-#### `ERROR: Couldn't create NvFBC instance`
-*Shadow Cast* uses the *NvFBC* facility to provide efficient, low-latency framebuffer capture on X11. By default, NVIDIA disables this on most (if not all) of its consumer-level GPUs. However, there are two ways around this restriction...
-
-- You can find a utility to patch your NVIDIA drivers in the [keylase/nvidia-patch](https://github.com/keylase/nvidia-patch) GitHub repo.
-- You can obtain a "key" to unlock this feature at runtime. The key can be set at runtime via the `SHADOW_CAST_NVFBC_KEY=<BASE64 ENCODED KEY>` environment variable. I use this method but I'm not sure how "official" it is, so no keys are provided in this repo. Feel free to message me about this.
-
 ### Requirements
 - FFMpeg (libav)
 - NVIDIA GPU, supporting NVENC and NvFBC
diff --git a/doc/faq.md b/doc/faq.md
new file mode 100644
index 0000000..3dc5b68
--- /dev/null
+++ b/doc/faq.md
@@ -0,0 +1,24 @@
+### Q. Help, I'm getting the following error
+
+```
+ERROR: Couldn't create NvFBC instance
+```
+
+#### A.
+*Shadow Cast* uses the *NvFBC* facility to provide efficient, low-latency framebuffer capture on X11. By default, NVIDIA disables this on most (if not all) of its consumer-level GPUs. However, there are two ways around this restriction...
+
+- You can find a utility to patch your NVIDIA drivers in the [keylase/nvidia-patch](https://github.com/keylase/nvidia-patch) GitHub repo.
+- You can obtain a "key" to unlock this feature at runtime. The key can be set at runtime via the `SHADOW_CAST_NVFBC_KEY=<BASE64 ENCODED KEY>` environment variable. I use this method but I'm not sure how "official" it is, so no keys are provided in this repo. Feel free to message me about this.
+
+### Q. I'm capturing gameplay footage on X11 and my game is "laggy"
+
+#### A.
+In some games, the NVIDIA Capture library (*NvFBC*) appears to interact poorly with v-sync if your refresh rate matches the capture FPS. Try disabling v-sync. Another option you can try is to set the following environment variable when capturing...
+
+```
+$ SHADOW_CAST_STRICT_FPS=0 shadow-cast ...
+```
+
+Please note, however, using this option will scale the output video's frame rate to match NvFBC's closest match (e.g. `62.5` in the case of a 60fps capture).
+
+I haven't quite worked out the definitive cause of this "lagginess", but I suspect it is because NvFBC only accepts integer millisecond values as its sampling rate, so cannot exactly match *Shadow Cast*'s frame rate. For example, 60fps would require a fractional sampling frequency of `16.666` milliseconds, and NvFBC only allows either `16` or `17` milliseconds.
diff --git a/src/CMakeLists.txt b/src/CMakeLists.txt
index 18b1954..d1b700a 100644
--- a/src/CMakeLists.txt
+++ b/src/CMakeLists.txt
@@ -35,6 +35,8 @@ add_library(shadow-cast-obj
     services/audio_service.cpp
     services/context.cpp
     services/drm_video_service.cpp
+    services/encoder.cpp
+    services/encoder_service.cpp
     services/metrics_service.cpp
     services/readiness.cpp
     services/service.cpp
@@ -42,10 +44,11 @@ add_library(shadow-cast-obj
     services/signal_service.cpp
     services/video_service.cpp
 
+    utils/base64.cpp
     utils/cmd_line.cpp
     utils/contracts.cpp
-    utils/base64.cpp
     utils/elapsed.cpp
+    utils/frame_time.cpp
     utils/result.cpp
 
     error.cpp
diff --git a/src/av/codec.cpp b/src/av/codec.cpp
index fddc14f..1882c0c 100644
--- a/src/av/codec.cpp
+++ b/src/av/codec.cpp
@@ -18,7 +18,7 @@ auto create_video_encoder(std::string const& encoder_name,
                           CUcontext cuda_ctx,
                           AVBufferPool* pool,
                           VideoOutputSize size,
-                          std::uint32_t fps,
+                          FrameTime const& ft,
                           AVPixelFormat pixel_format) -> sc::CodecContextPtr
 {
     sc::BorrowedPtr<AVCodec const> video_encoder { avcodec_find_encoder_by_name(
@@ -30,10 +30,10 @@ auto create_video_encoder(std::string const& encoder_name,
     sc::CodecContextPtr video_encoder_context { avcodec_alloc_context3(
         video_encoder.get()) };
     video_encoder_context->codec_id = video_encoder->id;
-    video_encoder_context->time_base.num = 1;
-    video_encoder_context->time_base.den = fps;
-    video_encoder_context->framerate.num = fps;
-    video_encoder_context->framerate.den = 1;
+    auto const timebase = ft.per_second_ratio();
+    video_encoder_context->time_base = timebase;
+    video_encoder_context->framerate.num = timebase.den;
+    video_encoder_context->framerate.den = timebase.num;
     video_encoder_context->sample_aspect_ratio.num = 0;
     video_encoder_context->sample_aspect_ratio.den = 0;
     video_encoder_context->max_b_frames = 0;
@@ -69,9 +69,6 @@ auto create_video_encoder(std::string const& encoder_name,
     hw_frame_context->height = video_encoder_context->height;
     hw_frame_context->sw_format = pixel_format;
     hw_frame_context->format = video_encoder_context->pix_fmt;
-    hw_frame_context->device_ref = av_buffer_ref(device_ctx.get());
-    hw_frame_context->device_ctx =
-        reinterpret_cast<AVHWDeviceContext*>(device_ctx->data);
 
     hw_frame_context->pool = pool;
     hw_frame_context->initial_pool_size = 1;
@@ -81,11 +78,7 @@ auto create_video_encoder(std::string const& encoder_name,
                                    av_error_to_string(ret) };
     }
 
-    /* TODO: Are we doing this correctly? It seems to be the
-     * source of memory leak...
-     */
-    video_encoder_context->hw_device_ctx = device_ctx.release();
-    video_encoder_context->hw_frames_ctx = frame_context.release();
+    video_encoder_context->hw_frames_ctx = av_buffer_ref(frame_context.get());
 
     AVDictionary* options = nullptr;
     av_dict_set_int(&options, "qp", 21, 0);
diff --git a/src/av/codec.hpp b/src/av/codec.hpp
index 5d1e722..e3089f7 100644
--- a/src/av/codec.hpp
+++ b/src/av/codec.hpp
@@ -25,7 +25,7 @@ auto create_video_encoder(std::string const& encoder_name,
                           CUcontext cuda_ctx,
                           AVBufferPool* pool,
                           VideoOutputSize size,
-                          std::uint32_t fps,
+                          FrameTime const& ft,
                           AVPixelFormat pixel_format) -> sc::CodecContextPtr;
 } // namespace sc
 
diff --git a/src/handlers/audio_chunk_writer.cpp b/src/handlers/audio_chunk_writer.cpp
index db952d2..e4df8c0 100644
--- a/src/handlers/audio_chunk_writer.cpp
+++ b/src/handlers/audio_chunk_writer.cpp
@@ -3,6 +3,7 @@
 #include "av/sample_format.hpp"
 #include "config.hpp"
 #include "error.hpp"
+#include "services/encoder.hpp"
 #include <algorithm>
 #include <cassert>
 #include <memory>
@@ -11,15 +12,14 @@
 namespace sc
 {
 
-ChunkWriter::ChunkWriter(AVFormatContext* format_context,
-                         AVCodecContext* codec_context,
-                         AVStream* stream) noexcept
-    : format_context_ { format_context }
-    , codec_context_ { codec_context }
+ChunkWriter::ChunkWriter(AVCodecContext* codec_context,
+                         AVStream* stream,
+                         Encoder encoder) noexcept
+    : codec_context_ { codec_context }
     , stream_ { stream }
+    , encoder_ { encoder }
     , frame_ { av_frame_alloc() }
     , total_samples_written_ { 0 }
-    , packet_ { av_packet_alloc() }
 {
 }
 
@@ -32,7 +32,9 @@ auto ChunkWriter::operator()(MediaChunk const& chunk) -> void
     auto const sample_size = sc::sample_format_size(sample_format);
     auto const interleaved = sc::is_interleaved_format(sample_format);
 
-    sc::BorrowedPtr<AVFrame> frame = frame_.get();
+    auto encoder_frame =
+        encoder_.prepare_frame(codec_context_.get(), stream_.get());
+    auto* frame = encoder_frame->frame.get();
 
     frame->nb_samples = chunk.sample_count;
     frame->format = codec_context_->sample_fmt;
@@ -46,9 +48,7 @@ auto ChunkWriter::operator()(MediaChunk const& chunk) -> void
     frame->pts = total_samples_written_;
     total_samples_written_ += frame->nb_samples;
 
-    sc::initialize_writable_buffer(frame.get());
-
-    AVFrameUnrefGuard unref_guard { frame };
+    sc::initialize_writable_buffer(frame);
 
     auto n = 0;
     for (auto const& channel_buffer : chunk.channel_buffers()) {
@@ -63,11 +63,7 @@ auto ChunkWriter::operator()(MediaChunk const& chunk) -> void
         std::copy(begin(source), end(source), begin(target));
     }
 
-    send_frame(frame.get(),
-               codec_context_.get(),
-               format_context_.get(),
-               stream_.get(),
-               packet_.get());
+    encoder_.write_frame(std::move(encoder_frame));
 }
 
 } // namespace sc
diff --git a/src/handlers/audio_chunk_writer.hpp b/src/handlers/audio_chunk_writer.hpp
index 7b98dc5..917235f 100644
--- a/src/handlers/audio_chunk_writer.hpp
+++ b/src/handlers/audio_chunk_writer.hpp
@@ -2,6 +2,7 @@
 #define SHADOW_CAST_HANDLERS_AUDIO_CHUNK_WRITER_HPP_INCLUDED
 
 #include "av.hpp"
+#include "services/encoder.hpp"
 #include "utils/borrowed_ptr.hpp"
 
 namespace sc
@@ -9,19 +10,18 @@ namespace sc
 
 struct ChunkWriter
 {
-    explicit ChunkWriter(AVFormatContext* format_context,
-                         AVCodecContext* codec_context,
-                         AVStream* stream) noexcept;
+    explicit ChunkWriter(AVCodecContext* codec_context,
+                         AVStream* stream,
+                         Encoder encoder) noexcept;
 
     auto operator()(MediaChunk const& chunk) -> void;
 
 private:
-    BorrowedPtr<AVFormatContext> format_context_;
     BorrowedPtr<AVCodecContext> codec_context_;
     BorrowedPtr<AVStream> stream_;
+    Encoder encoder_;
     FramePtr frame_;
     std::size_t total_samples_written_ { 0 };
-    PacketPtr packet_;
 };
 
 } // namespace sc
diff --git a/src/handlers/drm_video_frame_writer.cpp b/src/handlers/drm_video_frame_writer.cpp
index 566ef34..8eb44da 100644
--- a/src/handlers/drm_video_frame_writer.cpp
+++ b/src/handlers/drm_video_frame_writer.cpp
@@ -1,38 +1,45 @@
 #include "handlers/drm_video_frame_writer.hpp"
+#include "services/encoder.hpp"
 #include "utils/elapsed.hpp"
 
 namespace sc
 {
 
-DRMVideoFrameWriter::DRMVideoFrameWriter(AVFormatContext* fmt_context,
-                                         AVCodecContext* codec_context,
-                                         AVStream* stream)
-    : format_context_ { fmt_context }
-    , codec_context_ { codec_context }
+DRMVideoFrameWriter::DRMVideoFrameWriter(AVCodecContext* codec_context,
+                                         AVStream* stream,
+                                         Encoder encoder)
+    : codec_context_ { codec_context }
     , stream_ { stream }
-    , frame_ { av_frame_alloc() }
-    , packet_ { av_packet_alloc() }
+    , encoder_ { encoder }
 {
-    frame_->format = codec_context_->pix_fmt;
-    frame_->width = codec_context_->width;
-    frame_->height = codec_context_->height;
-    frame_->color_range = codec_context_->color_range;
-    frame_->color_primaries = codec_context_->color_primaries;
-    frame_->color_trc = codec_context_->color_trc;
-    frame_->colorspace = codec_context_->colorspace;
-    frame_->chroma_location = codec_context_->chroma_sample_location;
-    if (auto const r = av_hwframe_get_buffer(
-            codec_context_->hw_frames_ctx, frame_.get(), 0);
-        r < 0)
-        throw std::runtime_error { "Failed to get H/W frame buffer" };
 }
 
-auto DRMVideoFrameWriter::operator()(CUarray data, NvCuda const& cuda) -> void
+auto DRMVideoFrameWriter::operator()(CUarray data,
+                                     NvCuda const& cuda,
+                                     std::uint64_t frame_time) -> void
 {
     SC_EXPECT(data);
-    SC_EXPECT(frame_->linesize[0]);
-    SC_EXPECT(frame_->height);
-    SC_EXPECT(frame_->data[0]);
+
+    auto encoder_frame =
+        encoder_.prepare_frame(codec_context_.get(), stream_.get());
+    auto* frame = encoder_frame->frame.get();
+
+    frame->format = codec_context_->pix_fmt;
+    frame->width = codec_context_->width;
+    frame->height = codec_context_->height;
+    frame->color_range = codec_context_->color_range;
+    frame->color_primaries = codec_context_->color_primaries;
+    frame->color_trc = codec_context_->color_trc;
+    frame->colorspace = codec_context_->colorspace;
+    frame->chroma_location = codec_context_->chroma_sample_location;
+    if (auto const r =
+            av_hwframe_get_buffer(codec_context_->hw_frames_ctx, frame, 0);
+        r < 0)
+        throw std::runtime_error { "Failed to get H/W frame buffer" };
+
+    SC_EXPECT(frame->linesize[0]);
+    SC_EXPECT(frame->height);
+    SC_EXPECT(frame->data[0]);
 
     CUDA_MEMCPY2D memcpy_struct {};
 
@@ -43,10 +50,10 @@ auto DRMVideoFrameWriter::operator()(CUarray data, NvCuda const& cuda) -> void
     memcpy_struct.dstY = 0;
     memcpy_struct.dstMemoryType = CU_MEMORYTYPE_DEVICE;
     memcpy_struct.srcArray = data;
-    memcpy_struct.dstDevice = reinterpret_cast<CUdeviceptr>(frame_->data[0]);
-    memcpy_struct.dstPitch = frame_->linesize[0];
-    memcpy_struct.WidthInBytes = frame_->linesize[0];
-    memcpy_struct.Height = frame_->height;
+    memcpy_struct.dstDevice = reinterpret_cast<CUdeviceptr>(frame->data[0]);
+    memcpy_struct.dstPitch = frame->linesize[0];
+    memcpy_struct.WidthInBytes = frame->linesize[0];
+    memcpy_struct.Height = frame->height;
 
     if (auto const r = cuda.cuMemcpy2D_v2(&memcpy_struct); r != CUDA_SUCCESS) {
         char const* err = "unknown";
@@ -57,13 +64,9 @@ auto DRMVideoFrameWriter::operator()(CUarray data, NvCuda const& cuda) -> void
         };
     }
 
-    frame_->pts = frame_number_++;
+    frame->pts = frame_time * frame_number_++;
 
-    send_frame(frame_.get(),
-               codec_context_.get(),
-               format_context_.get(),
-               stream_.get(),
-               packet_.get());
+    encoder_.write_frame(std::move(encoder_frame));
 }
 
 } // namespace sc
diff --git a/src/handlers/drm_video_frame_writer.hpp b/src/handlers/drm_video_frame_writer.hpp
index 785dfd7..c371b86 100644
--- a/src/handlers/drm_video_frame_writer.hpp
+++ b/src/handlers/drm_video_frame_writer.hpp
@@ -3,24 +3,24 @@
 
 #include "av.hpp"
 #include "nvidia.hpp"
+#include "services/encoder.hpp"
+#include <cstdint>
 
 namespace sc
 {
 struct DRMVideoFrameWriter
 {
-    DRMVideoFrameWriter(AVFormatContext* fmt_context,
-                        AVCodecContext* codec_context,
-                        AVStream* stream);
+    DRMVideoFrameWriter(AVCodecContext* codec_context,
+                        AVStream* stream,
+                        Encoder encoder);
 
-    auto operator()(CUarray, NvCuda const&) -> void;
+    auto operator()(CUarray, NvCuda const&, std::uint64_t) -> void;
 
 private:
-    BorrowedPtr<AVFormatContext> format_context_;
     BorrowedPtr<AVCodecContext> codec_context_;
     BorrowedPtr<AVStream> stream_;
-    FramePtr frame_;
+    Encoder encoder_;
     std::size_t frame_number_ { 0 };
-    PacketPtr packet_;
 };
 
 } // namespace sc
diff --git a/src/handlers/video_frame_writer.cpp b/src/handlers/video_frame_writer.cpp
index c562ee7..3a6550a 100644
--- a/src/handlers/video_frame_writer.cpp
+++ b/src/handlers/video_frame_writer.cpp
@@ -1,61 +1,50 @@
 #include "handlers/video_frame_writer.hpp"
 #include "handlers/audio_chunk_writer.hpp"
+#include "services/encoder.hpp"
 #include "utils/elapsed.hpp"
 
-auto constexpr kCudaFrameAlignment = 256;
 namespace sc
 {
 
-VideoFrameWriter::VideoFrameWriter(AVFormatContext* fmt_context,
-                                   AVCodecContext* codec_context,
-                                   AVStream* stream)
-    : format_context_ { fmt_context }
-    , codec_context_ { codec_context }
+VideoFrameWriter::VideoFrameWriter(AVCodecContext* codec_context,
+                                   AVStream* stream,
+                                   Encoder encoder)
+    : codec_context_ { codec_context }
     , stream_ { stream }
-    , frame_ { av_frame_alloc() }
-    , packet_ { av_packet_alloc() }
+    , encoder_ { encoder }
 {
 }
 
 auto VideoFrameWriter::operator()(CUdeviceptr cu_device_ptr,
-                                  NVFBC_FRAME_GRAB_INFO) -> void
+                                  NVFBC_FRAME_GRAB_INFO,
+                                  std::uint64_t frame_time) -> void
 {
-    auto aligned_width = FFALIGN(codec_context_->width, kCudaFrameAlignment);
+    auto encoder_frame =
+        encoder_.prepare_frame(codec_context_.get(), stream_.get());
+    auto* frame = encoder_frame->frame.get();
 
-    sc::AVFrameUnrefGuard unref_guard { frame_.get() };
-
-    frame_->hw_frames_ctx = av_buffer_ref(codec_context_->hw_frames_ctx);
+    frame->hw_frames_ctx = av_buffer_ref(codec_context_->hw_frames_ctx);
 
     auto hw_frames_ctx = reinterpret_cast<AVHWFramesContext*>(
         codec_context_->hw_frames_ctx->data);
-    frame_->buf[0] = av_buffer_pool_get(hw_frames_ctx->pool);
-
-    /* Layout for yuv444p...
-     */
-    frame_->data[0] = reinterpret_cast<uint8_t*>(cu_device_ptr);
-    frame_->data[1] = frame_->data[0] + aligned_width * codec_context_->height;
-    frame_->data[2] = frame_->data[1] + aligned_width * codec_context_->height;
-    frame_->linesize[0] = aligned_width;
-    frame_->linesize[1] = aligned_width;
-    frame_->linesize[2] = aligned_width;
-
-    frame_->extended_data = frame_->data;
-    frame_->format = codec_context_->pix_fmt;
-    frame_->width = codec_context_->width;
-    frame_->height = codec_context_->height;
-    frame_->color_range = codec_context_->color_range;
-    frame_->color_primaries = codec_context_->color_primaries;
-    frame_->color_trc = codec_context_->color_trc;
-    frame_->colorspace = codec_context_->colorspace;
-    frame_->chroma_location = codec_context_->chroma_sample_location;
-
-    frame_->pts = frame_number_++;
-
-    send_frame(frame_.get(),
-               codec_context_.get(),
-               format_context_.get(),
-               stream_.get(),
-               packet_.get());
+    frame->buf[0] = av_buffer_pool_get(hw_frames_ctx->pool);
+
+    frame->data[0] = reinterpret_cast<uint8_t*>(cu_device_ptr);
+    frame->linesize[0] = codec_context_->width * sizeof(std::uint32_t);
+
+    frame->extended_data = frame->data;
+    frame->format = codec_context_->pix_fmt;
+    frame->width = codec_context_->width;
+    frame->height = codec_context_->height;
+    frame->color_range = codec_context_->color_range;
+    frame->color_primaries = codec_context_->color_primaries;
+    frame->color_trc = codec_context_->color_trc;
+    frame->colorspace = codec_context_->colorspace;
+    frame->chroma_location = codec_context_->chroma_sample_location;
+
+    frame->pts = frame_time * frame_number_++;
+
+    encoder_.write_frame(std::move(encoder_frame));
 }
 
 } // namespace sc
diff --git a/src/handlers/video_frame_writer.hpp b/src/handlers/video_frame_writer.hpp
index 6e9ed50..51c7e87 100644
--- a/src/handlers/video_frame_writer.hpp
+++ b/src/handlers/video_frame_writer.hpp
@@ -3,24 +3,26 @@
 
 #include "av.hpp"
 #include "nvidia.hpp"
+#include "services/encoder.hpp"
+#include <cstdint>
 
 namespace sc
 {
 struct VideoFrameWriter
 {
-    VideoFrameWriter(AVFormatContext* fmt_context,
-                     AVCodecContext* codec_context,
-                     AVStream* stream);
+    VideoFrameWriter(AVCodecContext* codec_context,
+                     AVStream* stream,
+                     Encoder encoder);
 
-    auto operator()(CUdeviceptr cu_device_ptr, NVFBC_FRAME_GRAB_INFO) -> void;
+    auto operator()(CUdeviceptr cu_device_ptr,
+                    NVFBC_FRAME_GRAB_INFO,
+                    std::uint64_t) -> void;
 
 private:
-    BorrowedPtr<AVFormatContext> format_context_;
     BorrowedPtr<AVCodecContext> codec_context_;
     BorrowedPtr<AVStream> stream_;
-    FramePtr frame_;
+    Encoder encoder_;
     std::size_t frame_number_ { 0 };
-    PacketPtr packet_;
 };
 
 } // namespace sc
diff --git a/src/main.cpp b/src/main.cpp
index 5b138f2..4ccc074 100644
--- a/src/main.cpp
+++ b/src/main.cpp
@@ -1,4 +1,5 @@
 #include "./shadow_cast.hpp"
+#include "utils/frame_time.hpp"
 
 #include <X11/Xlib.h>
 #include <cassert>
@@ -7,6 +8,7 @@
 #include <cstdio>
 #include <initializer_list>
 #include <iostream>
+#include <memory>
 #include <signal.h>
 #include <thread>
 #include <type_traits>
@@ -70,6 +72,103 @@ struct DestroyCaptureSessionGuard
     sc::NvFBC nvfbc;
 };
 
+auto run_loop(sc::Context& main,
+              sc::Context& media,
+              sc::Context& audio SC_METRICS_PARAM_DEFINE(sc::Context&, metrics),
+              sc::BorrowedPtr<AVCodecContext> video_codec,
+              sc::BorrowedPtr<AVStream> video_stream,
+              sc::BorrowedPtr<AVCodecContext> audio_codec,
+              sc::BorrowedPtr<AVStream> audio_stream) -> void
+{
+    std::mutex exception_mutex;
+    std::exception_ptr ex;
+    sc::Encoder encoder { media };
+
+    auto const stop = [&] {
+#ifdef SHADOW_CAST_ENABLE_METRICS
+        metrics.request_stop();
+#endif
+        main.request_stop();
+        audio.request_stop();
+    };
+
+    main.services().add<sc::SignalService>(sc::SignalService {});
+    add_signal_handler(main, SIGINT, [&](std::uint32_t) { stop(); });
+
+#ifdef SHADOW_CAST_ENABLE_METRICS
+    auto metrics_thread = std::thread([&] {
+        SC_SCOPE_GUARD([&] { stop(); });
+        try {
+            metrics.run();
+        }
+        catch (...) {
+            std::lock_guard lock { exception_mutex };
+            if (!ex)
+                ex = std::current_exception();
+        }
+    });
+#endif
+
+    auto media_thread = std::thread([&] {
+        SC_SCOPE_GUARD([&] { stop(); });
+        try {
+            media.run();
+        }
+        catch (...) {
+            std::lock_guard lock { exception_mutex };
+            if (!ex)
+                ex = std::current_exception();
+        }
+    });
+
+    auto audio_thread = std::thread([&] {
+        SC_SCOPE_GUARD([&] { stop(); });
+        try {
+            audio.run();
+        }
+        catch (...) {
+            std::lock_guard lock { exception_mutex };
+            if (!ex)
+                ex = std::current_exception();
+        }
+    });
+
+    {
+        SC_SCOPE_GUARD([&] { stop(); });
+        try {
+            main.run();
+        }
+        catch (...) {
+            std::lock_guard lock { exception_mutex };
+            if (!ex)
+                ex = std::current_exception();
+        }
+    }
+
+    std::cerr << "Finalizing output. Please wait...\n";
+
+#ifdef SHADOW_CAST_ENABLE_METRICS
+    metrics_thread.join();
+#endif
+    audio_thread.join();
+
+    try {
+        encoder.flush(video_codec.get(), video_stream.get());
+        encoder.flush(audio_codec.get(), audio_stream.get());
+    }
+    catch (...) {
+        std::lock_guard lock { exception_mutex };
+        if (!ex)
+            ex = std::current_exception();
+    }
+
+    media.request_stop();
+    media_thread.join();
+
+    if (ex)
+        std::rethrow_exception(ex);
+}
+
 auto run_wayland(sc::Parameters const& params, sc::wayland::DisplayPtr display)
     -> void
 {
@@ -161,7 +260,7 @@ auto run_wayland(sc::Parameters const& params, sc::wayland::DisplayPtr display)
         cuda_ctx.get(),
         nullptr, /*buffer_pool.get(),*/
         { .width = wayland->output_width, .height = wayland->output_height },
-        params.frame_rate,
+        params.frame_time,
         AV_PIX_FMT_BGR0);
 
     sc::BorrowedPtr<AVStream> video_stream { avformat_new_stream(
@@ -200,13 +299,14 @@ auto run_wayland(sc::Parameters const& params, sc::wayland::DisplayPtr display)
     }
 
 #ifdef SHADOW_CAST_ENABLE_METRICS
-    sc::Context metrics_ctx { static_cast<std::uint32_t>(params.frame_rate) };
+    sc::Context metrics_ctx { params.frame_time };
     metrics_ctx.services().add_from_factory<sc::MetricsService>([&] {
         return std::make_unique<sc::MetricsService>(params.output_file);
     });
 #endif
-    sc::Context ctx { static_cast<std::uint32_t>(params.frame_rate) };
-    sc::Context audio_ctx { static_cast<std::uint32_t>(params.frame_rate) };
+    sc::Context ctx { params.frame_time };
+    sc::Context audio_ctx { params.frame_time };
+    sc::Context media_ctx { params.frame_time };
 
     ctx.services().add<sc::SignalService>(sc::SignalService {});
     add_signal_handler(ctx, SIGINT, [&](std::uint32_t) {
@@ -235,50 +335,36 @@ auto run_wayland(sc::Parameters const& params, sc::wayland::DisplayPtr display)
                 metrics_ctx.services().use_if<sc::MetricsService>()));
     });
 
+    media_ctx.services().add_from_factory<sc::EncoderService>([&] {
+        return std::make_unique<sc::EncoderService>(
+            format_context.get() SC_METRICS_PARAM_USE(
+                metrics_ctx.services().use_if<sc::MetricsService>()));
+    });
+
+    sc::Encoder media_writer { media_ctx };
+
     set_audio_chunk_handler(audio_ctx,
-                            sc::ChunkWriter { format_context.get(),
-                                              audio_encoder_context.get(),
-                                              stream.get() });
+                            sc::ChunkWriter { audio_encoder_context.get(),
+                                              stream.get(),
+                                              media_writer });
     set_drm_video_frame_handler(
         ctx,
-        sc::DRMVideoFrameWriter { format_context.get(),
-                                  video_encoder_context.get(),
-                                  video_stream.get() });
-
-    set_stream_end_handler(audio_ctx,
-                           sc::StreamFinalizer { format_context.get(),
-                                                 audio_encoder_context.get(),
-                                                 video_encoder_context.get(),
-                                                 stream.get(),
-                                                 video_stream.get() });
-
-#ifdef SHADOW_CAST_ENABLE_METRICS
-    auto metrics_thread = std::thread([&] { metrics_ctx.run(); });
-#endif
-    auto audio_thread = std::thread([&] {
-        try {
-            audio_ctx.run();
-        }
-        catch (std::exception const& e) {
-            std::cerr << "Audio capture failed: " << e.what() << '\n';
-        }
-    });
+        sc::DRMVideoFrameWriter {
+            video_encoder_context.get(), video_stream.get(), media_writer });
 
     SC_SCOPE_GUARD([&] {
-        audio_ctx.request_stop();
-        audio_thread.join();
-#ifdef SHADOW_CAST_ENABLE_METRICS
-        metrics_thread.join();
-#endif
-        std::cerr << "Finalizing output...";
-        if (auto const ret = av_write_trailer(format_context.get()); ret < 0) {
+        if (auto const ret = av_write_trailer(format_context.get()); ret < 0)
             std::cerr << "Failed to write trailer: "
-                      << sc::av_error_to_string(ret);
-        }
-        std::cerr << '\n';
+                      << sc::av_error_to_string(ret) << '\n';
     });
 
-    ctx.run();
+    run_loop(ctx,
+             media_ctx,
+             audio_ctx SC_METRICS_PARAM_USE(metrics_ctx),
+             video_encoder_context.get(),
+             video_stream.get(),
+             audio_encoder_context.get(),
+             stream.get());
 }
 
 auto run(sc::Parameters const& params) -> void
@@ -299,7 +385,7 @@ auto run(sc::Parameters const& params) -> void
      */
     auto nvfbc_instance = sc::create_nvfbc_session(nvfbc);
     sc::create_nvfbc_capture_session(
-        nvfbc_instance.get(), nvfbc, params.frame_rate);
+        nvfbc_instance.get(), nvfbc, params.frame_time);
 
     DestroyCaptureSessionGuard destroy_capture_session_guard {
         nvfbc_instance.get(), nvfbc
@@ -393,8 +479,8 @@ auto run(sc::Parameters const& params) -> void
                                  cuda_ctx.get(),
                                  buffer_pool.get(),
                                  size,
-                                 params.frame_rate,
-                                 AV_PIX_FMT_YUV444P);
+                                 params.frame_time,
+                                 AV_PIX_FMT_BGR0);
 
     sc::BorrowedPtr<AVStream> video_stream { avformat_new_stream(
         format_context.get(), video_encoder_context->codec) };
@@ -431,10 +517,11 @@ auto run(sc::Parameters const& params) -> void
                             sc::av_error_to_string(ret) };
     }
 
-    sc::Context ctx { static_cast<std::uint32_t>(params.frame_rate) };
-    sc::Context audio_ctx { static_cast<std::uint32_t>(params.frame_rate) };
+    sc::Context ctx { params.frame_time };
+    sc::Context audio_ctx { params.frame_time };
+    sc::Context media_ctx { params.frame_time };
 #ifdef SHADOW_CAST_ENABLE_METRICS
-    sc::Context metrics_ctx { static_cast<std::uint32_t>(params.frame_rate) };
+    sc::Context metrics_ctx { params.frame_time };
     metrics_ctx.services().add_from_factory<sc::MetricsService>([&] {
         return std::make_unique<sc::MetricsService>(params.output_file);
     });
@@ -465,43 +552,43 @@ auto run(sc::Parameters const& params) -> void
                 metrics_ctx.services().use_if<sc::MetricsService>()));
     });
 
+    media_ctx.services().add_from_factory<sc::EncoderService>([&] {
+        return std::make_unique<sc::EncoderService>(
+            format_context.get() SC_METRICS_PARAM_USE(
+                metrics_ctx.services().use_if<sc::MetricsService>()));
+    });
+
+    sc::Encoder media_writer { media_ctx };
+
     set_audio_chunk_handler(audio_ctx,
-                            sc::ChunkWriter { format_context.get(),
-                                              audio_encoder_context.get(),
-                                              stream.get() });
+                            sc::ChunkWriter { audio_encoder_context.get(),
+                                              stream.get(),
+                                              media_writer });
     set_video_frame_handler(ctx,
-                            sc::VideoFrameWriter { format_context.get(),
-                                                   video_encoder_context.get(),
-                                                   video_stream.get() });
-
-    set_stream_end_handler(audio_ctx,
-                           sc::StreamFinalizer { format_context.get(),
-                                                 audio_encoder_context.get(),
-                                                 video_encoder_context.get(),
-                                                 stream.get(),
-                                                 video_stream.get() });
+                            sc::VideoFrameWriter { video_encoder_context.get(),
+                                                   video_stream.get(),
+                                                   media_writer });
 
-#ifdef SHADOW_CAST_ENABLE_METRICS
-    auto metrics_thread = std::thread([&] { metrics_ctx.run(); });
-#endif
-    auto audio_thread = std::thread([&] { audio_ctx.run(); });
-    ctx.run();
-    audio_thread.join();
-#ifdef SHADOW_CAST_ENABLE_METRICS
-    metrics_thread.join();
-#endif
+    SC_SCOPE_GUARD([&] {
+        if (auto const ret = av_write_trailer(format_context.get()); ret < 0)
+            std::cerr << "Failed to write trailer: "
+                      << sc::av_error_to_string(ret) << '\n';
+    });
 
-    std::cerr << "Finalizing output...\n";
-    if (auto const ret = av_write_trailer(format_context.get()); ret < 0)
-        throw std::runtime_error { "Failed to write trailer: " +
-                                   sc::av_error_to_string(ret) };
+    run_loop(ctx,
+             media_ctx,
+             audio_ctx SC_METRICS_PARAM_USE(metrics_ctx),
+             video_encoder_context.get(),
+             video_stream.get(),
+             audio_encoder_context.get(),
+             stream.get());
 }
 
 auto main(int argc, char const** argv) -> int
 {
     try {
         sc::block_signals({ SIGINT, SIGCHLD });
-        auto const params =
+        auto params =
             sc::get_parameters(sc::parse_cmd_line(argc - 1, argv + 1));
 
         if (!params) {
@@ -523,8 +610,14 @@ auto main(int argc, char const** argv) -> int
             if (wayland_display)
                 run_wayland(sc::get_value(std::move(params)),
                             std::move(wayland_display));
-            else
-                run(sc::get_value(std::move(params)));
+            else {
+                auto p = sc::get_value(std::move(params));
+
+                if (!p.strict_frame_time)
+                    p.frame_time = sc::truncate_to_millisecond(p.frame_time);
+
+                run(std::move(p));
+            }
         }
     }
     catch (std::exception const& e) {
diff --git a/src/nvidia.cpp b/src/nvidia.cpp
index bdec96f..cf76383 100644
--- a/src/nvidia.cpp
+++ b/src/nvidia.cpp
@@ -1,6 +1,7 @@
 #include "nvidia.hpp"
 #include "nvidia/cuda.hpp"
 #include "utils/base64.hpp"
+#include "utils/frame_time.hpp"
 #include "utils/symbol.hpp"
 #include <dlfcn.h>
 
@@ -145,14 +146,14 @@ auto create_nvfbc_session(sc::NvFBC instance) -> sc::NvFBCSessionHandlePtr
 
 auto create_nvfbc_capture_session(NVFBC_SESSION_HANDLE nvfbc_handle,
                                   NvFBC nvfbc,
-                                  std::uint32_t fps) -> void
+                                  FrameTime const& frame_time) -> void
 {
     NVFBC_CREATE_CAPTURE_SESSION_PARAMS create_capture_params {};
     create_capture_params.dwVersion = NVFBC_CREATE_CAPTURE_SESSION_PARAMS_VER;
     create_capture_params.eCaptureType = NVFBC_CAPTURE_SHARED_CUDA;
     create_capture_params.bWithCursor = NVFBC_TRUE;
     create_capture_params.eTrackingType = NVFBC_TRACKING_SCREEN;
-    create_capture_params.dwSamplingRateMs = 1000u / fps;
+    create_capture_params.dwSamplingRateMs = frame_time.value_in_milliseconds();
     create_capture_params.bAllowDirectCapture = NVFBC_FALSE;
     create_capture_params.bPushModel = NVFBC_FALSE;
 
@@ -162,7 +163,7 @@ auto create_nvfbc_capture_session(NVFBC_SESSION_HANDLE nvfbc_handle,
 
     NVFBC_TOCUDA_SETUP_PARAMS setup_params {};
     setup_params.dwVersion = NVFBC_TOCUDA_SETUP_PARAMS_VER;
-    setup_params.eBufferFormat = NVFBC_BUFFER_FORMAT_YUV444P;
+    setup_params.eBufferFormat = NVFBC_BUFFER_FORMAT_BGRA;
 
     if (nvfbc.nvFBCToCudaSetUp(nvfbc_handle, &setup_params) != NVFBC_SUCCESS)
         throw sc::NvFBCError { nvfbc, nvfbc_handle };
diff --git a/src/nvidia.hpp b/src/nvidia.hpp
index 82d1d77..ecaef6c 100644
--- a/src/nvidia.hpp
+++ b/src/nvidia.hpp
@@ -64,7 +64,7 @@ auto load_nvfbc() -> NvFBCLib;
 
 auto create_nvfbc_capture_session(NVFBC_SESSION_HANDLE nvfbc_handle,
                                   NvFBC nvfbc,
-                                  std::uint32_t fps) -> void;
+                                  FrameTime const&) -> void;
 auto destroy_nvfbc_capture_session(NVFBC_SESSION_HANDLE nvfbc_handle,
                                    NvFBC nvfbc) -> void;
 } // namespace sc
diff --git a/src/services.hpp b/src/services.hpp
index 97ac9e3..d9a14d3 100644
--- a/src/services.hpp
+++ b/src/services.hpp
@@ -6,6 +6,8 @@
 #include "./services/audio_service.hpp"
 #include "./services/context.hpp"
 #include "./services/drm_video_service.hpp"
+#include "./services/encoder.hpp"
+#include "./services/encoder_service.hpp"
 #ifdef SHADOW_CAST_ENABLE_METRICS
 #include "./services/metrics_service.hpp"
 #endif
diff --git a/src/services/audio_service.cpp b/src/services/audio_service.cpp
index 8801545..6b07e58 100644
--- a/src/services/audio_service.cpp
+++ b/src/services/audio_service.cpp
@@ -246,6 +246,7 @@ AudioService::AudioService(SampleFormat sample_format,
     , sample_rate_ { sample_rate }
     , frame_size_ { frame_size } // clang-format off
     SC_METRICS_MEMBER_USE(metrics_service, metrics_service_)
+    SC_METRICS_MEMBER_USE(0, metrics_start_time_)
 // clang-format on
 {
 #ifdef SHADOW_CAST_ENABLE_METRICS
@@ -265,7 +266,7 @@ auto AudioService::chunk_pool() noexcept -> SynchronizedPool<MediaChunk>&
 
 auto AudioService::on_init(ReadinessRegister reg) -> void
 {
-    reg(FrameTimeRatio(1, 2), &dispatch_chunks);
+    reg(FrameTimeRatio(1), &dispatch_chunks);
 
     loop_data_ = {};
     loop_data_.service = this;
diff --git a/src/services/context.cpp b/src/services/context.cpp
index c67c382..cb64838 100644
--- a/src/services/context.cpp
+++ b/src/services/context.cpp
@@ -1,13 +1,16 @@
 #include "services/context.hpp"
 #include "services/readiness.hpp"
 #include "utils/elapsed.hpp"
+#include "utils/scope_guard.hpp"
 #include <algorithm>
 #include <cassert>
+#include <cerrno>
 #include <cstddef>
 #include <errno.h>
 #include <limits>
 #include <poll.h>
 #include <signal.h>
+#include <sys/eventfd.h>
 #include <system_error>
 #include <tuple>
 #include <vector>
@@ -67,21 +70,34 @@ auto tick_timers(sc::ReadinessRegister::FrameTickRegisterType& timers,
 
 namespace sc
 {
+Context::Context(FrameTime const& ft) noexcept
+    : frame_time_ { ft.value() }
+{
+}
+
 Context::Context(std::uint32_t fps) noexcept
-    : fps_ { fps }
+    : frame_time_ { from_fps(fps).value() }
 {
 }
 
 auto Context::services() noexcept -> ServiceRegistry& { return reg_; }
 
-auto Context::request_stop() noexcept -> void { stop_requested_ = true; }
+auto Context::request_stop() noexcept -> void
+{
+    stop_requested_ = true;
+    std::uint64_t event { 1 };
+    ::write(event_fd_, &event, sizeof(event));
+}
 
 auto Context::run() -> void
 {
     using Notifications = ReadinessRegister::NotifyRegisterType;
     using Timers = ReadinessRegister::FrameTickRegisterType;
 
-    auto const frame_time_in_ns = kNsPerSec / fps_;
+    if (event_fd_ = ::eventfd(0, EFD_NONBLOCK); event_fd_ < 0)
+        throw std::system_error { errno, std::system_category() };
+
+    SC_SCOPE_GUARD([&] { ::close(event_fd_); });
 
     Notifications notifications;
     Timers timers;
@@ -96,8 +112,8 @@ auto Context::run() -> void
     try {
         for (; initialized_pos != reg_.end(); ++initialized_pos) {
             auto& svc = std::get<1>(*initialized_pos);
-            svc->init(ReadinessRegister {
-                *svc, notifications, timers, frame_time_in_ns });
+            svc->init(
+                ReadinessRegister { *svc, notifications, timers, frame_time_ });
         }
     }
     catch (...) {
@@ -118,7 +134,8 @@ auto Context::run() -> void
     }
 
     std::vector<pollfd> poll_events;
-    poll_events.reserve(notifications.size());
+    poll_events.reserve(notifications.size() + 1);
+    poll_events.push_back({ event_fd_, POLLIN, 0 });
 
     std::transform(begin(notifications),
                    end(notifications),
@@ -127,7 +144,7 @@ auto Context::run() -> void
                        return pollfd { std::get<0>(notification), POLLIN, 0 };
                    });
 
-    Elapsed const elapsed;
+    Elapsed const& elapsed = global_elapsed;
     auto frame_start = elapsed.nanosecond_value();
 
     while (!stop_requested_) {
@@ -135,8 +152,7 @@ auto Context::run() -> void
         auto const frame_time = frame_stop - frame_start;
         frame_start = frame_stop;
 
-        auto const next_timeout =
-            tick_timers(timers, frame_time, frame_time_in_ns);
+        auto const next_timeout = tick_timers(timers, frame_time, frame_time_);
 
         auto sleep_for = from_nanoseconds(next_timeout);
         auto const poll_result =
@@ -150,9 +166,22 @@ auto Context::run() -> void
 
         if (poll_result > 0) {
             for (auto const& ev : poll_events) {
+
                 if (!(ev.revents & POLLIN))
                     continue;
 
+                if (ev.fd == event_fd_) {
+                    std::uint64_t discard;
+                    if (auto const result =
+                            ::read(event_fd_, &discard, sizeof(discard));
+                        result < 0)
+                        if (errno != EAGAIN)
+                            throw std::system_error { errno,
+                                                      std::system_category() };
+
+                    continue;
+                }
+
                 auto notify = notifications.find(ev.fd);
                 if (notify != notifications.end()) {
                     std::get<1>(*notify).dispatch(*std::get<1>(*notify).svc);
diff --git a/src/services/context.hpp b/src/services/context.hpp
index 5002372..d639b3c 100644
--- a/src/services/context.hpp
+++ b/src/services/context.hpp
@@ -2,6 +2,7 @@
 #define SHADOW_CAST_SERVICES_CONTEXT_HPP_INCLUDED
 
 #include "services/service_registry.hpp"
+#include "utils/frame_time.hpp"
 #include <atomic>
 
 namespace sc
@@ -9,6 +10,7 @@ namespace sc
 
 struct Context
 {
+    explicit Context(FrameTime const&) noexcept;
     explicit Context(std::uint32_t = 60) noexcept;
     Context(Context const&) = delete;
     auto operator=(Context const&) -> Context& = delete;
@@ -18,9 +20,10 @@ struct Context
     auto request_stop() noexcept -> void;
 
 private:
+    std::uint64_t frame_time_;
     std::atomic<bool> stop_requested_ { false };
     ServiceRegistry reg_;
-    std::uint32_t fps_;
+    int event_fd_ { -1 };
 };
 
 } // namespace sc
diff --git a/src/services/drm_video_service.cpp b/src/services/drm_video_service.cpp
index f3ba93d..b39fe5e 100644
--- a/src/services/drm_video_service.cpp
+++ b/src/services/drm_video_service.cpp
@@ -115,6 +115,7 @@ DRMVideoService::DRMVideoService(
     , wayland_ { &wayland }
     , platform_egl_ { &plaform_egl } // clang-format off
     SC_METRICS_MEMBER_USE(metrics_service, metrics_service_)
+    SC_METRICS_MEMBER_USE(0, metrics_start_time_)
 // clang-format on
 {
 #ifdef SHADOW_CAST_ENABLE_METRICS
@@ -161,6 +162,7 @@ auto DRMVideoService::on_init(ReadinessRegister reg) -> void
     egl_->eglSwapInterval(platform_egl_->egl_display.get(), 0);
 
     reg(FrameTimeRatio(1), &dispatch_frame);
+    frame_time_ = reg.frame_time();
 
 #ifdef SHADOW_CAST_ENABLE_METRICS
     metrics_start_time_ = global_elapsed.nanosecond_value();
@@ -266,7 +268,7 @@ auto DRMVideoService::dispatch_frame(Service& svc) -> void
         }
     });
 
-    (*self.frame_handler_)(self.cuda_array_, self.nvcuda_);
+    (*self.frame_handler_)(self.cuda_array_, self.nvcuda_, self.frame_time_);
 
 #ifdef SHADOW_CAST_ENABLE_METRICS
     self.metrics_service_->post_time_metric(
diff --git a/src/services/drm_video_service.hpp b/src/services/drm_video_service.hpp
index bca589f..d9222d5 100644
--- a/src/services/drm_video_service.hpp
+++ b/src/services/drm_video_service.hpp
@@ -18,6 +18,7 @@
 #include "services/service.hpp"
 #include "utils/borrowed_ptr.hpp"
 #include "utils/receiver.hpp"
+#include <cstdint>
 #include <optional>
 #include <signal.h>
 
@@ -26,7 +27,8 @@ namespace sc
 
 struct DRMVideoService final : Service
 {
-    using CaptureFrameReceiverType = Receiver<void(CUarray, NvCuda const&)>;
+    using CaptureFrameReceiverType =
+        Receiver<void(CUarray, NvCuda const&, std::uint64_t)>;
 
     explicit DRMVideoService(NvCuda nvcuda,
                              CUcontext cuda_ctx,
@@ -63,6 +65,7 @@ struct DRMVideoService final : Service
     SC_METRICS_MEMBER_DECLARE(MetricsService*, metrics_service_);
     SC_METRICS_MEMBER_DECLARE(Elapsed, frame_timer_);
     SC_METRICS_MEMBER_DECLARE(std::size_t, metrics_start_time_);
+    std::uint64_t frame_time_ { 0 };
 };
 
 } // namespace sc
diff --git a/src/services/encoder.cpp b/src/services/encoder.cpp
new file mode 100644
index 0000000..ac5c834
--- /dev/null
+++ b/src/services/encoder.cpp
@@ -0,0 +1,37 @@
+#include "services/encoder.hpp"
+#include "utils/contracts.hpp"
+#include "utils/pool.hpp"
+#include <libavcodec/avcodec.h>
+#include <libavformat/avformat.h>
+
+namespace sc
+{
+Encoder::Encoder(Context& ctx) noexcept
+    : svc_ { ctx.services().use_if<EncoderService>() }
+{
+    SC_EXPECT(svc_);
+}
+
+auto Encoder::write_frame(Frame&& item) -> void
+{
+    svc_->write_frame(std::move(item));
+}
+
+auto Encoder::flush(BorrowedPtr<AVCodecContext> codec_ctx,
+                    BorrowedPtr<AVStream> stream) -> void
+{
+    auto encoder_frame = prepare_frame(codec_ctx, stream);
+    encoder_frame->frame.reset();
+    svc_->write_frame(std::move(encoder_frame));
+}
+
+auto Encoder::prepare_frame(BorrowedPtr<AVCodecContext> codec_ctx,
+                            BorrowedPtr<AVStream> stream) -> Frame
+{
+    auto pool_item = svc_->pool().get();
+    pool_item->codec_ctx = codec_ctx.get();
+    pool_item->stream = stream.get();
+    return pool_item;
+}
+
+} // namespace sc
diff --git a/src/services/encoder.hpp b/src/services/encoder.hpp
new file mode 100644
index 0000000..a069bd7
--- /dev/null
+++ b/src/services/encoder.hpp
@@ -0,0 +1,27 @@
+#ifndef SHADOW_CAST_SERVICES_MEDIA_WRITER_HPP_INCLUDED
+#define SHADOW_CAST_SERVICES_MEDIA_WRITER_HPP_INCLUDED
+
+#include "services/context.hpp"
+#include "services/encoder_service.hpp"
+#include "utils/borrowed_ptr.hpp"
+#include "utils/pool.hpp"
+
+namespace sc
+{
+struct Encoder
+{
+    using Frame = typename EncoderService::PoolType::ItemPtr;
+    explicit Encoder(Context&) noexcept;
+
+    auto write_frame(Frame&&) -> void;
+    auto flush(BorrowedPtr<AVCodecContext>, BorrowedPtr<AVStream>) -> void;
+
+    auto prepare_frame(BorrowedPtr<AVCodecContext>, BorrowedPtr<AVStream>)
+        -> Frame;
+
+private:
+    sc::BorrowedPtr<EncoderService> svc_;
+};
+} // namespace sc
+
+#endif // SHADOW_CAST_SERVICES_MEDIA_WRITER_HPP_INCLUDED
diff --git a/src/services/encoder_service.cpp b/src/services/encoder_service.cpp
new file mode 100644
index 0000000..fceed3e
--- /dev/null
+++ b/src/services/encoder_service.cpp
@@ -0,0 +1,151 @@
+#include "services/encoder_service.hpp"
+#include "config.hpp"
+#include "error.hpp"
+#include "utils/pool.hpp"
+#include <cstring>
+#include <errno.h>
+#include <libavcodec/avcodec.h>
+#include <stdexcept>
+#include <sys/eventfd.h>
+#include <unistd.h>
+
+using namespace std::literals::string_literals;
+
+namespace
+{
+std::size_t constexpr kInitialPoolSize = 16;
+}
+
+namespace sc
+{
+EncoderService::EncoderService(
+    BorrowedPtr<AVFormatContext> fmt_context
+        SC_METRICS_PARAM_DEFINE(MetricsService*, metrics_service)) noexcept
+    : format_context_ { fmt_context } SC_METRICS_MEMBER_USE(metrics_service,
+                                                            metrics_service_)
+    , packet_ { av_packet_alloc() }
+{
+}
+
+auto EncoderService::write_frame(PoolType::ItemPtr item) -> void
+{
+    {
+        std::lock_guard lock { data_mutex_ };
+        static_cast<void>(
+            avcodec_send_frame(item->codec_ctx, item->frame.get()));
+        pending_.push_back(item.release());
+    }
+
+    std::uint64_t const event_num { 1 };
+    static_cast<void>(::write(notify_fd_, &event_num, sizeof(event_num)));
+}
+
+auto EncoderService::on_init(ReadinessRegister reg) -> void
+{
+    if (notify_fd_ = ::eventfd(0, EFD_NONBLOCK); notify_fd_ < 0)
+        throw new std::runtime_error {
+            "EncoderService initialization failed: "s + std::strerror(errno)
+        };
+
+    pool_.fill(kInitialPoolSize);
+    reg(notify_fd_, &dispatch);
+#ifdef SHADOW_CAST_ENABLE_METRICS
+    metrics_start_time_ = global_elapsed.nanosecond_value();
+#endif
+}
+
+auto EncoderService::on_uninit() noexcept -> void
+{
+    static_cast<void>(::close(notify_fd_));
+    try {
+        dispatch(*this);
+        pool_.clear();
+    }
+    catch (...) {
+    }
+}
+
+auto EncoderService::dispatch(Service& svc) -> void
+{
+    auto& self = static_cast<EncoderService&>(svc);
+    std::uint64_t event_num;
+    static_cast<void>(::read(self.notify_fd_, &event_num, sizeof(event_num)));
+
+    IntrusiveList<StreamPoll> tmp;
+    {
+        std::lock_guard lock { self.data_mutex_ };
+        tmp.splice(tmp.begin(),
+                   self.pending_,
+                   self.pending_.begin(),
+                   self.pending_.end());
+    }
+
+    ReturnToPoolGuard return_to_pool_guard { tmp, self.pool_ };
+
+    for (auto const& stream_poll : tmp) {
+        auto* stream = stream_poll.stream;
+        auto* ctx = stream_poll.codec_ctx;
+        int response = 0;
+        while (response >= 0) {
+#ifdef SHADOW_CAST_ENABLE_METRICS
+            self.frame_timer_.reset();
+            auto const frame_timestamp =
+                global_elapsed.nanosecond_value() - self.metrics_start_time_;
+#endif
+            {
+                std::lock_guard lock { self.data_mutex_ };
+                response = avcodec_receive_packet(ctx, self.packet_.get());
+            }
+            if (response == AVERROR(EAGAIN) || response == AVERROR_EOF) {
+                break;
+            }
+
+            if (response < 0) {
+                throw std::runtime_error { "receive packet error" };
+            }
+
+            av_packet_rescale_ts(
+                self.packet_.get(), ctx->time_base, stream->time_base);
+            self.packet_->stream_index = stream->index;
+
+            response = av_interleaved_write_frame(self.format_context_.get(),
+                                                  self.packet_.get());
+            if (response < 0) {
+                throw std::runtime_error { "write packet error: " +
+                                           av_error_to_string(response) };
+            }
+#ifdef SHADOW_CAST_ENABLE_METRICS
+            self.metrics_service_->post_time_metric(
+                { .category = static_cast<std::uint32_t>(4 - stream->index),
+                  .id = 0,
+                  .timestamp_ns = frame_timestamp,
+                  .nanoseconds = self.frame_timer_.nanosecond_value(),
+                  .frame_size = 1,
+                  .frame_count = 1 });
+#endif
+        }
+    }
+}
+
+auto EncoderService::pool() noexcept -> PoolType& { return pool_; }
+
+StreamPoll::StreamPoll()
+    : codec_ctx { nullptr }
+    , stream { nullptr }
+    , frame { av_frame_alloc() }
+{
+}
+
+auto StreamPoll::reset() noexcept -> void
+{
+    codec_ctx = nullptr;
+    stream = nullptr;
+    if (!frame) {
+        frame = FramePtr { av_frame_alloc() };
+    }
+    else {
+        av_frame_unref(frame.get());
+    }
+}
+
+} // namespace sc
diff --git a/src/services/encoder_service.hpp b/src/services/encoder_service.hpp
new file mode 100644
index 0000000..c8cc8eb
--- /dev/null
+++ b/src/services/encoder_service.hpp
@@ -0,0 +1,83 @@
+#ifndef SHADOW_CAST_SERVICES_MEDIA_WRITER_SERVICE_HPP_INCLUDED
+#define SHADOW_CAST_SERVICES_MEDIA_WRITER_SERVICE_HPP_INCLUDED
+
+#include "config.hpp"
+
+#ifdef SHADOW_CAST_ENABLE_METRICS
+#include "services/metrics_service.hpp"
+#include "utils/elapsed.hpp"
+#endif
+
+#include "av/frame.hpp"
+#include "av/packet.hpp"
+#include "services/readiness.hpp"
+#include "services/service.hpp"
+#include "utils/borrowed_ptr.hpp"
+#include "utils/intrusive_list.hpp"
+#include "utils/pool.hpp"
+extern "C" {
+#include <libavcodec/avcodec.h>
+#include <libavformat/avformat.h>
+}
+#include <mutex>
+
+namespace sc
+{
+
+struct StreamPoll : ListItemBase
+{
+    StreamPoll();
+
+    AVCodecContext* codec_ctx;
+    AVStream* stream;
+    FramePtr frame;
+
+    auto reset() noexcept -> void;
+};
+
+struct EncoderService final : Service
+{
+private:
+    struct EncoderPoolLifetime
+    {
+        auto construct(StreamPoll* item) -> void
+        {
+            new (static_cast<void*>(item)) StreamPoll {};
+            item->frame = FramePtr { av_frame_alloc() };
+        }
+
+        auto destruct(StreamPoll* item) -> void { item->~StreamPoll(); }
+    };
+
+public:
+    using PoolType = SynchronizedPool<StreamPoll, EncoderPoolLifetime>;
+    EncoderService(BorrowedPtr<AVFormatContext> SC_METRICS_PARAM_DECLARE(
+        MetricsService*)) noexcept;
+
+    EncoderService(EncoderService const&) = delete;
+    auto operator=(EncoderService const&) -> EncoderService& = delete;
+
+    auto write_frame(PoolType::ItemPtr) -> void;
+
+    auto pool() noexcept -> PoolType&;
+
+protected:
+    auto on_init(ReadinessRegister) -> void override;
+    auto on_uninit() noexcept -> void override;
+
+private:
+    static auto dispatch(Service&) -> void;
+
+    BorrowedPtr<AVFormatContext> format_context_;
+    SC_METRICS_MEMBER_DECLARE(MetricsService*, metrics_service_);
+    int notify_fd_ { -1 };
+    std::mutex data_mutex_;
+    PacketPtr packet_;
+    PoolType pool_;
+    IntrusiveList<StreamPoll> pending_;
+    SC_METRICS_MEMBER_DECLARE(Elapsed, frame_timer_);
+    SC_METRICS_MEMBER_DECLARE(std::size_t, metrics_start_time_);
+};
+} // namespace sc
+
+#endif // SHADOW_CAST_SERVICES_MEDIA_WRITER_SERVICE_HPP_INCLUDED
diff --git a/src/services/video_service.cpp b/src/services/video_service.cpp
index 95c931d..1fccbce 100644
--- a/src/services/video_service.cpp
+++ b/src/services/video_service.cpp
@@ -1,10 +1,16 @@
 #include "services/video_service.hpp"
+#include "nvidia/NvFBC.h"
 #include "utils/contracts.hpp"
 
 #ifdef SHADOW_CAST_ENABLE_METRICS
 #include "utils/elapsed.hpp"
 #endif
 
+namespace
+{
+constexpr std::size_t kNsPerMs = 1'000'000;
+}
+
 namespace sc
 {
 
@@ -17,6 +23,7 @@ VideoService::VideoService(
     , nvcuda_ctx_ { nvcuda_ctx }
     , nvfbc_session_ { nvfbc_session } // clang-format off
     SC_METRICS_MEMBER_USE(metrics_service, metrics_service_)
+    SC_METRICS_MEMBER_USE(0, metrics_start_time_)
 // clang-format on
 {
 #ifdef SHADOW_CAST_ENABLE_METRICS
@@ -26,6 +33,7 @@ VideoService::VideoService(
 
 auto VideoService::on_init(ReadinessRegister reg) -> void
 {
+    frame_time_ = reg.frame_time();
     reg(FrameTimeRatio(1), &dispatch_frame);
 
 #ifdef SHADOW_CAST_ENABLE_METRICS
@@ -50,10 +58,10 @@ auto dispatch_frame(Service& svc) -> void
 
     NVFBC_TOCUDA_GRAB_FRAME_PARAMS grab_params {};
     grab_params.dwVersion = NVFBC_TOCUDA_GRAB_FRAME_PARAMS_VER;
-    grab_params.dwFlags = NVFBC_TOCUDA_GRAB_FLAGS_NOWAIT;
+    grab_params.dwFlags = NVFBC_TOCUDA_GRAB_FLAGS_NOWAIT_IF_NEW_FRAME_READY;
     grab_params.pFrameGrabInfo = &frame_info;
     grab_params.pCUDADeviceBuffer = &cu_device_ptr;
-    grab_params.dwTimeoutMs = 0;
+    grab_params.dwTimeoutMs = self.frame_time_ / kNsPerMs;
 
     if (auto const status =
             self.nvfbc_.nvFBCToCudaGrabFrame(self.nvfbc_session_, &grab_params);
@@ -61,7 +69,7 @@ auto dispatch_frame(Service& svc) -> void
         throw NvFBCError { self.nvfbc_, self.nvfbc_session_ };
 
     if (self.receiver_)
-        (*self.receiver_)(cu_device_ptr, frame_info);
+        (*self.receiver_)(cu_device_ptr, frame_info, self.frame_time_);
 
 #ifdef SHADOW_CAST_ENABLE_METRICS
     self.metrics_service_->post_time_metric(
diff --git a/src/services/video_service.hpp b/src/services/video_service.hpp
index 5385b0a..6310766 100644
--- a/src/services/video_service.hpp
+++ b/src/services/video_service.hpp
@@ -21,7 +21,7 @@ struct VideoService final : Service
     friend auto dispatch_frame(Service&) -> void;
 
     using CaptureFrameReceiverType =
-        Receiver<void(CUdeviceptr, NVFBC_FRAME_GRAB_INFO)>;
+        Receiver<void(CUdeviceptr, NVFBC_FRAME_GRAB_INFO, std::uint64_t)>;
 
     VideoService(NvFBC,
                  BorrowedPtr<std::remove_pointer_t<CUcontext>>,
@@ -46,6 +46,7 @@ struct VideoService final : Service
     SC_METRICS_MEMBER_DECLARE(MetricsService*, metrics_service_);
     SC_METRICS_MEMBER_DECLARE(Elapsed, frame_timer_);
     SC_METRICS_MEMBER_DECLARE(std::size_t, metrics_start_time_);
+    std::uint64_t frame_time_ { 0 };
 };
 
 auto dispatch_frame(Service&) -> void;
diff --git a/src/utils.hpp b/src/utils.hpp
index d2810a8..95724e9 100644
--- a/src/utils.hpp
+++ b/src/utils.hpp
@@ -6,6 +6,7 @@
 #include "./utils/cmd_line.hpp"
 #include "./utils/contracts.hpp"
 #include "./utils/elapsed.hpp"
+#include "./utils/frame_time.hpp"
 #include "./utils/intrusive_list.hpp"
 #include "./utils/non_pointer.hpp"
 #include "./utils/pool.hpp"
diff --git a/src/utils/cmd_line.cpp b/src/utils/cmd_line.cpp
index 7b1b81c..6e14fe9 100644
--- a/src/utils/cmd_line.cpp
+++ b/src/utils/cmd_line.cpp
@@ -3,6 +3,7 @@
 #include <array>
 #include <cassert>
 #include <charconv>
+#include <cstdlib>
 #include <cstring>
 #include <initializer_list>
 #include <iostream>
@@ -15,6 +16,8 @@ using namespace std::literals::string_literals;
 namespace
 {
 
+constexpr char const kStrictFrameTimeEnvVar[] = "SHADOW_CAST_STRICT_FPS";
+
 template <typename Container, typename... T>
 constexpr auto construct(T... vals) noexcept -> Container
 requires(sizeof...(T) <= std::tuple_size<Container>::value) &&
@@ -39,9 +42,9 @@ sc::CmdLineOptionSpec const cmd_line_spec[] = {
       .long_name = "--framerate",
       .option = sc::CmdLineOption::frame_rate,
       .flags = sc::cmdline::VALUE_REQUIRED | sc::cmdline::VALUE_NUMERIC,
-      .validation = sc::ValidRange { 20, 60 },
+      .validation = sc::ValidRange { 20, 70 },
       .description =
-          "Video frame rate in frames-per-second. Must be between 20 - 60. "
+          "Video frame rate in frames-per-second. Must be between 20 - 70. "
           "Default 60" },
 
     /* Show help...
@@ -330,6 +333,14 @@ auto parse_cmd_line(int argc, char const** argv) -> CmdLine
     return cmdline;
 }
 
+auto read_env(Parameters& params) -> void
+{
+    if (auto const* strict_frame_time = std::getenv(kStrictFrameTimeEnvVar);
+        strict_frame_time) {
+        params.strict_frame_time = std::strcmp(strict_frame_time, "1") == 0;
+    }
+}
+
 auto get_parameters(CmdLine const& cmdline) noexcept
     -> Result<Parameters, CmdLineError>
 {
@@ -344,8 +355,8 @@ auto get_parameters(CmdLine const& cmdline) noexcept
             sc::CmdLineOption::video_encoder, "hevc_nvenc") },
         .audio_encoder = std::string { cmdline.get_option_value_or_default(
             sc::CmdLineOption::audio_encoder, "libopus") },
-        .frame_rate = cmdline.get_option_value_or_default(
-            sc::CmdLineOption::frame_rate, 60, sc::number_value),
+        .frame_time = from_fps(cmdline.get_option_value_or_default(
+            sc::CmdLineOption::frame_rate, 60, sc::number_value)),
         .sample_rate = cmdline.get_option_value_or_default(
             sc::CmdLineOption::sample_rate, 48'000, sc::number_value),
         .output_file = cmdline.args().size() ? cmdline.args()[0] : ""
@@ -355,6 +366,7 @@ auto get_parameters(CmdLine const& cmdline) noexcept
         return CmdLineError { CmdLineError::error,
                               "Missing parameter: output file" };
 
+    read_env(params);
     return params;
 }
 
diff --git a/src/utils/cmd_line.hpp b/src/utils/cmd_line.hpp
index dece0ef..ca49a13 100644
--- a/src/utils/cmd_line.hpp
+++ b/src/utils/cmd_line.hpp
@@ -2,6 +2,7 @@
 #define SHADOW_CAST_UTILS_CMD_LINE_HPP_INCLUDED
 
 #include "error.hpp"
+#include "utils/frame_time.hpp"
 #include "utils/result.hpp"
 #include <algorithm>
 #include <array>
@@ -43,9 +44,10 @@ struct Parameters
 {
     std::string video_encoder;
     std::string audio_encoder;
-    std::int32_t frame_rate;
+    FrameTime frame_time;
     std::int32_t sample_rate;
     std::string output_file;
+    bool strict_frame_time { true };
 };
 
 struct NoValidation
diff --git a/src/utils/frame_time.cpp b/src/utils/frame_time.cpp
new file mode 100644
index 0000000..27b1a40
--- /dev/null
+++ b/src/utils/frame_time.cpp
@@ -0,0 +1,49 @@
+#include "utils/frame_time.hpp"
+#include <libavutil/rational.h>
+
+namespace
+{
+std::uint64_t constexpr kNsPerSec = 1'000'000'000;
+std::uint64_t constexpr kNsPerMs = 1'000'000;
+auto constexpr kRound = kNsPerMs / 2;
+
+} // namespace
+namespace sc
+{
+
+FrameTime::FrameTime(std::uint64_t frame_time_nanoseconds) noexcept
+    : frame_time_nanoseconds_ { frame_time_nanoseconds }
+{
+}
+
+auto FrameTime::value() const noexcept -> std::uint64_t
+{
+    return frame_time_nanoseconds_;
+}
+
+auto FrameTime::value_in_milliseconds() const noexcept -> std::uint64_t
+{
+    return (frame_time_nanoseconds_ + kRound) / kNsPerMs;
+}
+
+auto FrameTime::fps() const noexcept -> float
+{
+    return static_cast<float>(kNsPerSec) / frame_time_nanoseconds_;
+}
+
+auto FrameTime::per_second_ratio() const noexcept -> AVRational
+{
+    return AVRational { .num = 1, .den = kNsPerSec };
+}
+
+auto truncate_to_millisecond(FrameTime const& ft) noexcept -> FrameTime
+{
+    auto const in_ms = ft.value() / kNsPerMs;
+    return FrameTime { in_ms * kNsPerMs };
+}
+auto from_fps(std::uint32_t fps) noexcept -> FrameTime
+{
+    return FrameTime { kNsPerSec / fps };
+}
+
+} // namespace sc
diff --git a/src/utils/frame_time.hpp b/src/utils/frame_time.hpp
new file mode 100644
index 0000000..109bbc7
--- /dev/null
+++ b/src/utils/frame_time.hpp
@@ -0,0 +1,26 @@
+#ifndef SHADOW_CAST_UTILS_FRAME_TIME_HPP_INCLUDED
+#define SHADOW_CAST_UTILS_FRAME_TIME_HPP_INCLUDED
+
+#include <cstdint>
+#include <libavutil/rational.h>
+
+namespace sc
+{
+struct FrameTime
+{
+    explicit FrameTime(std::uint64_t) noexcept;
+    auto value() const noexcept -> std::uint64_t;
+    auto value_in_milliseconds() const noexcept -> std::uint64_t;
+    auto fps() const noexcept -> float;
+    auto per_second_ratio() const noexcept -> AVRational;
+
+private:
+    std::uint64_t frame_time_nanoseconds_;
+};
+
+auto truncate_to_millisecond(FrameTime const&) noexcept -> FrameTime;
+auto from_fps(std::uint32_t) noexcept -> FrameTime;
+
+} // namespace sc
+
+#endif // SHADOW_CAST_UTILS_FRAME_TIME_HPP_INCLUDED
diff --git a/src/utils/pool.hpp b/src/utils/pool.hpp
index 79ae4c1..989b81c 100644
--- a/src/utils/pool.hpp
+++ b/src/utils/pool.hpp
@@ -30,6 +30,14 @@ struct MutexPoolSynchronization
     std::mutex mutex_;
 };
 
+template <typename T>
+struct DefaultObjectLifetime
+{
+    auto construct(T* ptr) -> void { new (static_cast<void*>(ptr)) T {}; }
+
+    auto destruct(T* ptr) -> void { ptr->~T(); }
+};
+
 template <typename T>
 struct SynchronizationGuard
 {
@@ -51,13 +59,15 @@ struct SynchronizationGuard
 };
 
 template <ListItem T,
+          typename ObjectLifetime = DefaultObjectLifetime<T>,
           typename Allocator = std::allocator<T>,
           typename Synchronization = DefaultPoolSynchronization>
 struct Pool
 {
     struct PoolItemDeleter
     {
-        PoolItemDeleter(Pool<T, Allocator, Synchronization>& pool) noexcept
+        PoolItemDeleter(
+            Pool<T, ObjectLifetime, Allocator, Synchronization>& pool) noexcept
             : pool_ { &pool }
         {
         }
@@ -65,13 +75,15 @@ struct Pool
         auto operator()(T* ptr) const noexcept -> void { pool_->put(ptr); }
 
     private:
-        Pool<T, Allocator, Synchronization>* pool_;
+        Pool<T, ObjectLifetime, Allocator, Synchronization>* pool_;
     };
 
     using ItemPtr = std::unique_ptr<T, PoolItemDeleter>;
 
-    explicit Pool(Allocator alloc = Allocator {}) noexcept
-        : alloc_ { alloc }
+    explicit Pool(ObjectLifetime lifetime = ObjectLifetime {},
+                  Allocator alloc = Allocator {}) noexcept
+        : lifetime_ { lifetime }
+        , alloc_ { alloc }
     {
     }
 
@@ -105,7 +117,7 @@ struct Pool
 
         T* new_item = allocate_item();
         try {
-            new (static_cast<void*>(new_item)) T {};
+            lifetime_.construct(new_item);
         }
         catch (...) {
             deallocate_item(new_item);
@@ -125,6 +137,24 @@ struct Pool
         pool_list_.push_back(item);
     }
 
+    /* Pre-populates the pool with `n` items
+     */
+    auto fill(std::size_t n) -> void
+    {
+        while (n--) {
+            T* new_item = allocate_item();
+            try {
+                lifetime_.construct(new_item);
+            }
+            catch (...) {
+                deallocate_item(new_item);
+                throw;
+            }
+
+            put(new_item);
+        }
+    }
+
     /* Removes and deallocates all remaining
      * items in the pool. There should have been a
      * equal number of put() and get() calls
@@ -138,7 +168,7 @@ struct Pool
             T* item = &*it;
             it = pool_list_.erase(it);
 
-            item->~T();
+            lifetime_.destruct(item);
             deallocate_item(item);
         }
     }
@@ -160,13 +190,17 @@ struct Pool
         alloc.deallocate(item, 1);
     }
 
+    ObjectLifetime lifetime_;
     Allocator alloc_;
     IntrusiveList<T> pool_list_;
     Synchronization sync_;
 };
 
-template <ListItem T, typename Allocator = std::allocator<T>>
-using SynchronizedPool = Pool<T, Allocator, MutexPoolSynchronization>;
+template <ListItem T,
+          typename ObjectLifetime = DefaultObjectLifetime<T>,
+          typename Allocator = std::allocator<T>>
+using SynchronizedPool =
+    Pool<T, ObjectLifetime, Allocator, MutexPoolSynchronization>;
 
 template <typename List, typename Pool>
 struct ReturnToPoolGuard
diff --git a/tools/make-dist b/tools/make-dist
index f9dc25a..b5a26b8 100755
--- a/tools/make-dist
+++ b/tools/make-dist
@@ -14,6 +14,7 @@ mkdir ./dist
 tar \
     --exclude './build' \
     --exclude './dist' \
+    --exclude './report' \
     --exclude './.private' \
     --exclude './.git' \
     --exclude './.github' \
diff --git a/tools/metrics/average b/tools/metrics/average
index 8069b40..3f15710 100755
--- a/tools/metrics/average
+++ b/tools/metrics/average
@@ -5,19 +5,27 @@ usage() {
 Usage ${0} [ OPTION... ] <INPUT FILE>
 OPTIONS
   -a    Audio
+  -A    Audio encoder
   -v    Video (default)
+  -V    Video encoder
 EOF
 }
 
 category=1
-while getopts 'av' opt; do
+while getopts 'aAvV' opt; do
     case "${opt}" in
         a)
             category=2
             ;;
+        A)
+            category=4
+            ;;
         v)
             category=1
             ;;
+        V)
+            category=3
+            ;;
         ?)
             usage
             ;;
diff --git a/tools/metrics/percentile b/tools/metrics/percentile
index 3db9c8f..49a7def 100755
--- a/tools/metrics/percentile
+++ b/tools/metrics/percentile
@@ -5,12 +5,14 @@ usage() {
 Usage ${0} [ OPTION... ] <INPUT FILE> <PERCENTILE>
 OPTIONS
   -a    Audio
+  -A    Audio Encoding
   -v    Video (default)
+  -V    Video Encoding
 EOF
 }
 
 category=1
-while getopts 'av' opt; do
+while getopts 'aAvV' opt; do
     case "${opt}" in
         a)
             category=2
@@ -18,6 +20,12 @@ while getopts 'av' opt; do
         v)
             category=1
             ;;
+        A)
+            category=4
+            ;;
+        V)
+            category=3
+            ;;
         ?)
             usage
             ;;
@@ -32,7 +40,7 @@ if [[ $# -lt 2 ]]; then
     exit 1
 fi
 
-set -x
+#set -x
 
 <"${1}" grep -E '^'${category}'' \
     | sort -k4 -t, -g \
diff --git a/tools/metrics/plot b/tools/metrics/plot
index 3aa33a0..8f5d443 100755
--- a/tools/metrics/plot
+++ b/tools/metrics/plot
@@ -2,12 +2,18 @@
 
 exclude_audio=0
 exclude_video=0
+video_category=1
+audio_category=2
 
-while getopts 'sVA' opt; do
+while getopts 'sVAe' opt; do
     case "${opt}" in
         A)
             exclude_audio=1
             ;;
+        e)
+            video_category=3
+            audio_category=4
+            ;;
         s)
             smoothval='smooth csplines'
             ;;
@@ -32,6 +38,7 @@ if [[ ${exclude_audio} -ne 0 ]] && [[ ${exclude_audio} == ${exclude_video} ]]; t
 fi
 
 inputfile="${1}"
+yrange="4"
 
 set -x
 #
@@ -46,14 +53,14 @@ set xdata time
 set xlabel "Time (seconds)"
 set ylabel "Frame Time (milliseconds)"
 set xtics 30
-set yrange [0:16]
+set yrange [0:${yrange}]
 
-$([[ ${exclude_audio} -eq 1 ]] && echo "plot '< grep -E \"^1\" "${inputfile}" | cut -d, -f3,4' \
+$([[ ${exclude_audio} -eq 1 ]] && echo "plot '< grep -E \"^${video_category}\" "${inputfile}" | cut -d, -f3,4' \
  using (\$1/1000000000):(\$2/1000000) ${smoothval} with lines title \"Video\"")
-$([[ ${exclude_video} -eq 1 ]] && echo "plot '< grep -E \"^2\" "${inputfile}" | cut -d, -f3,4' \
+$([[ ${exclude_video} -eq 1 ]] && echo "plot '< grep -E \"^${audio_category}\" "${inputfile}" | cut -d, -f3,4' \
  using (\$1/1000000000):(\$2/1000000) ${smoothval} with lines title \"Audio\"")
-$([[ ${exclude_audio} -eq ${exclude_video} ]] && echo "plot '< grep -E \"^1\" "${inputfile}" | cut -d, -f3,4' \
+$([[ ${exclude_audio} -eq ${exclude_video} ]] && echo "plot '< grep -E \"^${video_category}\" "${inputfile}" | cut -d, -f3,4' \
  using (\$1/1000000000):(\$2/1000000) ${smoothval} with lines title \"Video\", \
- '< grep -E \"^2\" "${inputfile}" | cut -d, -f3,4' \
+ '< grep -E \"^${audio_category}\" "${inputfile}" | cut -d, -f3,4' \
  using (\$1/1000000000):(\$2/1000000) ${smoothval} with lines title \"Audio\"")
 EOF
diff --git a/tools/next-version b/tools/next-version
new file mode 100755
index 0000000..5537d65
--- /dev/null
+++ b/tools/next-version
@@ -0,0 +1,25 @@
+#!/usr/bin/env bash
+
+project_dir=$(cd $(dirname ${0})/..; pwd)
+changes_dir="${project_dir}/.versioning/changes"
+current_version=$(cat ${project_dir}/.versioning/current | tr -d '\n')
+
+version_list=(${current_version})
+
+test_multiple() {
+    [[ $(ls -1 "${changes_dir}" 2>/dev/null | grep "${1}" | wc -l) -gt 0 ]]
+}
+
+if test_multiple "patch" ; then
+    version_list+=($(echo "${current_version}" | semverutil -P))
+fi
+
+if test_multiple "minor" ; then
+    version_list+=($(echo "${current_version}" | semverutil -N))
+fi
+
+if test_multiple "major" ; then
+    version_list+=($(echo "${current_version}" | semverutil -M))
+fi
+
+echo ${version_list[@]} | semverutil
diff --git a/tools/performance-report b/tools/performance-report
new file mode 100755
index 0000000..3f4061a
--- /dev/null
+++ b/tools/performance-report
@@ -0,0 +1,97 @@
+#!/usr/bin/env bash
+
+print_usage() {
+    cat >&2 <<-EOF
+USAGE ${0} <CAPTURE_MEDIA_FILE> <PLATFORM>
+EOF
+}
+
+[[ $# -eq 2 ]] || {
+    echo "Incorrect number of arguments" >&2
+    print_usage
+    exit 1
+}
+
+metrics_file="${1}.metrics"
+platform="${2}"
+
+[[ -f "${metrics_file}" ]] || {
+    echo "Couldn't find metrics file: ${metrics_file}" >&2
+    exit 1
+}
+
+this_dir=$(cd $(dirname "${0}"); pwd)
+report_dir="$(cd "${this_dir}/.."; pwd)/report"
+percentile="${this_dir}/metrics/percentile"
+average="${this_dir}/metrics/average"
+plot="${this_dir}/metrics/plot"
+
+[[ -d "${report_dir}" ]] && rm -rf "${report_dir}"
+mkdir -p "${report_dir}/images"
+
+print_percentiles() {
+    echo "| Percentile  | Video     | Audio     | Video encoding | Audio encoding |"
+    echo "|----------   |---------  |--------   |--------------- |--------------- |"
+    for p in "99.99" 99 90 75 50; do
+        local video_val=$(printf "%.3fms" $(${percentile} -v "${metrics_file}" ${p} | awk -F, '{ print $4/1000000; }'))
+        local video_encoding_val=$(printf "%.3fms" $(${percentile} -V "${metrics_file}" ${p} | awk -F, '{ print $4/1000000; }'))
+        local audio_val=$(printf "%.3fms" $(${percentile} -a "${metrics_file}" ${p} | awk -F, '{ print $4/1000000; }'))
+        local audio_encoding_val=$(printf "%.3fms" $(${percentile} -A "${metrics_file}" ${p} | awk -F, '{ print $4/1000000; }'))
+        echo "| ${p}        | \`${video_val}\`  | \`${audio_val}\`  | \`${video_encoding_val}\` | \`${audio_encoding_val}\` |"
+    done
+}
+
+print_averages() {
+    echo "| Stream  | Capture       | Encoding  |"
+    echo "|-------- |-------------  |---------  |"
+
+    local video_val=$(${average} -v "${metrics_file}")
+    local video_encoding_val=$(${average} -V "${metrics_file}")
+    local audio_val=$(${average} -a "${metrics_file}")
+    local audio_encoding_val=$(${average} -A "${metrics_file}")
+
+    echo "| Video   | \`$(printf "%.3fms" $(echo "scale=3; ${video_val}/1000000" | bc))\`  | \
+        \`$(printf "%.3fms" $(echo "scale=3; ${video_encoding_val}/1000000" | bc))\`  |"
+    echo "| Audio   | \`$(printf "%.3fms" $(echo "scale=3; ${audio_val}/1000000" | bc))\`  | \
+        \`$(printf "%.3fms" $(echo "scale=3; ${audio_encoding_val}/1000000" | bc))\`  |"
+}
+
+generate_charts() {
+    ${plot} -A ${metrics_file} 2>/dev/null
+    cp ${metrics_file}.chart.png "${report_dir}/images/${platform}-video-detailed.png"
+    echo "##### Video frame times"
+    echo -e "![Video frame times](images/${platform}-video-detailed.png)\n"
+    ${plot} -e -A ${metrics_file} 2>/dev/null
+    cp ${metrics_file}.chart.png "${report_dir}/images/${platform}-video-encoding-detailed.png"
+    echo "##### Video encoding frame times"
+    echo -e "![Video encoding frame times](images/${platform}-video-encoding-detailed.png)\n"
+    ${plot} -V ${metrics_file} 2>/dev/null
+    cp ${metrics_file}.chart.png "${report_dir}/images/${platform}-audio-detailed.png"
+    echo "##### Audio frame times"
+    echo -e "![Audio frame times](images/${platform}-audio-detailed.png)\n"
+    ${plot} -e -V ${metrics_file} 2>/dev/null
+    cp ${metrics_file}.chart.png "${report_dir}/images/${platform}-audio-encoding-detailed.png"
+    echo "##### Audio encoding frame times"
+    echo -e "![Audio encoding frame times](images/${platform}-audio-encoding-detailed.png)\n"
+    ${plot} -s ${metrics_file} 2>/dev/null
+    cp ${metrics_file}.chart.png "${report_dir}/images/${platform}-video-audio-downsampled.png"
+    echo "##### Video and Audio frame times (downsampled)"
+    echo -e "![Video and Audio frame times downsampled](images/${platform}-video-audio-downsampled.png)\n"
+    ${plot} -e -s ${metrics_file} 2>/dev/null
+    cp ${metrics_file}.chart.png "${report_dir}/images/${platform}-video-audio-encoding-downsampled.png"
+    echo "##### Video and Audio encoding frame times (downsampled)"
+    echo -e "![Video and Audio encoding frame times downsampled](images/${platform}-video-audio-encoding-downsampled.png)\n"
+}
+
+(
+echo -e "### Performance - ${platform}"
+echo -e "Version: \`$(${this_dir}/next-version | tr -d '\n')\`\n"
+echo -e "#### Average frame times\n"
+print_averages
+echo -e "\n#### Frame time percentiles\n"
+print_percentiles
+echo -e "\n#### Frame time charts\n"
+generate_charts
+) | tee "${report_dir}/${platform}-report.md"
+
+markdown "${report_dir}/${platform}-report.md" > "${report_dir}/${platform}-report.html"