omtsndcli_v01.cpp

/* SPDX-License-Identifier: MIT */
/*
 * omtsndcli_v01.cpp
 *
 * Canonical GitHub source snapshot for the current OMT sender CLI state.
 *
 * Licensing note
 * --------------
 * This repository source is intended to be distributed under the MIT License.
 * Project notes indicate the sender lineage began as a derivative of the
 * Open Media Transport C++ example sender, whose upstream Examples repository
 * is also published under MIT. Third-party libraries and headers used by this
 * program retain their own licenses.
 *
 * Source lineage
 * --------------
 * This file is the documented v01 snapshot derived directly from the proven
 * working source `omtcli06_fix.cpp` and prepared as the canonical repository
 * entry point for the Linux sender PC implementation.
 *
 * Project scope
 * -------------
 * - Linux OMT sender for Magewell HDMI capture devices
 * - Video input via V4L2 (`-t v4l2:...`) or synthetic/original testcard
 * - Audio input via ALSA (`-s alsa:...`) or built-in testcard noise
 * - OMT network sender over TCP using libomt
 * - Runtime stats, sender health, rolling 24 h exit summary, clean signal stop
 *
 * Validated environment from project handoff
 * ------------------------------------------
 * - Debian 13 sender PC
 * - Host: qduv1
 * - Capture hardware: 4x Magewell Pro Capture HDMI
 * - Devices observed as /dev/video0 .. /dev/video3
 * - OMT libs already built and verified: libvmx, libomtnet, libomt
 * - Interop verified against vMix: discovery, test video/audio, live V4L2,
 *   live ALSA HDMI audio
 *
 * Architectural intent
 * --------------------
 * Linux sender PC -> Magewell Pro Capture HDMI -> V4L2 / ALSA -> OMT sender
 *
 * The sender is intentionally small and direct. Preferred behavior is to pass
 * through formats that OMT can send natively and only perform limited local
 * conversion where explicitly implemented.
 *
 * Current CLI surface
 * -------------------
 * General help:
 *   ./omtsndcli_v01 -h
 *
 * Video help:
 *   ./omtsndcli_v01 -t help
 *   ./omtsndcli_v01 -t testcard:help
 *   ./omtsndcli_v01 -t v4l2:help
 *
 * Audio help:
 *   ./omtsndcli_v01 -s help
 *   ./omtsndcli_v01 -s testcard:help
 *   ./omtsndcli_v01 -s alsa:help
 *
 * Examples:
 *   ./omtsndcli_v01 -t testcard
 *   ./omtsndcli_v01 -t testcard -s testcard
 *   ./omtsndcli_v01 -t v4l2:device=/dev/video0
 *   ./omtsndcli_v01 -t v4l2:device=/dev/video0:name=Cam1:format=YUY2:b=mid
 *   ./omtsndcli_v01 -t v4l2:device=/dev/video0 -s alsa:hw:2,0
 *
 * Quality mapping
 * ---------------
 * User-facing bitrate / quality aliases map to OMT quality as follows:
 *   low  | 1 -> OMTQuality_Low
 *   mid  | 2 -> OMTQuality_Medium
 *   high | 3 -> OMTQuality_High
 *
 * Operational notes
 * -----------------
 * - `late` in sender health means `omt_send()` exceeded the frame budget.
 * - `late` is not the same as `dropped`.
 * - This source already contains V4L2 format discovery/classification,
 *   optional RGB->BGRA conversion paths, ALSA capture, test generators,
 *   runtime statistics, and 24 h rolling interval summarization.
 *
 * Build example
 * -------------
 * clang++ -O3 -std=c++17 -o omtsndcli_v01 omtsndcli_v01.cpp \
 *     -L. -lomt -lasound -Wl,-rpath,'$ORIGIN'
 */


#include <iostream>
#include <chrono>
#include <thread>
#include <fstream>
#include <vector>
#include <map>
#include <string>
#include <cstring>
#include <cstdlib>
#include <ctime>
#include <cmath>
#include <algorithm>
#include <cstdint>
#include <cerrno>
#include <stdexcept>
#include <sstream>
#include <filesystem>
#include <memory>
#include <iomanip>
#include <deque>
#include <csignal>

#include <fcntl.h>
#include <unistd.h>
#include <sys/ioctl.h>
#include <sys/mman.h>
#include <linux/videodev2.h>

#include <alsa/asoundlib.h>

// The header for the C/C++ wrapper of OMT
#include "libomt.h"

using namespace std;


static volatile sig_atomic_t g_stop_requested = 0;

static void handle_signal(int)
{
    g_stop_requested = 1;
}


struct CaptureBuffer
{
    void* start = nullptr;
    size_t length = 0;
};

struct ParsedSpec
{
    std::string driver;
    std::map<std::string, std::string> kv;
};

enum class VideoSourceType
{
    Testcard,
    V4L2,
};

enum class AudioSourceType
{
    None,
    Testcard,
    ALSA,
};

struct VideoConfig
{
    VideoSourceType type = VideoSourceType::Testcard;
    std::string device = "/dev/video0";
    std::string name;
    std::string format = "YUY2";
    std::string file = "california-1080-uyvy.yuv";
    int width = 1920;
    int height = 1080;
    int fps = 50;
    std::string bitrate = "mid";
    int qualityCode = 0;
    std::map<std::string, std::string> controls;
};

struct AudioConfig
{
    AudioSourceType type = AudioSourceType::None;
    std::string device = "default";
    int rate = 48000;
    int channels = 2;
    double volumeDb = -20.0;
};

enum class V4L2ConversionMode
{
    None,
    RGB4_TO_BGRA,
    RGB3_TO_BGRA,
    BGR3_TO_BGRA,
};

struct V4L2State
{
    int fd = -1;
    uint32_t pixelformat = 0;
    OMTCodec outputCodec = OMTCodec_UYVY;
    V4L2ConversionMode conversionMode = V4L2ConversionMode::None;
    std::vector<CaptureBuffer> buffers;
    size_t inputStride = 0;
    size_t inputFrameBytes = 0;
};

struct TestcardVideoState
{
    std::vector<uint8_t> baseFrame;
    std::vector<uint8_t> movingLines;
    size_t linePos = 0;
};

struct ALSAState
{
    snd_pcm_t* pcm = nullptr;
    std::vector<int16_t> interleaved;
};

struct TestcardAudioState
{
    std::vector<float> samples;
    float gain = 0.1f;
};

static int xioctl(int fd, unsigned long request, void* arg)
{
    int r;
    do
    {
        r = ioctl(fd, request, arg);
    } while (r == -1 && errno == EINTR);
    return r;
}

static float rand_FloatRange(float a, float b)
{
    return ((b - a) * ((float)rand() / (float)RAND_MAX)) + a;
}

static std::vector<std::string> split(const std::string& text, char sep)
{
    std::vector<std::string> out;
    size_t start = 0;
    while (start <= text.size())
    {
        size_t end = text.find(sep, start);
        out.push_back(text.substr(start, end == std::string::npos ? std::string::npos : end - start));
        if (end == std::string::npos)
        {
            break;
        }
        start = end + 1;
    }
    return out;
}

static std::string trim(const std::string& s)
{
    size_t start = 0;
    while (start < s.size() && std::isspace(static_cast<unsigned char>(s[start])))
    {
        ++start;
    }
    size_t end = s.size();
    while (end > start && std::isspace(static_cast<unsigned char>(s[end - 1])))
    {
        --end;
    }
    return s.substr(start, end - start);
}

static std::string to_lower(std::string s)
{
    std::transform(s.begin(), s.end(), s.begin(), [](unsigned char c) { return static_cast<char>(std::tolower(c)); });
    return s;
}

static std::string normalize_control_name(const std::string& s)
{
    std::string out;
    for (unsigned char c : s)
    {
        if (std::isalnum(c))
        {
            out.push_back(static_cast<char>(std::tolower(c)));
        }
        else if (c == ' ' || c == '-' || c == '_' || c == '.')
        {
            out.push_back('_');
        }
    }
    return out;
}

static std::string fourcc_to_string(uint32_t fourcc)
{
    char out[5] = {
        static_cast<char>(fourcc & 0xFF),
        static_cast<char>((fourcc >> 8) & 0xFF),
        static_cast<char>((fourcc >> 16) & 0xFF),
        static_cast<char>((fourcc >> 24) & 0xFF),
        0
    };
    return std::string(out);
}

static ParsedSpec parse_spec(const std::string& spec)
{
    ParsedSpec out;

    size_t firstColon = spec.find(':');
    if (firstColon == std::string::npos)
    {
        out.driver = spec;
        return out;
    }

    out.driver = spec.substr(0, firstColon);
    std::string rest = spec.substr(firstColon + 1);
    auto tokens = split(rest, ':');

    for (const auto& tokenRaw : tokens)
    {
        std::string token = trim(tokenRaw);
        if (token.empty())
        {
            continue;
        }

        if (token == "help")
        {
            out.kv["help"] = "1";
            continue;
        }

        size_t eq = token.find('=');
        if (eq != std::string::npos)
        {
            out.kv[token.substr(0, eq)] = token.substr(eq + 1);
        }
        else
        {
            if (!out.kv.count("device"))
            {
                out.kv["device"] = token;
            }
            else
            {
                out.kv["device"] += ":" + token;
            }
        }
    }

    return out;
}

static int get_int(const std::map<std::string, std::string>& kv, const std::string& key, int fallback)
{
    auto it = kv.find(key);
    if (it == kv.end())
    {
        return fallback;
    }
    return std::stoi(it->second);
}

static double get_double(const std::map<std::string, std::string>& kv, const std::string& key, double fallback)
{
    auto it = kv.find(key);
    if (it == kv.end())
    {
        return fallback;
    }
    return std::stod(it->second);
}

static std::string get_string(const std::map<std::string, std::string>& kv, const std::string& key, const std::string& fallback)
{
    auto it = kv.find(key);
    if (it == kv.end())
    {
        return fallback;
    }
    return it->second;
}


static std::string get_string_any(const std::map<std::string, std::string>& kv,
                                  std::initializer_list<const char*> keys,
                                  const std::string& fallback)
{
    for (const char* key : keys)
    {
        auto it = kv.find(key);
        if (it != kv.end())
        {
            return it->second;
        }
    }
    return fallback;
}

static int get_int_any(const std::map<std::string, std::string>& kv,
                       std::initializer_list<const char*> keys,
                       int fallback)
{
    for (const char* key : keys)
    {
        auto it = kv.find(key);
        if (it != kv.end())
        {
            return std::stoi(it->second);
        }
    }
    return fallback;
}

enum class FormatSupportKind
{
    Passthrough,
    ConversionOnly,
    Unsupported,
};

struct FormatSupport
{
    FormatSupportKind kind = FormatSupportKind::Unsupported;
    std::string target;
};

static bool stdout_supports_color()
{
    return isatty(STDOUT_FILENO) != 0;
}

static std::string colorize_text(const std::string& text, const char* code)
{
    if (!stdout_supports_color())
    {
        return text;
    }
    return std::string(code) + text + "\033[0m";
}

static std::string yellow_text(const std::string& text)
{
    return colorize_text(text, "\033[33m");
}

static std::string white_text(const std::string& text)
{
    return colorize_text(text, "\033[97m");
}

static std::string green_text(const std::string& text)
{
    return colorize_text(text, "\033[32m");
}

static std::string red_text(const std::string& text)
{
    return colorize_text(text, "\033[31m");
}

static std::string cyan_text(const std::string& text)
{
    return colorize_text(text, "\033[36m");
}

static FormatSupport classify_v4l2_format(uint32_t pixelformat)
{
    if (pixelformat == V4L2_PIX_FMT_YUYV)
    {
        return {FormatSupportKind::Passthrough, "YUY2"};
    }
    if (pixelformat == V4L2_PIX_FMT_UYVY)
    {
        return {FormatSupportKind::Passthrough, "UYVY"};
    }
#ifdef V4L2_PIX_FMT_NV12
    if (pixelformat == V4L2_PIX_FMT_NV12)
    {
        return {FormatSupportKind::Passthrough, "NV12"};
    }
#endif
#ifdef V4L2_PIX_FMT_YVU420
    if (pixelformat == V4L2_PIX_FMT_YVU420)
    {
        return {FormatSupportKind::Passthrough, "YV12"};
    }
#endif
#ifdef V4L2_PIX_FMT_YUV420
    if (pixelformat == V4L2_PIX_FMT_YUV420)
    {
        return {FormatSupportKind::Unsupported, ""};
    }
#endif
#ifdef V4L2_PIX_FMT_BGR32
    if (pixelformat == V4L2_PIX_FMT_BGR32)
    {
        return {FormatSupportKind::Passthrough, "BGRA"};
    }
#endif
#ifdef V4L2_PIX_FMT_RGB32
    if (pixelformat == V4L2_PIX_FMT_RGB32)
    {
        return {FormatSupportKind::ConversionOnly, "BGRA"};
    }
#endif
#ifdef V4L2_PIX_FMT_RGB24
    if (pixelformat == V4L2_PIX_FMT_RGB24)
    {
        return {FormatSupportKind::ConversionOnly, "BGRA"};
    }
#endif
#ifdef V4L2_PIX_FMT_BGR24
    if (pixelformat == V4L2_PIX_FMT_BGR24)
    {
        return {FormatSupportKind::ConversionOnly, "BGRA"};
    }
#endif
    return {FormatSupportKind::Unsupported, ""};
}

static std::string format_support_suffix(const FormatSupport& support)
{
    switch (support.kind)
    {
        case FormatSupportKind::Passthrough:
            return "[OMT passthrough: yes -> " + support.target + "]";
        case FormatSupportKind::ConversionOnly:
            return "[OMT conversion only -> " + support.target + "]";
        default:
            return "[not sendable by this sender without conversion]";
    }
}

static std::string colorized_format_line(const std::string& base, const FormatSupport& support)
{
    std::string text = base + " " + format_support_suffix(support);
    switch (support.kind)
    {
        case FormatSupportKind::Passthrough:
            return colorize_text(text, "\033[32m");
        case FormatSupportKind::ConversionOnly:
            return colorize_text(text, "\033[38;5;208m");
        default:
            return colorize_text(text, "\033[31m");
    }
}

static int parse_quality_code(const std::string& value)
{
    std::string v = to_lower(trim(value));
    if (v.empty() || v == "default" || v == "mid" || v == "medium" || v == "2")
    {
        return static_cast<int>(OMTQuality_Medium);
    }
    if (v == "low" || v == "1")
    {
        return static_cast<int>(OMTQuality_Low);
    }
    if (v == "high" || v == "3")
    {
        return static_cast<int>(OMTQuality_High);
    }
    throw std::runtime_error("Unsupported bitrate/quality value: " + value + " (use low|mid|high or 1|2|3)");
}

static std::string normalize_quality_label(const std::string& value)
{
    std::string v = to_lower(trim(value));
    if (v.empty() || v == "default" || v == "mid" || v == "medium" || v == "2")
    {
        return "mid";
    }
    if (v == "low" || v == "1")
    {
        return "low";
    }
    if (v == "high" || v == "3")
    {
        return "high";
    }
    throw std::runtime_error("Unsupported bitrate/quality value: " + value + " (use low|mid|high or 1|2|3)");
}


static std::string quality_label_from_code(int qualityCode)
{
    if (qualityCode == static_cast<int>(OMTQuality_Low))
    {
        return "Low";
    }
    if (qualityCode == static_cast<int>(OMTQuality_Medium))
    {
        return "Medium";
    }
    if (qualityCode == static_cast<int>(OMTQuality_High))
    {
        return "High";
    }
    if (qualityCode == static_cast<int>(OMTQuality_Default))
    {
        return "Default";
    }
    return "Unknown";
}

static std::string format_decimal(double value, int decimals)
{
    std::ostringstream oss;
    oss << std::fixed << std::setprecision(decimals) << value;
    return oss.str();
}

static std::string white_or_red_uint64(uint64_t value)
{
    std::string s = std::to_string(value);
    return value == 0 ? white_text(s) : red_text(s);
}

static std::string white_or_red_double(double value, int decimals)
{
    std::string s = format_decimal(value, decimals);
    return value == 0.0 ? white_text(s) : red_text(s);
}

struct RollingInterval
{
    std::chrono::steady_clock::time_point endTime;
    double elapsedSeconds = 0.0;
    uint64_t videoFrames = 0;
    uint64_t videoBytes = 0;
    uint64_t audioSamplesPerChannel = 0;
    uint64_t capturedFrames = 0;
    uint64_t sentFrames = 0;
    uint64_t droppedFrames = 0;
    uint64_t lateFrames = 0;
    double sendTimeSumMs = 0.0;
    double sendTimeMaxMs = 0.0;
};

static void trim_rolling_intervals(std::deque<RollingInterval>& intervals,
                                   const std::chrono::steady_clock::time_point& now)
{
    const auto window = std::chrono::hours(24);
    while (!intervals.empty() && (now - intervals.front().endTime) > window)
    {
        intervals.pop_front();
    }
}

static void accumulate_audio_levels(const OMTMediaFrame& audio_frame,
                                    std::vector<double>& sumSquares,
                                    std::vector<double>& peaks)
{
    const float* samples = static_cast<const float*>(audio_frame.Data);
    if (!samples)
    {
        return;
    }

    for (int s = 0; s < audio_frame.SamplesPerChannel; ++s)
    {
        for (int ch = 0; ch < audio_frame.Channels; ++ch)
        {
            size_t idx = static_cast<size_t>(s) * static_cast<size_t>(audio_frame.Channels) + static_cast<size_t>(ch);
            double v = samples[idx];
            sumSquares[ch] += v * v;
            peaks[ch] = std::max(peaks[ch], std::abs(v));
        }
    }
}

static std::string audio_levels_line(const std::vector<double>& sumSquares,
                                     const std::vector<double>& peaks,
                                     uint64_t samplesPerChannelInInterval)
{
    std::ostringstream oss;
    oss << yellow_text("[Audio sender] Volume: ");
    if (samplesPerChannelInInterval == 0 || sumSquares.empty())
    {
        oss << green_text("(no audio samples)");
        return oss.str();
    }

    for (size_t ch = 0; ch < sumSquares.size(); ++ch)
    {
        double rms = std::sqrt(sumSquares[ch] / static_cast<double>(samplesPerChannelInInterval));
        double peak = peaks[ch];
        double rmsDb = 20.0 * std::log10(std::max(rms, 1e-12));
        double peakDb = 20.0 * std::log10(std::max(peak, 1e-12));

        if (ch > 0)
        {
            oss << " ";
        }

        std::ostringstream channel;
        channel << "[" << ch << "] "
                << std::fixed << std::setprecision(2)
                << rmsDb << "/" << peakDb << " dBFS RMS/peak";
        oss << green_text(channel.str());
    }
    return oss.str();
}


static std::string sender_health_line(uint64_t capturedFrames,
                                      uint64_t sentFrames,
                                      uint64_t droppedFrames,
                                      uint64_t lateFrames,
                                      double avgSendMs,
                                      double maxSendMs)
{
    std::ostringstream oss;
    oss << white_text("-----------------------------------------------------------------------------") << "\n";
    oss << white_text(" Sender health   : ")
        << white_text("captured=") << white_text(std::to_string(capturedFrames))
        << white_text(" sent=") << white_text(std::to_string(sentFrames))
        << white_text(" dropped=") << white_or_red_uint64(droppedFrames)
        << white_text(" late=") << white_or_red_uint64(lateFrames)
        << white_text(" omt_send avg/max=") << white_text(format_decimal(avgSendMs, 3))
        << white_text("/") << white_or_red_double(maxSendMs, 3)
        << white_text(" ms");
    return oss.str();
}

static void print_exit_summary(const std::deque<RollingInterval>& intervals,
                               bool audioEnabled)
{
    double seconds = 0.0;
    uint64_t videoFrames = 0;
    uint64_t videoBytes = 0;
    uint64_t audioSamples = 0;
    uint64_t capturedFrames = 0;
    uint64_t sentFrames = 0;
    uint64_t droppedFrames = 0;
    uint64_t lateFrames = 0;
    double sendTimeSumMs = 0.0;
    double sendTimeMaxMs = 0.0;

    for (const auto& item : intervals)
    {
        seconds += item.elapsedSeconds;
        videoFrames += item.videoFrames;
        videoBytes += item.videoBytes;
        audioSamples += item.audioSamplesPerChannel;
        capturedFrames += item.capturedFrames;
        sentFrames += item.sentFrames;
        droppedFrames += item.droppedFrames;
        lateFrames += item.lateFrames;
        sendTimeSumMs += item.sendTimeSumMs;
        sendTimeMaxMs = std::max(sendTimeMaxMs, item.sendTimeMaxMs);
    }

    std::cout << "\n";
    std::cout << yellow_text("Last 24h summary") << "\n";
    if (seconds <= 0.0)
    {
        std::cout << yellow_text("  No interval statistics collected.") << "\n";
        return;
    }

    double avgFps = static_cast<double>(videoFrames) / seconds;
    double avgBitrateMbit = (static_cast<double>(videoBytes) * 8.0) / seconds / 1000000.0;
    double avgSendMs = sentFrames > 0 ? (sendTimeSumMs / static_cast<double>(sentFrames)) : 0.0;

    std::cout << yellow_text("  Window          : ")
              << format_decimal(seconds / 3600.0, 2) << " h\n";
    std::cout << yellow_text("  Video frames    : ")
              << videoFrames << "\n";
    std::cout << yellow_text("  Average FPS     : ")
              << format_decimal(avgFps, 3) << "\n";
    std::cout << yellow_text("  Average bitrate : ")
              << cyan_text(format_decimal(avgBitrateMbit, 3) + " Mbit/s") << "\n";
    std::cout << white_text("  Sender health   : ")
              << white_text("captured=") << white_text(std::to_string(capturedFrames))
              << white_text(" sent=") << white_text(std::to_string(sentFrames))
              << white_text(" dropped=") << white_or_red_uint64(droppedFrames)
              << white_text(" late=") << white_or_red_uint64(lateFrames)
              << white_text(" omt_send avg/max=") << white_text(format_decimal(avgSendMs, 3))
              << white_text("/") << white_or_red_double(sendTimeMaxMs, 3)
              << white_text(" ms") << "\n";

    if (audioEnabled)
    {
        std::cout << yellow_text("  Audio samples   : ")
                  << audioSamples << " samples/channel\n";
    }
}


static std::string basename_like(const std::string& path)
{
    size_t pos = path.find_last_of('/');
    if (pos == std::string::npos)
    {
        return path;
    }
    if (pos + 1 >= path.size())
    {
        return path;
    }
    return path.substr(pos + 1);
}

static VideoConfig build_video_config(const std::string& spec)
{
    ParsedSpec parsed = parse_spec(spec);
    VideoConfig cfg;

    if (parsed.driver.empty() || parsed.driver == "testcard")
    {
        cfg.type = VideoSourceType::Testcard;
        cfg.width = get_int(parsed.kv, "width", 1920);
        cfg.height = get_int(parsed.kv, "height", 1080);
        cfg.fps = get_int(parsed.kv, "fps", 60);
        cfg.format = get_string_any(parsed.kv, {"format", "fmt"}, "UYVY");
        cfg.file = get_string(parsed.kv, "file", "california-1080-uyvy.yuv");
        cfg.name = get_string(parsed.kv, "name", "Testcard");
        cfg.bitrate = normalize_quality_label(get_string_any(parsed.kv, {"bitrate", "b"}, "mid"));
        cfg.qualityCode = parse_quality_code(cfg.bitrate);
        return cfg;
    }

    if (parsed.driver == "v4l2")
    {
        cfg.type = VideoSourceType::V4L2;
        cfg.device = get_string_any(parsed.kv, {"device", "d"}, "/dev/video0");
        cfg.width = get_int(parsed.kv, "width", 1920);
        cfg.height = get_int(parsed.kv, "height", 1080);
        cfg.fps = get_int(parsed.kv, "fps", 50);
        cfg.format = get_string_any(parsed.kv, {"format", "fmt"}, "YUY2");
        cfg.name = get_string(parsed.kv, "name", "Magewell " + basename_like(cfg.device));
        cfg.bitrate = normalize_quality_label(get_string_any(parsed.kv, {"bitrate", "b"}, "mid"));
        cfg.qualityCode = parse_quality_code(cfg.bitrate);

        for (const auto& [key, value] : parsed.kv)
        {
            if (key.rfind("ctrl.", 0) == 0)
            {
                cfg.controls[key.substr(5)] = value;
            }
            else if (key.rfind("control.", 0) == 0)
            {
                cfg.controls[key.substr(8)] = value;
            }
        }
        return cfg;
    }

    throw std::runtime_error("Unsupported video transport: " + parsed.driver);
}

static AudioConfig build_audio_config(const std::string& spec)
{
    ParsedSpec parsed = parse_spec(spec);
    AudioConfig cfg;

    if (parsed.driver.empty() || parsed.driver == "testcard")
    {
        cfg.type = AudioSourceType::Testcard;
        cfg.rate = get_int(parsed.kv, "rate", 48000);
        cfg.channels = get_int(parsed.kv, "channels", 2);
        cfg.volumeDb = get_double(parsed.kv, "volume", -20.0);
        return cfg;
    }

    if (parsed.driver == "alsa")
    {
        cfg.type = AudioSourceType::ALSA;
        cfg.device = get_string(parsed.kv, "device", "default");
        cfg.rate = get_int(parsed.kv, "rate", 48000);
        cfg.channels = get_int(parsed.kv, "channels", 2);
        cfg.volumeDb = get_double(parsed.kv, "volume", 0.0);
        return cfg;
    }

    throw std::runtime_error("Unsupported audio source: " + parsed.driver);
}

static uint32_t v4l2_fourcc_from_string(const std::string& format)
{
    std::string f = to_lower(format);
    if (f == "yuy2" || f == "yuyv")
    {
        return V4L2_PIX_FMT_YUYV;
    }
    if (f == "uyvy")
    {
        return V4L2_PIX_FMT_UYVY;
    }
#ifdef V4L2_PIX_FMT_BGR32
    if (f == "bgr4" || f == "bgra")
    {
        return V4L2_PIX_FMT_BGR32;
    }
#endif
#ifdef V4L2_PIX_FMT_RGB32
    if (f == "rgb4" || f == "argb" || f == "xrgb")
    {
        return V4L2_PIX_FMT_RGB32;
    }
#endif
#ifdef V4L2_PIX_FMT_NV12
    if (f == "nv12")
    {
        return V4L2_PIX_FMT_NV12;
    }
#endif
#ifdef V4L2_PIX_FMT_YVU420
    if (f == "yv12")
    {
        return V4L2_PIX_FMT_YVU420;
    }
#endif
#ifdef V4L2_PIX_FMT_YUV420
    if (f == "yu12" || f == "i420")
    {
        return V4L2_PIX_FMT_YUV420;
    }
#endif
#ifdef V4L2_PIX_FMT_RGB24
    if (f == "rgb3" || f == "rgb24")
    {
        return V4L2_PIX_FMT_RGB24;
    }
#endif
#ifdef V4L2_PIX_FMT_BGR24
    if (f == "bgr3" || f == "bgr24")
    {
        return V4L2_PIX_FMT_BGR24;
    }
#endif
#ifdef V4L2_PIX_FMT_GREY
    if (f == "grey" || f == "gray")
    {
        return V4L2_PIX_FMT_GREY;
    }
#endif
#ifdef V4L2_PIX_FMT_Y16
    if (f == "y16")
    {
        return V4L2_PIX_FMT_Y16;
    }
#endif
#ifdef V4L2_PIX_FMT_YUV32
    if (f == "yuv4")
    {
        return V4L2_PIX_FMT_YUV32;
    }
#endif
    return 0;
}

static bool omt_codec_from_v4l2(uint32_t pixelformat, OMTCodec& codec)
{
    if (pixelformat == V4L2_PIX_FMT_YUYV)
    {
        codec = OMTCodec_YUY2;
        return true;
    }
    if (pixelformat == V4L2_PIX_FMT_UYVY)
    {
        codec = OMTCodec_UYVY;
        return true;
    }
#ifdef V4L2_PIX_FMT_NV12
    if (pixelformat == V4L2_PIX_FMT_NV12)
    {
        codec = OMTCodec_NV12;
        return true;
    }
#endif
#ifdef V4L2_PIX_FMT_YVU420
    if (pixelformat == V4L2_PIX_FMT_YVU420)
    {
        codec = OMTCodec_YV12;
        return true;
    }
#endif
#ifdef V4L2_PIX_FMT_BGR32
    if (pixelformat == V4L2_PIX_FMT_BGR32)
    {
        codec = OMTCodec_BGRA;
        return true;
    }
#endif
    return false;
}

static bool omt_codec_from_testcard_format(const std::string& format, OMTCodec& codec)
{
    std::string f = to_lower(format);
    if (f == "uyvy")
    {
        codec = OMTCodec_UYVY;
        return true;
    }
    if (f == "yuy2" || f == "yuyv")
    {
        codec = OMTCodec_YUY2;
        return true;
    }
    return false;
}

static void generate_synthetic_testcard(std::vector<uint8_t>& frame, int width, int height, OMTCodec codec)
{
    frame.resize(static_cast<size_t>(width) * static_cast<size_t>(height) * 2);

    const uint8_t yValues[8] = { 235, 210, 170, 145, 106, 81, 41, 16 };
    const uint8_t uValues[8] = { 128, 16, 166, 54, 202, 90, 240, 128 };
    const uint8_t vValues[8] = { 128, 146, 16, 34, 222, 240, 110, 128 };

    for (int y = 0; y < height; ++y)
    {
        for (int x = 0; x < width; x += 2)
        {
            int bar = std::min(7, (x * 8) / std::max(1, width));
            size_t idx = (static_cast<size_t>(y) * width + x) * 2;
            uint8_t y0 = yValues[bar];
            uint8_t y1 = yValues[bar];
            uint8_t u = uValues[bar];
            uint8_t v = vValues[bar];

            if (codec == OMTCodec_UYVY)
            {
                frame[idx + 0] = u;
                frame[idx + 1] = y0;
                frame[idx + 2] = v;
                frame[idx + 3] = y1;
            }
            else
            {
                frame[idx + 0] = y0;
                frame[idx + 1] = u;
                frame[idx + 2] = y1;
                frame[idx + 3] = v;
            }
        }
    }
}

static bool load_original_test_file(std::vector<uint8_t>& frame, const VideoConfig& cfg, OMTCodec codec)
{
    if (cfg.width != 1920 || cfg.height != 1080 || codec != OMTCodec_UYVY)
    {
        return false;
    }

    std::ifstream file(cfg.file, std::ios::binary | std::ios::in | std::ios::ate);
    if (!file.is_open())
    {
        return false;
    }

    std::streamsize size = file.tellg();
    file.seekg(0, std::ios::beg);
    if (size != static_cast<std::streamsize>(frame.size()))
    {
        return false;
    }

    if (!file.read(reinterpret_cast<char*>(frame.data()), size))
    {
        return false;
    }

    return true;
}

static bool init_testcard_video(const VideoConfig& cfg, OMTMediaFrame& video_frame, TestcardVideoState& state, std::string& error)
{
    OMTCodec codec = {};
    if (!omt_codec_from_testcard_format(cfg.format, codec))
    {
        error = "Unsupported testcard video format: " + cfg.format;
        return false;
    }

    video_frame = {};
    video_frame.Type = OMTFrameType_Video;
    video_frame.Width = cfg.width;
    video_frame.Height = cfg.height;
    video_frame.Codec = codec;
    video_frame.Timestamp = -1;
    video_frame.ColorSpace = (cfg.height >= 720) ? OMTColorSpace_BT709 : OMTColorSpace_BT601;
    video_frame.Flags = OMTVideoFlags_None;
    video_frame.Stride = cfg.width * 2;
    video_frame.DataLength = video_frame.Stride * video_frame.Height;
    video_frame.Data = malloc(video_frame.DataLength);
    video_frame.FrameRateN = cfg.fps * 1000;
    video_frame.FrameRateD = 1000;
    video_frame.FrameMetadata = NULL;
    video_frame.FrameMetadataLength = 0;

    if (!video_frame.Data)
    {
        error = "malloc(video_frame.Data) failed";
        return false;
    }

    state.baseFrame.resize(video_frame.DataLength);
    if (!load_original_test_file(state.baseFrame, cfg, codec))
    {
        generate_synthetic_testcard(state.baseFrame, cfg.width, cfg.height, codec);
    }

    state.movingLines.resize(static_cast<size_t>(video_frame.Stride) * 2, 255);
    state.linePos = 0;
    std::memcpy(video_frame.Data, state.baseFrame.data(), state.baseFrame.size());
    std::ostringstream tcLine;
    tcLine << "[Testcard video] Capturing " << cfg.width << "x" << cfg.height
           << " @" << std::fixed << std::setprecision(2) << static_cast<double>(cfg.fps) << "p "
           << cfg.format << " from synthetic/original testcard";
    std::cout << white_text(tcLine.str()) << "\n";
    return true;
}

static bool grab_testcard_video_frame(OMTMediaFrame& video_frame, TestcardVideoState& state)
{
    std::memcpy(video_frame.Data, state.baseFrame.data(), state.baseFrame.size());
    std::memcpy(static_cast<char*>(video_frame.Data) + state.linePos,
                state.movingLines.data(),
                state.movingLines.size());

    state.linePos += state.movingLines.size();
    if (state.linePos >= static_cast<size_t>(video_frame.DataLength))
    {
        state.linePos = 0;
    }
    return true;
}

static std::vector<std::string> list_v4l2_device_paths()
{
    std::vector<std::string> out;
    for (const auto& entry : std::filesystem::directory_iterator("/dev"))
    {
        std::string name = entry.path().filename().string();
        if (name.rfind("video", 0) == 0)
        {
            out.push_back(entry.path().string());
        }
    }
    std::sort(out.begin(), out.end());
    return out;
}

static std::string v4l2_control_type_name(uint32_t type)
{
    switch (type)
    {
        case V4L2_CTRL_TYPE_INTEGER: return "integer";
        case V4L2_CTRL_TYPE_BOOLEAN: return "boolean";
        case V4L2_CTRL_TYPE_MENU: return "menu";
        case V4L2_CTRL_TYPE_BUTTON: return "button";
        case V4L2_CTRL_TYPE_INTEGER64: return "integer64";
#ifdef V4L2_CTRL_TYPE_STRING
        case V4L2_CTRL_TYPE_STRING: return "string";
#endif
#ifdef V4L2_CTRL_TYPE_BITMASK
        case V4L2_CTRL_TYPE_BITMASK: return "bitmask";
#endif
#ifdef V4L2_CTRL_TYPE_INTEGER_MENU
        case V4L2_CTRL_TYPE_INTEGER_MENU: return "integer_menu";
#endif
        default: return "other";
    }
}

static void print_v4l2_controls(int fd)
{
    std::cout << "  controls:\n";

    v4l2_queryctrl query = {};
#ifdef V4L2_CTRL_FLAG_NEXT_CTRL
    query.id = V4L2_CTRL_FLAG_NEXT_CTRL;
#else
    query.id = V4L2_CID_BASE;
#endif

    bool any = false;
    while (xioctl(fd, VIDIOC_QUERYCTRL, &query) == 0)
    {
        if (!(query.flags & V4L2_CTRL_FLAG_DISABLED))
        {
            any = true;
            std::string norm = normalize_control_name(reinterpret_cast<const char*>(query.name));
            std::cout << "    " << norm
                      << " [" << v4l2_control_type_name(query.type) << "]"
                      << " min=" << query.minimum
                      << " max=" << query.maximum
                      << " step=" << query.step
                      << " default=" << query.default_value;

            if (query.type == V4L2_CTRL_TYPE_INTEGER ||
                query.type == V4L2_CTRL_TYPE_BOOLEAN ||
                query.type == V4L2_CTRL_TYPE_MENU)
            {
                v4l2_control ctrl = {};
                ctrl.id = query.id;
                if (xioctl(fd, VIDIOC_G_CTRL, &ctrl) == 0)
                {
                    std::cout << " current=" << ctrl.value;
                }
            }
            std::cout << "\n";
        }

#ifdef V4L2_CTRL_FLAG_NEXT_CTRL
        query.id |= V4L2_CTRL_FLAG_NEXT_CTRL;
#else
        ++query.id;
#endif
    }

    if (!any)
    {
        std::cout << "    (none exposed by driver)\n";
    }
}

static void print_v4l2_formats(int fd)
{
    std::cout << "  formats:\n";
    v4l2_fmtdesc fmtdesc = {};
    fmtdesc.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;

    bool any = false;
    for (fmtdesc.index = 0; xioctl(fd, VIDIOC_ENUM_FMT, &fmtdesc) == 0; ++fmtdesc.index)
    {
        any = true;
        std::string formatLine = "    " + fourcc_to_string(fmtdesc.pixelformat) +
                                 " - " + reinterpret_cast<const char*>(fmtdesc.description);
        std::cout << colorized_format_line(formatLine, classify_v4l2_format(fmtdesc.pixelformat)) << "\n";

        v4l2_frmsizeenum frmsize = {};
        frmsize.pixel_format = fmtdesc.pixelformat;
        for (frmsize.index = 0; xioctl(fd, VIDIOC_ENUM_FRAMESIZES, &frmsize) == 0; ++frmsize.index)
        {
            if (frmsize.type == V4L2_FRMSIZE_TYPE_DISCRETE)
            {
                std::cout << "      size " << frmsize.discrete.width << "x" << frmsize.discrete.height;

                v4l2_frmivalenum frmival = {};
                frmival.pixel_format = fmtdesc.pixelformat;
                frmival.width = frmsize.discrete.width;
                frmival.height = frmsize.discrete.height;
                bool first = true;
                for (frmival.index = 0; xioctl(fd, VIDIOC_ENUM_FRAMEINTERVALS, &frmival) == 0; ++frmival.index)
                {
                    if (frmival.type == V4L2_FRMIVAL_TYPE_DISCRETE && frmival.discrete.numerator != 0)
                    {
                        double fps = static_cast<double>(frmival.discrete.denominator) / frmival.discrete.numerator;
                        std::cout << (first ? " fps " : ", ") << std::fixed << std::setprecision(3) << fps;
                        first = false;
                    }
                }
                std::cout << "\n";
            }
            else if (frmsize.type == V4L2_FRMSIZE_TYPE_CONTINUOUS || frmsize.type == V4L2_FRMSIZE_TYPE_STEPWISE)
            {
                std::cout << "      size " << frmsize.stepwise.min_width << "x" << frmsize.stepwise.min_height
                          << " .. " << frmsize.stepwise.max_width << "x" << frmsize.stepwise.max_height
                          << " step " << frmsize.stepwise.step_width << "x" << frmsize.stepwise.step_height << "\n";
            }
        }
    }

    if (!any)
    {
        std::cout << "    (no capture formats found)\n";
    }
}

static void print_v4l2_help(const std::string& requestedDevice)
{
    std::cout << "v4l2 module\n";
    std::cout << "  syntax:\n";
    std::cout << "    -t v4l2:device=/dev/video0[:name=Cam1][:width=1920][:height=1080][:fps=50][:format=YUY2]\n";
    std::cout << "    -t v4l2:device=/dev/video0:ctrl.<control_name>=<value>\n";
    std::cout << "\n";
    std::cout << "  notes:\n";
    std::cout << "    - sender only forwards what V4L2 delivers; no image conversion is done inside OMT\n";
    std::cout << "    - use format / width / height / fps and V4L2 controls to drive Magewell-side processing\n";
    std::cout << "    - control names below can be set as ctrl.<normalized_name>=value\n";
    std::cout << "\n";

    auto devices = list_v4l2_device_paths();
    if (!requestedDevice.empty())
    {
        devices = {requestedDevice};
    }

    if (devices.empty())
    {
        std::cout << "  no /dev/video* devices found\n";
        return;
    }

    for (const auto& dev : devices)
    {
        int fd = open(dev.c_str(), O_RDWR | O_NONBLOCK);
        if (fd < 0)
        {
            std::cout << dev << " - open failed: " << strerror(errno) << "\n";
            continue;
        }

        v4l2_capability cap = {};
        if (xioctl(fd, VIDIOC_QUERYCAP, &cap) < 0)
        {
            std::cout << dev << " - VIDIOC_QUERYCAP failed: " << strerror(errno) << "\n";
            close(fd);
            continue;
        }

        std::cout << dev
                  << " - " << reinterpret_cast<const char*>(cap.card)
                  << " [" << reinterpret_cast<const char*>(cap.bus_info) << "]\n";
        print_v4l2_formats(fd);
        print_v4l2_controls(fd);
        std::cout << "\n";

        close(fd);
    }
}

static void print_video_modules_help()
{
    std::cout << "video modules:\n";
    std::cout << "  testcard  - built-in moving test image or california-1080-uyvy.yuv when compatible\n";
    std::cout << "  v4l2      - Linux V4L2 capture device, suitable for Magewell cards\n";
    std::cout << "\n";
    std::cout << "details:\n";
    std::cout << "  -t testcard:help\n";
    std::cout << "  -t v4l2:help\n";
}

static void print_testcard_video_help()
{
    std::cout << "testcard video module\n";
    std::cout << "  syntax:\n";
    std::cout << "    -t testcard[:name=Testcard][:width=1920][:height=1080][:fps=60][:format=UYVY][:file=california-1080-uyvy.yuv]\n";
    std::cout << "\n";
    std::cout << "  supported formats:\n";
    std::cout << "    UYVY, YUY2\n";
}

static bool lookup_v4l2_control_id(int fd, const std::string& requestedName, v4l2_queryctrl& found)
{
    std::string wanted = normalize_control_name(requestedName);

    v4l2_queryctrl query = {};
#ifdef V4L2_CTRL_FLAG_NEXT_CTRL
    query.id = V4L2_CTRL_FLAG_NEXT_CTRL;
#else
    query.id = V4L2_CID_BASE;
#endif

    while (xioctl(fd, VIDIOC_QUERYCTRL, &query) == 0)
    {
        if (!(query.flags & V4L2_CTRL_FLAG_DISABLED))
        {
            std::string current = normalize_control_name(reinterpret_cast<const char*>(query.name));
            if (current == wanted)
            {
                found = query;
                return true;
            }
        }
#ifdef V4L2_CTRL_FLAG_NEXT_CTRL
        query.id |= V4L2_CTRL_FLAG_NEXT_CTRL;
#else
        ++query.id;
#endif
    }

    return false;
}

static bool apply_v4l2_controls(int fd, const std::map<std::string, std::string>& controls, std::string& error)
{
    for (const auto& [name, valueText] : controls)
    {
        v4l2_queryctrl query = {};
        if (!lookup_v4l2_control_id(fd, name, query))
        {
            error = "Unknown V4L2 control: " + name;
            return false;
        }

        if (query.type == V4L2_CTRL_TYPE_BUTTON)
        {
            v4l2_control ctrl = {};
            ctrl.id = query.id;
            ctrl.value = 0;
            if (xioctl(fd, VIDIOC_S_CTRL, &ctrl) < 0)
            {
                error = "VIDIOC_S_CTRL failed for " + name + ": " + std::string(strerror(errno));
                return false;
            }
            continue;
        }

        if (query.type == V4L2_CTRL_TYPE_INTEGER ||
            query.type == V4L2_CTRL_TYPE_BOOLEAN ||
            query.type == V4L2_CTRL_TYPE_MENU)
        {
            int value = std::stoi(valueText);
            v4l2_control ctrl = {};
            ctrl.id = query.id;
            ctrl.value = value;
            if (xioctl(fd, VIDIOC_S_CTRL, &ctrl) < 0)
            {
                error = "VIDIOC_S_CTRL failed for " + name + ": " + std::string(strerror(errno));
                return false;
            }
            continue;
        }

        error = "Unsupported V4L2 control type for " + name;
        return false;
    }

    return true;
}


static bool determine_v4l2_output(uint32_t pixelformat, OMTCodec& codec, V4L2ConversionMode& conversionMode)
{
    conversionMode = V4L2ConversionMode::None;

    if (omt_codec_from_v4l2(pixelformat, codec))
    {
        return true;
    }

#ifdef V4L2_PIX_FMT_RGB32
    if (pixelformat == V4L2_PIX_FMT_RGB32)
    {
        codec = OMTCodec_BGRA;
        conversionMode = V4L2ConversionMode::RGB4_TO_BGRA;
        return true;
    }
#endif
#ifdef V4L2_PIX_FMT_RGB24
    if (pixelformat == V4L2_PIX_FMT_RGB24)
    {
        codec = OMTCodec_BGRA;
        conversionMode = V4L2ConversionMode::RGB3_TO_BGRA;
        return true;
    }
#endif
#ifdef V4L2_PIX_FMT_BGR24
    if (pixelformat == V4L2_PIX_FMT_BGR24)
    {
        codec = OMTCodec_BGRA;
        conversionMode = V4L2ConversionMode::BGR3_TO_BGRA;
        return true;
    }
#endif
    return false;
}

static int bytes_per_pixel_for_omt(OMTCodec codec)
{
    switch (codec)
    {
        case OMTCodec_YUY2:
        case OMTCodec_UYVY:
            return 2;
        case OMTCodec_BGRA:
            return 4;
        default:
            return 0;
    }
}

static void convert_v4l2_frame(const uint8_t* src, size_t srcStride, OMTMediaFrame& video_frame, const V4L2State& state)
{
    const int width = video_frame.Width;
    const int height = video_frame.Height;
    uint8_t* dst = static_cast<uint8_t*>(video_frame.Data);

    switch (state.conversionMode)
    {
        case V4L2ConversionMode::RGB4_TO_BGRA:
            for (int y = 0; y < height; ++y)
            {
                const uint8_t* s = src + static_cast<size_t>(y) * srcStride;
                uint8_t* d = dst + static_cast<size_t>(y) * video_frame.Stride;
                for (int x = 0; x < width; ++x)
                {
                    const uint8_t r = s[x * 4 + 0];
                    const uint8_t g = s[x * 4 + 1];
                    const uint8_t b = s[x * 4 + 2];
                    const uint8_t a = s[x * 4 + 3];
                    d[x * 4 + 0] = b;
                    d[x * 4 + 1] = g;
                    d[x * 4 + 2] = r;
                    d[x * 4 + 3] = a;
                }
            }
            break;
        case V4L2ConversionMode::RGB3_TO_BGRA:
            for (int y = 0; y < height; ++y)
            {
                const uint8_t* s = src + static_cast<size_t>(y) * srcStride;
                uint8_t* d = dst + static_cast<size_t>(y) * video_frame.Stride;
                for (int x = 0; x < width; ++x)
                {
                    const uint8_t r = s[x * 3 + 0];
                    const uint8_t g = s[x * 3 + 1];
                    const uint8_t b = s[x * 3 + 2];
                    d[x * 4 + 0] = b;
                    d[x * 4 + 1] = g;
                    d[x * 4 + 2] = r;
                    d[x * 4 + 3] = 255;
                }
            }
            break;
        case V4L2ConversionMode::BGR3_TO_BGRA:
            for (int y = 0; y < height; ++y)
            {
                const uint8_t* s = src + static_cast<size_t>(y) * srcStride;
                uint8_t* d = dst + static_cast<size_t>(y) * video_frame.Stride;
                for (int x = 0; x < width; ++x)
                {
                    d[x * 4 + 0] = s[x * 3 + 0];
                    d[x * 4 + 1] = s[x * 3 + 1];
                    d[x * 4 + 2] = s[x * 3 + 2];
                    d[x * 4 + 3] = 255;
                }
            }
            break;
        case V4L2ConversionMode::None:
        default:
            break;
    }
}

static bool init_v4l2_video(const VideoConfig& cfg, OMTMediaFrame& video_frame, V4L2State& state, std::string& error)
{
    state.fd = open(cfg.device.c_str(), O_RDWR);
    if (state.fd < 0)
    {
        error = "open(" + cfg.device + ") failed: " + std::string(strerror(errno));
        return false;
    }

    v4l2_format fmt = {};
    fmt.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
    fmt.fmt.pix.width = cfg.width;
    fmt.fmt.pix.height = cfg.height;
    fmt.fmt.pix.field = V4L2_FIELD_NONE;

    uint32_t wanted = v4l2_fourcc_from_string(cfg.format);
    if (wanted == 0)
    {
        error = "Unsupported V4L2 requested format: " + cfg.format;
        close(state.fd);
        state.fd = -1;
        return false;
    }
    fmt.fmt.pix.pixelformat = wanted;

    if (xioctl(state.fd, VIDIOC_S_FMT, &fmt) < 0)
    {
        error = "VIDIOC_S_FMT failed: " + std::string(strerror(errno));
        close(state.fd);
        state.fd = -1;
        return false;
    }

    v4l2_streamparm parm = {};
    parm.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
    parm.parm.capture.timeperframe.numerator = 1;
    parm.parm.capture.timeperframe.denominator = cfg.fps;

    if (xioctl(state.fd, VIDIOC_S_PARM, &parm) < 0)
    {
        error = "VIDIOC_S_PARM failed: " + std::string(strerror(errno));
        close(state.fd);
        state.fd = -1;
        return false;
    }

    if (!cfg.controls.empty())
    {
        if (!apply_v4l2_controls(state.fd, cfg.controls, error))
        {
            close(state.fd);
            state.fd = -1;
            return false;
        }
    }

    FormatSupport support = classify_v4l2_format(fmt.fmt.pix.pixelformat);
    if (support.kind == FormatSupportKind::Unsupported)
    {
        error = "V4L2 format " + fourcc_to_string(fmt.fmt.pix.pixelformat) +
                " is exposed by the device but is not supported by this sender without conversion";
        close(state.fd);
        state.fd = -1;
        return false;
    }

    OMTCodec codec = {};
    V4L2ConversionMode conversionMode = V4L2ConversionMode::None;
    if (!determine_v4l2_output(fmt.fmt.pix.pixelformat, codec, conversionMode))
    {
        error = "V4L2 format " + fourcc_to_string(fmt.fmt.pix.pixelformat) +
                " is exposed by the device but is not supported by this sender without conversion";
        close(state.fd);
        state.fd = -1;
        return false;
    }

    state.pixelformat = fmt.fmt.pix.pixelformat;
    state.outputCodec = codec;
    state.conversionMode = conversionMode;
    state.inputStride = fmt.fmt.pix.bytesperline;
    state.inputFrameBytes = fmt.fmt.pix.sizeimage;
    if (state.inputFrameBytes == 0)
    {
        state.inputFrameBytes = state.inputStride * fmt.fmt.pix.height;
    }

    video_frame = {};
    video_frame.Type = OMTFrameType_Video;
    video_frame.Width = static_cast<int>(fmt.fmt.pix.width);
    video_frame.Height = static_cast<int>(fmt.fmt.pix.height);
    video_frame.Codec = codec;
    video_frame.Timestamp = -1;
    video_frame.ColorSpace = (video_frame.Height >= 720) ? OMTColorSpace_BT709 : OMTColorSpace_BT601;
    video_frame.Flags = OMTVideoFlags_None;
    video_frame.Stride = static_cast<int>(state.inputStride);
    video_frame.DataLength = static_cast<int>(state.inputFrameBytes);

    if (conversionMode != V4L2ConversionMode::None)
    {
        int bpp = bytes_per_pixel_for_omt(codec);
        if (bpp <= 0)
        {
            error = "No byte-size mapping for converted OMT codec";
            close(state.fd);
            state.fd = -1;
            return false;
        }
        video_frame.Stride = video_frame.Width * bpp;
        video_frame.DataLength = video_frame.Stride * video_frame.Height;
    }
    video_frame.Data = malloc(video_frame.DataLength);
    video_frame.FrameRateN = cfg.fps * 1000;
    video_frame.FrameRateD = 1000;
    video_frame.FrameMetadata = NULL;
    video_frame.FrameMetadataLength = 0;

    if (!video_frame.Data)
    {
        error = "malloc(video_frame.Data) failed";
        close(state.fd);
        state.fd = -1;
        return false;
    }

    v4l2_requestbuffers req = {};
    req.count = 4;
    req.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
    req.memory = V4L2_MEMORY_MMAP;

    if (xioctl(state.fd, VIDIOC_REQBUFS, &req) < 0)
    {
        error = "VIDIOC_REQBUFS failed: " + std::string(strerror(errno));
        free(video_frame.Data);
        video_frame.Data = nullptr;
        close(state.fd);
        state.fd = -1;
        return false;
    }

    if (req.count < 2)
    {
        error = "Not enough V4L2 buffers";
        free(video_frame.Data);
        video_frame.Data = nullptr;
        close(state.fd);
        state.fd = -1;
        return false;
    }

    state.buffers.resize(req.count);

    for (unsigned int i = 0; i < req.count; ++i)
    {
        v4l2_buffer buf = {};
        buf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
        buf.memory = V4L2_MEMORY_MMAP;
        buf.index = i;

        if (xioctl(state.fd, VIDIOC_QUERYBUF, &buf) < 0)
        {
            error = "VIDIOC_QUERYBUF failed: " + std::string(strerror(errno));
            return false;
        }

        state.buffers[i].length = buf.length;
        state.buffers[i].start = mmap(NULL, buf.length, PROT_READ | PROT_WRITE, MAP_SHARED, state.fd, buf.m.offset);
        if (state.buffers[i].start == MAP_FAILED)
        {
            state.buffers[i].start = nullptr;
            error = "mmap failed: " + std::string(strerror(errno));
            return false;
        }

        if (xioctl(state.fd, VIDIOC_QBUF, &buf) < 0)
        {
            error = "VIDIOC_QBUF failed: " + std::string(strerror(errno));
            return false;
        }
    }

    v4l2_buf_type type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
    if (xioctl(state.fd, VIDIOC_STREAMON, &type) < 0)
    {
        error = "VIDIOC_STREAMON failed: " + std::string(strerror(errno));
        return false;
    }

    std::ostringstream v4l2Line;
    v4l2Line << "[V4L cap.] Capturing "
             << video_frame.Width << "x" << video_frame.Height
             << " @" << std::fixed << std::setprecision(2) << static_cast<double>(cfg.fps) << "p "
             << fourcc_to_string(state.pixelformat)
             << " from " << cfg.device
             << " -> OMT " << support.target;
    if (state.conversionMode != V4L2ConversionMode::None)
    {
        v4l2Line << " (converted)";
    }
    std::cout << white_text(v4l2Line.str()) << "\n";
    return true;
}

static bool grab_v4l2_video_frame(OMTMediaFrame& video_frame, V4L2State& state, std::string& error)
{
    v4l2_buffer buf = {};
    buf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
    buf.memory = V4L2_MEMORY_MMAP;

    if (xioctl(state.fd, VIDIOC_DQBUF, &buf) < 0)
    {
        error = "VIDIOC_DQBUF failed: " + std::string(strerror(errno));
        return false;
    }

    const uint8_t* src = static_cast<const uint8_t*>(state.buffers[buf.index].start);
    if (state.conversionMode == V4L2ConversionMode::None)
    {
        size_t copySize = std::min(static_cast<size_t>(buf.bytesused), static_cast<size_t>(video_frame.DataLength));
        std::memcpy(video_frame.Data, src, copySize);
        if (copySize < static_cast<size_t>(video_frame.DataLength))
        {
            std::memset(static_cast<char*>(video_frame.Data) + copySize, 0, video_frame.DataLength - copySize);
        }
    }
    else
    {
        convert_v4l2_frame(src, state.inputStride, video_frame, state);
    }

    if (xioctl(state.fd, VIDIOC_QBUF, &buf) < 0)
    {
        error = "VIDIOC_QBUF failed: " + std::string(strerror(errno));
        return false;
    }

    return true;
}

static void shutdown_v4l2_video(V4L2State& state)
{
    if (state.fd >= 0)
    {
        v4l2_buf_type stopType = V4L2_BUF_TYPE_VIDEO_CAPTURE;
        xioctl(state.fd, VIDIOC_STREAMOFF, &stopType);
    }

    for (auto& buffer : state.buffers)
    {
        if (buffer.start)
        {
            munmap(buffer.start, buffer.length);
            buffer.start = nullptr;
            buffer.length = 0;
        }
    }
    state.buffers.clear();

    if (state.fd >= 0)
    {
        close(state.fd);
        state.fd = -1;
    }
}

static bool init_testcard_audio(const AudioConfig& cfg, int samplesPerChannel, OMTMediaFrame& audio_frame, TestcardAudioState& state, std::string& error)
{
    if (cfg.channels != 2)
    {
        error = "testcard audio currently expects 2 channels";
        return false;
    }

    audio_frame = {};
    audio_frame.Type = OMTFrameType_Audio;
    audio_frame.Timestamp = -1;
    audio_frame.Codec = OMTCodec_FPA1;
    audio_frame.SampleRate = cfg.rate;
    audio_frame.Channels = cfg.channels;
    audio_frame.SamplesPerChannel = samplesPerChannel;
    audio_frame.DataLength = samplesPerChannel * sizeof(float) * cfg.channels;
    audio_frame.FrameMetadata = NULL;
    audio_frame.FrameMetadataLength = 0;

    state.samples.resize(static_cast<size_t>(samplesPerChannel) * cfg.channels);
    state.gain = static_cast<float>(std::pow(10.0, cfg.volumeDb / 20.0));
    audio_frame.Data = state.samples.data();
    std::ostringstream tcAudio;
    tcAudio << "[Audio testcard] Using built-in noise, " << cfg.channels << " channel" << (cfg.channels == 1 ? "" : "s")
            << ", " << cfg.rate << " Hz, " << samplesPerChannel << " samples per frame, volume " << cfg.volumeDb << " dB.";
    std::cout << white_text(tcAudio.str()) << "\n";
    return true;
}

static bool grab_testcard_audio_frame(TestcardAudioState& state)
{
    for (size_t i = 0; i < state.samples.size(); ++i)
    {
        state.samples[i] = rand_FloatRange(-1.0f, +1.0f) * state.gain;
    }
    return true;
}

static bool init_alsa_audio(const AudioConfig& cfg, int samplesPerChannel, OMTMediaFrame& audio_frame, ALSAState& state, std::string& error)
{
    int rc = snd_pcm_open(&state.pcm, cfg.device.c_str(), SND_PCM_STREAM_CAPTURE, 0);
    if (rc < 0)
    {
        error = "snd_pcm_open failed for '" + cfg.device + "': " + snd_strerror(rc);
        return false;
    }

    snd_pcm_hw_params_t* hw = nullptr;
    snd_pcm_hw_params_malloc(&hw);
    snd_pcm_hw_params_any(state.pcm, hw);
    snd_pcm_hw_params_set_access(state.pcm, hw, SND_PCM_ACCESS_RW_INTERLEAVED);
    snd_pcm_hw_params_set_format(state.pcm, hw, SND_PCM_FORMAT_S16_LE);

    unsigned int rate = cfg.rate;
    snd_pcm_hw_params_set_rate_near(state.pcm, hw, &rate, 0);
    snd_pcm_hw_params_set_channels(state.pcm, hw, cfg.channels);

    snd_pcm_uframes_t period = samplesPerChannel;
    snd_pcm_hw_params_set_period_size_near(state.pcm, hw, &period, 0);

    rc = snd_pcm_hw_params(state.pcm, hw);
    snd_pcm_hw_params_free(hw);
    if (rc < 0)
    {
        error = "snd_pcm_hw_params failed: " + std::string(snd_strerror(rc));
        snd_pcm_close(state.pcm);
        state.pcm = nullptr;
        return false;
    }

    rc = snd_pcm_prepare(state.pcm);
    if (rc < 0)
    {
        error = "snd_pcm_prepare failed: " + std::string(snd_strerror(rc));
        snd_pcm_close(state.pcm);
        state.pcm = nullptr;
        return false;
    }

    state.interleaved.resize(static_cast<size_t>(samplesPerChannel) * cfg.channels);

    audio_frame = {};
    audio_frame.Type = OMTFrameType_Audio;
    audio_frame.Timestamp = -1;
    audio_frame.Codec = OMTCodec_FPA1;
    audio_frame.SampleRate = cfg.rate;
    audio_frame.Channels = cfg.channels;
    audio_frame.SamplesPerChannel = samplesPerChannel;
    audio_frame.DataLength = samplesPerChannel * sizeof(float) * cfg.channels;
    audio_frame.Data = malloc(audio_frame.DataLength);
    audio_frame.FrameMetadata = NULL;
    audio_frame.FrameMetadataLength = 0;

    if (!audio_frame.Data)
    {
        error = "malloc(audio_frame.Data) failed";
        snd_pcm_close(state.pcm);
        state.pcm = nullptr;
        return false;
    }

    const char* alsaName = snd_pcm_name(state.pcm);
    std::string pcmName = alsaName ? alsaName : cfg.device;
    std::cout << white_text("[ALSA cap.] Using device: " + pcmName) << "\n";

    std::ostringstream alsaCfg;
    alsaCfg << "ALSA capture configuration: "
            << cfg.channels << " channel" << (cfg.channels == 1 ? "" : "s")
            << ", 2 Bps, "
            << cfg.rate << " Hz, "
            << samplesPerChannel << " samples per frame.";
    std::cout << white_text(alsaCfg.str()) << "\n";
    return true;
}

static bool grab_alsa_audio_frame(const AudioConfig& cfg, OMTMediaFrame& audio_frame, ALSAState& state, std::string& error)
{
    int framesNeeded = audio_frame.SamplesPerChannel;
    int framesReadTotal = 0;

    while (framesReadTotal < framesNeeded)
    {
        int rc = snd_pcm_readi(state.pcm,
                               state.interleaved.data() + (framesReadTotal * cfg.channels),
                               framesNeeded - framesReadTotal);
        if (rc == -EPIPE)
        {
            snd_pcm_prepare(state.pcm);
            continue;
        }
        if (rc < 0)
        {
            error = "snd_pcm_readi failed: " + std::string(snd_strerror(rc));
            return false;
        }
        framesReadTotal += rc;
    }

    float gain = static_cast<float>(std::pow(10.0, cfg.volumeDb / 20.0));
    float* out = static_cast<float*>(audio_frame.Data);
    for (size_t i = 0; i < state.interleaved.size(); ++i)
    {
        out[i] = (static_cast<float>(state.interleaved[i]) / 32768.0f) * gain;
    }
    return true;
}

static void shutdown_alsa_audio(ALSAState& state)
{
    if (state.pcm)
    {
        snd_pcm_drop(state.pcm);
        snd_pcm_close(state.pcm);
        state.pcm = nullptr;
    }
    state.interleaved.clear();
}

static void print_audio_modules_help()
{
    std::cout << "audio modules:\n";
    std::cout << "  testcard  - built-in stereo noise generator\n";
    std::cout << "  alsa      - ALSA capture device\n";
    std::cout << "\n";
    std::cout << "details:\n";
    std::cout << "  -s testcard:help\n";
    std::cout << "  -s alsa:help\n";
}

static void print_testcard_audio_help()
{
    std::cout << "testcard audio module\n";
    std::cout << "  syntax:\n";
    std::cout << "    -s testcard[:volume=-20][:rate=48000][:channels=2]\n";
    std::cout << "\n";
    std::cout << "  note:\n";
    std::cout << "    if volume is omitted, the default is -20 dB\n";
}

static void print_alsa_help()
{
    std::cout << "alsa module\n";
    std::cout << "  syntax:\n";
    std::cout << "    -s alsa:hw:2,0\n";
    std::cout << "    -s alsa:device=hw:2,0[:volume=0][:rate=48000][:channels=2]\n";
    std::cout << "\n";
    std::cout << "  available capture PCM devices:\n";

    void** hints = nullptr;
    int rc = snd_device_name_hint(-1, "pcm", &hints);
    if (rc != 0 || !hints)
    {
        std::cout << "    (ALSA hints unavailable)\n";
        return;
    }

    bool any = false;
    for (void** p = hints; *p != nullptr; ++p)
    {
        char* name = snd_device_name_get_hint(*p, "NAME");
        char* desc = snd_device_name_get_hint(*p, "DESC");
        char* ioid = snd_device_name_get_hint(*p, "IOID");

        bool isInput = (!ioid || std::strcmp(ioid, "Input") == 0 || std::strcmp(ioid, "Duplex") == 0);
        if (name && isInput)
        {
            any = true;
            std::cout << "    " << name;
            if (desc)
            {
                std::string cleanDesc = desc;
                std::replace(cleanDesc.begin(), cleanDesc.end(), '\n', ' ');
                std::cout << " - " << cleanDesc;
            }
            std::cout << "\n";
        }

        if (name) free(name);
        if (desc) free(desc);
        if (ioid) free(ioid);
    }

    if (!any)
    {
        std::cout << "    (no capture devices found)\n";
    }

    snd_device_name_free_hint(hints);
}

static void print_usage(const char* argv0)
{
    std::cout
        << "Usage: " << argv0 << " [-t video_source] [-s audio_source]\n"
        << "\n"
        << "General help:\n"
        << "  " << argv0 << " -h\n"
        << "\n"
        << "Module help:\n"
        << "  " << argv0 << " -t help\n"
        << "  " << argv0 << " -t v4l2:help\n"
        << "  " << argv0 << " -s help\n"
        << "  " << argv0 << " -s alsa:help\n"
        << "\n"
        << "Examples:\n"
        << "  " << argv0 << " -t testcard\n"
        << "  " << argv0 << " -t testcard -s testcard\n"
        << "  " << argv0 << " -t v4l2:device=/dev/video0\n"
        << "  " << argv0 << " -t v4l2:device=/dev/video0:name=Cam1:format=YUY2 -s testcard\n"
        << "  " << argv0 << " -t v4l2:device=/dev/video0 -s alsa:hw:2,0\n"
        << "\n"
        << "Audio behavior:\n"
        << "  if -s is omitted, no audio is sent\n"
        << "  if -s testcard is used without volume, the default is -20 dB\n";
}

static bool wants_general_help(const std::string& arg)
{
    return arg == "help" || arg == "-h" || arg == "--help";
}

static bool maybe_handle_help(const char* argv0,
                              const std::string& videoSpec,
                              bool audioSpecified,
                              const std::string& audioSpec)
{
    if (!videoSpec.empty())
    {
        if (videoSpec == "help")
        {
            print_video_modules_help();
            return true;
        }

        ParsedSpec pv = parse_spec(videoSpec);
        if (pv.driver == "v4l2" && pv.kv.count("help"))
        {
            print_v4l2_help(get_string(pv.kv, "device", ""));
            return true;
        }
        if (pv.driver == "testcard" && pv.kv.count("help"))
        {
            print_testcard_video_help();
            return true;
        }
    }

    if (audioSpecified)
    {
        if (audioSpec == "help")
        {
            print_audio_modules_help();
            return true;
        }

        ParsedSpec pa = parse_spec(audioSpec);
        if (pa.driver == "alsa" && pa.kv.count("help"))
        {
            print_alsa_help();
            return true;
        }
        if (pa.driver == "testcard" && pa.kv.count("help"))
        {
            print_testcard_audio_help();
            return true;
        }
    }

    (void)argv0;
    return false;
}

int main(int argc, char* argv[])
{
    std::signal(SIGINT, handle_signal);
    std::signal(SIGTERM, handle_signal);
    std::srand(static_cast<unsigned int>(std::time(nullptr)));
    std::cout << yellow_text("OMTSNDCLI_V01") << "\n\n";

    std::string videoSpec = "testcard";
    std::string audioSpec;
    bool audioSpecified = false;

    for (int i = 1; i < argc; ++i)
    {
        std::string arg = argv[i];
        if (arg == "-t" && i + 1 < argc)
        {
            videoSpec = argv[++i];
        }
        else if (arg == "-s" && i + 1 < argc)
        {
            audioSpec = argv[++i];
            audioSpecified = true;
        }
        else if (arg == "-h" || arg == "--help")
        {
            print_usage(argv[0]);
            return 0;
        }
        else
        {
            std::cerr << "Unknown argument: " << arg << "\n";
            print_usage(argv[0]);
            return 1;
        }
    }

    if (maybe_handle_help(argv[0], videoSpec, audioSpecified, audioSpec))
    {
        return 0;
    }

    VideoConfig videoCfg;
    AudioConfig audioCfg;
    try
    {
        videoCfg = build_video_config(videoSpec);
        if (audioSpecified)
        {
            audioCfg = build_audio_config(audioSpec);
        }
        else
        {
            audioCfg.type = AudioSourceType::None;
        }
    }
    catch (const std::exception& ex)
    {
        std::cerr << ex.what() << "\n";
        return 1;
    }

    int audioRate = (audioCfg.type == AudioSourceType::None) ? 48000 : audioCfg.rate;
    int samplesPerChannel = std::max(1, static_cast<int>(std::llround(static_cast<double>(audioRate) / std::max(1, videoCfg.fps))));

    std::cout << yellow_text("Video source     : ") << videoSpec << "\n";
    if (audioSpecified)
    {
        std::cout << yellow_text("Audio source     : ") << audioSpec << "\n";
    }
    else
    {
        std::cout << yellow_text("Audio source     : ") << "disabled\n";
    }
    std::cout << yellow_text("Network protocol : ") << "OMT TCP\n";
    std::cout << yellow_text("Stream name      : ") << videoCfg.name << "\n";
    std::cout << yellow_text("OMT quality      : ")
              << quality_label_from_code(videoCfg.qualityCode)
              << " (enum " << videoCfg.qualityCode << ")\n";
    if (audioSpecified)
    {
        std::cout << yellow_text("Audio frame size : ")
                  << samplesPerChannel << " samples/channel\n";
    }
    std::cout << "\n";

    std::string filename = "omtsndcli_v01.log";
    omt_setloggingfilename(filename.c_str());
    std::cout << yellow_text("omt_setloggingfilename.success") << "\n";

    omt_send_t* snd = omt_send_create(videoCfg.name.c_str(), static_cast<OMTQuality>(videoCfg.qualityCode));
    if (!snd)
    {
        std::cerr << "omt_send_create.failed\n";
        return 1;
    }
    std::cout << yellow_text("omt_send_create.success") << "\n";

    OMTSenderInfo info = {};
    std::string productName = "OMTSNDCLI";
    std::string manufacturer = "OMT";
    std::string version = "0.1";
    productName.copy(&info.ProductName[0], OMT_MAX_STRING_LENGTH, 0);
    manufacturer.copy(&info.Manufacturer[0], OMT_MAX_STRING_LENGTH, 0);
    version.copy(&info.Version[0], OMT_MAX_STRING_LENGTH, 0);
    omt_send_setsenderinformation(snd, &info);
    std::cout << yellow_text("omt_send_setsenderinformation.success") << "\n";

    OMTMediaFrame video_frame = {};
    OMTMediaFrame audio_frame = {};
    V4L2State v4l2State;
    TestcardVideoState testcardVideo;
    ALSAState alsaState;
    TestcardAudioState testcardAudio;
    std::string error;

    bool ok = false;
    if (videoCfg.type == VideoSourceType::V4L2)
    {
        ok = init_v4l2_video(videoCfg, video_frame, v4l2State, error);
    }
    else
    {
        ok = init_testcard_video(videoCfg, video_frame, testcardVideo, error);
    }

    if (!ok)
    {
        std::cerr << error << "\n";
        omt_send_destroy(snd);
        return 1;
    }

    bool audioEnabled = (audioCfg.type != AudioSourceType::None);
    if (audioEnabled)
    {
        ok = false;
        error.clear();
        if (audioCfg.type == AudioSourceType::ALSA)
        {
            ok = init_alsa_audio(audioCfg, samplesPerChannel, audio_frame, alsaState, error);
        }
        else
        {
            ok = init_testcard_audio(audioCfg, samplesPerChannel, audio_frame, testcardAudio, error);
        }

        if (!ok)
        {
            std::cerr << error << "\n";
            if (videoCfg.type == VideoSourceType::V4L2)
            {
                shutdown_v4l2_video(v4l2State);
            }
            if (video_frame.Data)
            {
                free(video_frame.Data);
            }
            omt_send_destroy(snd);
            return 1;
        }
    }


    OMTTally tally = {};
    OMTStatistics stats = {};
    int maxFrames = 1000000000;

    const auto appStart = std::chrono::steady_clock::now();
    auto intervalStart = appStart;
    uint64_t intervalVideoFrames = 0;
    uint64_t intervalVideoBytes = 0;
    uint64_t intervalAudioSamplesPerChannel = 0;
    uint64_t intervalCapturedFrames = 0;
    uint64_t intervalSentFrames = 0;
    uint64_t intervalDroppedFrames = 0;
    uint64_t intervalLateFrames = 0;
    double intervalSendTimeSumMs = 0.0;
    double intervalSendTimeMaxMs = 0.0;

    auto healthStart = appStart;
    uint64_t healthCapturedFrames = 0;
    uint64_t healthSentFrames = 0;
    uint64_t healthDroppedFrames = 0;
    uint64_t healthLateFrames = 0;
    double healthSendTimeSumMs = 0.0;
    double healthSendTimeMaxMs = 0.0;
    std::vector<double> intervalAudioSumSquares(static_cast<size_t>(std::max(1, audioEnabled ? audio_frame.Channels : 1)), 0.0);
    std::vector<double> intervalAudioPeaks(static_cast<size_t>(std::max(1, audioEnabled ? audio_frame.Channels : 1)), 0.0);
    std::deque<RollingInterval> rollingIntervals;

    for (int i = 0; i < maxFrames && !g_stop_requested; ++i)
    {
        bool videoGrabbed = false;
        error.clear();
        if (videoCfg.type == VideoSourceType::V4L2)
        {
            videoGrabbed = grab_v4l2_video_frame(video_frame, v4l2State, error);
        }
        else
        {
            videoGrabbed = grab_testcard_video_frame(video_frame, testcardVideo);
        }

        if (!videoGrabbed)
        {
            std::cerr << error << "\n";
            break;
        }

        intervalCapturedFrames += 1;
        healthCapturedFrames += 1;

        auto sendStart = std::chrono::steady_clock::now();
        int sentVideoBytes = omt_send(snd, &video_frame);
        auto sendEnd = std::chrono::steady_clock::now();
        double sendMs = std::chrono::duration<double, std::milli>(sendEnd - sendStart).count();
        intervalSendTimeSumMs += sendMs;
        intervalSendTimeMaxMs = std::max(intervalSendTimeMaxMs, sendMs);
        healthSendTimeSumMs += sendMs;
        healthSendTimeMaxMs = std::max(healthSendTimeMaxMs, sendMs);

        if (sentVideoBytes >= 0)
        {
            intervalSentFrames += 1;
            healthSentFrames += 1;
            if (sentVideoBytes > 0)
            {
                intervalVideoBytes += static_cast<uint64_t>(sentVideoBytes);
            }
        }
        else
        {
            intervalDroppedFrames += 1;
            healthDroppedFrames += 1;
        }

        double frameBudgetMs = 1000.0 / static_cast<double>(std::max(1, videoCfg.fps));
        if (sendMs > frameBudgetMs)
        {
            intervalLateFrames += 1;
            healthLateFrames += 1;
        }

        intervalVideoFrames += 1;

        if (audioEnabled)
        {
            bool audioGrabbed = false;
            error.clear();
            if (audioCfg.type == AudioSourceType::ALSA)
            {
                audioGrabbed = grab_alsa_audio_frame(audioCfg, audio_frame, alsaState, error);
            }
            else
            {
                audioGrabbed = grab_testcard_audio_frame(testcardAudio);
            }

            if (!audioGrabbed)
            {
                std::cerr << error << "\n";
                break;
            }

            accumulate_audio_levels(audio_frame, intervalAudioSumSquares, intervalAudioPeaks);
            intervalAudioSamplesPerChannel += static_cast<uint64_t>(audio_frame.SamplesPerChannel);
            omt_send(snd, &audio_frame);
        }

        auto now = std::chrono::steady_clock::now();
        double elapsed = std::chrono::duration<double>(now - intervalStart).count();
        if (elapsed >= 5.0)
        {
            omt_send_gettally(snd, 0, &tally);
            int connections = omt_send_connections(snd);
            omt_send_getvideostatistics(snd, &stats);

            double fps = (elapsed > 0.0) ? (static_cast<double>(intervalVideoFrames) / elapsed) : 0.0;
            double bitrateMbit = (elapsed > 0.0) ? (static_cast<double>(intervalVideoBytes) * 8.0 / elapsed / 1000000.0) : 0.0;

            if (audioEnabled)
            {
                std::cout << yellow_text("[Audio sender] Sent ")
                          << intervalAudioSamplesPerChannel
                          << yellow_text(" samples in last ")
                          << format_decimal(elapsed, 2)
                          << yellow_text(" seconds.") << "\n";
                std::cout << audio_levels_line(intervalAudioSumSquares, intervalAudioPeaks, intervalAudioSamplesPerChannel) << "\n";
            }

            std::ostringstream videoLine;
            videoLine << (videoCfg.type == VideoSourceType::V4L2 ? "[V4L2 capture] " : "[Testcard video] ")
                      << intervalVideoFrames << " frames in "
                      << std::fixed << std::setprecision(5) << elapsed << " seconds = "
                      << std::fixed << std::setprecision(4) << fps << " FPS"
                      << ", bitrate = ";
            std::cout << yellow_text(videoLine.str())
                      << cyan_text(format_decimal(bitrateMbit, 3) + " Mbit/s") << "\n";

            std::ostringstream omtLine;
            omtLine << "[OMT sender] connections=" << connections
                    << " tally=" << tally.preview << "/" << tally.program
                    << " totalBytes=" << stats.BytesSent
                    << " totalFrames=" << stats.Frames;
            std::cout << yellow_text(omtLine.str()) << "\n";

            rollingIntervals.push_back({now, elapsed, intervalVideoFrames, intervalVideoBytes, intervalAudioSamplesPerChannel, intervalCapturedFrames, intervalSentFrames, intervalDroppedFrames, intervalLateFrames, intervalSendTimeSumMs, intervalSendTimeMaxMs});
            trim_rolling_intervals(rollingIntervals, now);

            double healthElapsed = std::chrono::duration<double>(now - healthStart).count();
            if (healthElapsed >= 60.0)
            {
                double avgHealthSendMs = healthSentFrames > 0 ? (healthSendTimeSumMs / static_cast<double>(healthSentFrames)) : 0.0;
                std::cout << sender_health_line(healthCapturedFrames,
                                                healthSentFrames,
                                                healthDroppedFrames,
                                                healthLateFrames,
                                                avgHealthSendMs,
                                                healthSendTimeMaxMs) << "\n";

                healthStart = now;
                healthCapturedFrames = 0;
                healthSentFrames = 0;
                healthDroppedFrames = 0;
                healthLateFrames = 0;
                healthSendTimeSumMs = 0.0;
                healthSendTimeMaxMs = 0.0;
            }

            intervalStart = now;
            intervalVideoFrames = 0;
            intervalVideoBytes = 0;
            intervalAudioSamplesPerChannel = 0;
            intervalCapturedFrames = 0;
            intervalSentFrames = 0;
            intervalDroppedFrames = 0;
            intervalLateFrames = 0;
            intervalSendTimeSumMs = 0.0;
            intervalSendTimeMaxMs = 0.0;
            std::fill(intervalAudioSumSquares.begin(), intervalAudioSumSquares.end(), 0.0);
            std::fill(intervalAudioPeaks.begin(), intervalAudioPeaks.end(), 0.0);
        }
    }

    if (g_stop_requested)
    {
        std::cout << "\n" << yellow_text("Stopping on signal.") << "\n";
    }

    if (audioCfg.type == AudioSourceType::ALSA)
    {
        shutdown_alsa_audio(alsaState);
    }
    if (videoCfg.type == VideoSourceType::V4L2)
    {
        shutdown_v4l2_video(v4l2State);
    }

    if (video_frame.Data)
    {
        free(video_frame.Data);
        video_frame.Data = nullptr;
    }
    if (audioCfg.type == AudioSourceType::ALSA && audio_frame.Data)
    {
        free(audio_frame.Data);
        audio_frame.Data = nullptr;
    }

    print_exit_summary(rollingIntervals, audioEnabled);
    omt_send_destroy(snd);
    std::cout << yellow_text("omt_send_destroy.success") << "\n";
    return 0;
}