dmf-studio-rnd/nodes/testpattern/main.cpp

#include <cmath>
#include <numbers>
#include <string>
#include <mxl/flow.h>
#include <mxl/time.h>
#include "NodeBase.hpp"
#include "FlowDef.hpp"
#include "V210.hpp"

class TestPatternNode : public dmf::NodeBase {
    void run() override {
        // --- video flow ---
        const auto flow_info = config().at("flow_id");
        const auto flow_id   = flow_info.at("id").get<std::string>();
        const int  width     = flow_info.value("width",   1920);
        const int  height    = flow_info.value("height",  1080);
        const int  fps_num   = flow_info.value("fps_num", 25);
        const int  fps_den   = flow_info.value("fps_den", 1);
        const auto pattern   = config().value("pattern", "bars");

        log("flow=%s  %dx%d @ %d/%d fps  pattern=%s",
            flow_id.c_str(), width, height, fps_num, fps_den, pattern.c_str());

        mxlFlowWriter     video_writer{};
        mxlFlowConfigInfo video_cfg{};
        bool created = false;
        mxlStatus vst = mxlCreateFlowWriter(
            instance(),
            dmf::make_video_flow_def(flow_id, node_id(), width, height, fps_num, fps_den).c_str(),
            nullptr, &video_writer, &video_cfg, &created);
        if (vst != MXL_STATUS_OK) { log("video mxlCreateFlowWriter failed (%s)", dmf::mxl_status_str(vst)); return; }

        const uint32_t video_stride = video_cfg.discrete.sliceSizes[0];
        log("video stride=%u B/line  grain=%u B  ring=%u grains",
            video_stride, video_stride * static_cast<uint32_t>(height), video_cfg.discrete.grainCount);

        // --- audio flow (optional) ---
        mxlFlowWriter     audio_writer{};
        mxlFlowConfigInfo audio_cfg{};
        int  sample_rate   = 48000;
        int  channels      = 2;
        bool has_audio     = config().contains("audio_flow_id");

        if (has_audio) {
            const auto audio_flow_info = config().at("audio_flow_id");
            const auto audio_flow_id   = audio_flow_info.at("id").get<std::string>();
            sample_rate = audio_flow_info.value("sample_rate", 48000);
            channels    = audio_flow_info.value("channels", 2);

            log("audio flow=%s  %d Hz  %dch", audio_flow_id.c_str(), sample_rate, channels);

            mxlStatus ast = mxlCreateFlowWriter(
                instance(),
                dmf::make_audio_flow_def(audio_flow_id, node_id(), sample_rate, channels, 32,
                                         fps_num, fps_den).c_str(),
                nullptr, &audio_writer, &audio_cfg, &created);
            if (ast != MXL_STATUS_OK) {
                log("audio mxlCreateFlowWriter failed (%s) — continuing without audio", dmf::mxl_status_str(ast));
                has_audio = false;
            } else {
                log("audio channels=%u  buffer=%u samples",
                    audio_cfg.continuous.channelCount, audio_cfg.continuous.bufferLength);
            }
        }

        // --- main loop ---
        const mxlRational video_rate = {fps_num, fps_den};
        const size_t      samples_per_frame =
            static_cast<size_t>(sample_rate) * static_cast<size_t>(fps_den) / static_cast<size_t>(fps_num);

        // -18 dBFS broadcast reference level
        const float amplitude = static_cast<float>(std::pow(10.0, -18.0 / 20.0));

        uint64_t video_index = mxlGetCurrentIndex(&video_rate);
        uint64_t audio_index = 0;
        if (has_audio) {
            const mxlRational audio_rate = {sample_rate, 1};
            audio_index = mxlGetCurrentIndex(&audio_rate);
        }
        log("start video_index=%llu", video_index);

        while (dmf::g_running.load(std::memory_order_relaxed)) {
            // --- video grain ---
            mxlGrainInfo video_grain{};
            uint8_t*     video_buf = nullptr;
            vst = mxlFlowWriterOpenGrain(video_writer, video_index, &video_grain, &video_buf);
            if (vst != MXL_STATUS_OK) {
                log("OpenGrain failed (%s) at index=%llu", dmf::mxl_status_str(vst), video_index);
                video_index++;
                continue;
            }

            if      (pattern == "bars")  dmf::v210::fill_colorbars(video_buf, width, height, video_stride);
            else if (pattern == "ire")   dmf::v210::fill_ire_ramp (video_buf, width, height, video_stride);
            else if (pattern == "black") dmf::v210::fill_black     (video_buf, width, height, video_stride);
            else if (pattern == "white") dmf::v210::fill_white     (video_buf, width, height, video_stride);
            else                         dmf::v210::fill_colorbars (video_buf, width, height, video_stride);
            video_grain.flags       = 0;
            video_grain.validSlices = video_grain.totalSlices;
            mxlFlowWriterCommitGrain(video_writer, &video_grain);

            // --- audio: sine tones, channel c = (c+1) * 1000 Hz ---
            if (has_audio) {
                mxlMutableWrappedMultiBufferSlice slice{};
                if (mxlFlowWriterOpenSamples(audio_writer, audio_index,
                                             samples_per_frame, &slice) == MXL_STATUS_OK) {
                    const size_t frag0 = slice.base.fragments[0].size / sizeof(float);
                    const size_t frag1 = slice.base.fragments[1].size / sizeof(float);
                    for (int c = 0; c < channels; ++c) {
                        const double freq   = 1000.0 * (c + 1);
                        const double period = static_cast<double>(sample_rate) / freq;
                        auto write_samples = [&](float* dst, size_t count, size_t offset) {
                            for (size_t s = 0; s < count; ++s)
                                dst[s] = amplitude * static_cast<float>(
                                    std::sin(2.0 * std::numbers::pi * (audio_index + offset + s) / period));
                        };
                        auto* dst0 = reinterpret_cast<float*>(
                            static_cast<uint8_t*>(slice.base.fragments[0].pointer) + c * slice.stride);
                        write_samples(dst0, frag0, 0);
                        if (frag1 > 0) {
                            auto* dst1 = reinterpret_cast<float*>(
                                static_cast<uint8_t*>(slice.base.fragments[1].pointer) + c * slice.stride);
                            write_samples(dst1, frag1, frag0);
                        }
                    }
                    mxlFlowWriterCommitSamples(audio_writer);
                }
                audio_index += samples_per_frame;
            }

            const uint64_t ns = mxlGetNsUntilIndex(video_index + 1, &video_rate);
            if (ns > 0 && ns < 2'000'000'000ULL) mxlSleepForNs(ns);
            video_index++;
        }

        log("stopped at video_index=%llu", video_index);
        mxlReleaseFlowWriter(instance(), video_writer);
        if (has_audio) mxlReleaseFlowWriter(instance(), audio_writer);
    }
};

int main() {
    TestPatternNode node;
    return node.execute();
}