anonymous_namespace{mxwrite.cpp} Namespace Reference

Functions
uint16_t	clamp10 (float v)
void	convertBt2020Rgba16EncodedToYuv420p10 (const uint16_t *rgba, int src_stride_shorts, uint16_t *y_plane, int y_stride_shorts, uint16_t *u_plane, int u_stride_shorts, uint16_t *v_plane, int v_stride_shorts, int width, int height)
void	convertRgbaToBt2020PqYuv420p10 (const uint8_t *rgba, int src_stride_bytes, uint16_t *y_plane, int y_stride_shorts, uint16_t *u_plane, int u_stride_shorts, uint16_t *v_plane, int v_stride_shorts, int width, int height)
bool	is_valid_x264_preset (const std::string &p)
std::string	lowercase_ascii (std::string text)
float	pqOetf (float L)
float	srgbEotf (float v)
const char *	x264_preset_to_nvenc (const std::string &p)

Variables
constexpr float	kPqC1 = 3424.0f / 4096.0f
constexpr float	kPqC2 = (2413.0f / 4096.0f) * 32.0f
constexpr float	kPqC3 = (2392.0f / 4096.0f) * 32.0f
constexpr float	kPqM1 = 2610.0f / 16384.0f
constexpr float	kPqM2 = (2523.0f / 4096.0f) * 128.0f
constexpr float	kSdrRefFraction = 100.0f / 10000.0f

Function Documentation

clamp10()

uint16_t anonymous_namespace{mxwrite.cpp}::clamp10 ( float v )

inline

Definition at line 50 of file mxwrite.cpp.

                                 {
    if (v < 0.0f) v = 0.0f;
    if (v > 1023.0f) v = 1023.0f;
    return static_cast<uint16_t>(v + 0.5f);
}

convertBt2020Rgba16EncodedToYuv420p10()

void anonymous_namespace{mxwrite.cpp}::convertBt2020Rgba16EncodedToYuv420p10	(	const uint16_t *	rgba,
		int	src_stride_shorts,
		uint16_t *	y_plane,
		int	y_stride_shorts,
		uint16_t *	u_plane,
		int	u_stride_shorts,
		uint16_t *	v_plane,
		int	v_stride_shorts,
		int	width,
		int	height )

Definition at line 139 of file mxwrite.cpp.

                                                                  {
    constexpr float kKr = 0.2627f;
    constexpr float kKg = 0.6780f;
    constexpr float kKb = 0.0593f;
    constexpr float kPbDiv = 1.0f / 1.8814f;
    constexpr float kPrDiv = 1.0f / 1.4746f;
    constexpr float kInv65535 = 1.0f / 65535.0f;
 
    for (int y = 0; y < height; y += 2) {
        const int y1 = std::min(y + 1, height - 1);
        const uint16_t *row0 = rgba + y  * src_stride_shorts;
        const uint16_t *row1 = rgba + y1 * src_stride_shorts;
        uint16_t *yr0 = y_plane + y  * y_stride_shorts;
        uint16_t *yr1 = y_plane + y1 * y_stride_shorts;
        uint16_t *ur  = u_plane + (y / 2) * u_stride_shorts;
        uint16_t *vr  = v_plane + (y / 2) * v_stride_shorts;
 
        for (int x = 0; x < width; x += 2) {
            const int x1 = std::min(x + 1, width - 1);
 
            auto load = [&](const uint16_t *px, float &Y, float &U, float &V) {
                const float rp = px[0] * kInv65535;
                const float gp = px[1] * kInv65535;
                const float bp = px[2] * kInv65535;
                Y = kKr * rp + kKg * gp + kKb * bp;
                U = (bp - Y) * kPbDiv;
                V = (rp - Y) * kPrDiv;
            };
 
            float Y00, U00, V00;
            float Y01, U01, V01;
            float Y10, U10, V10;
            float Y11, U11, V11;
            load(row0 + x  * 4, Y00, U00, V00);
            load(row0 + x1 * 4, Y01, U01, V01);
            load(row1 + x  * 4, Y10, U10, V10);
            load(row1 + x1 * 4, Y11, U11, V11);
 
            yr0[x]  = clamp10(Y00 * 876.0f + 64.0f);
            yr0[x1] = clamp10(Y01 * 876.0f + 64.0f);
            yr1[x]  = clamp10(Y10 * 876.0f + 64.0f);
            yr1[x1] = clamp10(Y11 * 876.0f + 64.0f);
 
            const float Uavg = 0.25f * (U00 + U01 + U10 + U11);
            const float Vavg = 0.25f * (V00 + V01 + V10 + V11);
            ur[x / 2] = clamp10(Uavg * 896.0f + 512.0f);
            vr[x / 2] = clamp10(Vavg * 896.0f + 512.0f);
        }
    }
}

convertRgbaToBt2020PqYuv420p10()

void anonymous_namespace{mxwrite.cpp}::convertRgbaToBt2020PqYuv420p10	(	const uint8_t *	rgba,
		int	src_stride_bytes,
		uint16_t *	y_plane,
		int	y_stride_shorts,
		uint16_t *	u_plane,
		int	u_stride_shorts,
		uint16_t *	v_plane,
		int	v_stride_shorts,
		int	width,
		int	height )

Definition at line 60 of file mxwrite.cpp.

                                                           {
    // BT.2020 non-constant luminance RGB->YUV (limited range).
    // E'Y = 0.2627*R + 0.6780*G + 0.0593*B
    // E'Pb = (B - Y) / 1.8814
    // E'Pr = (R - Y) / 1.4746
    // Limited 10-bit: Y: 0..1 -> 64..940 (range 876), UV: -0.5..0.5 -> 64..960 (range 896, center 512).
    constexpr float kKr = 0.2627f;
    constexpr float kKg = 0.6780f;
    constexpr float kKb = 0.0593f;
    constexpr float kPbDiv = 1.0f / 1.8814f;
    constexpr float kPrDiv = 1.0f / 1.4746f;
 
    for (int y = 0; y < height; y += 2) {
        const int y1 = std::min(y + 1, height - 1);
        const uint8_t *row0 = rgba + y  * src_stride_bytes;
        const uint8_t *row1 = rgba + y1 * src_stride_bytes;
        uint16_t *yr0 = y_plane + y  * y_stride_shorts;
        uint16_t *yr1 = y_plane + y1 * y_stride_shorts;
        uint16_t *ur  = u_plane + (y / 2) * u_stride_shorts;
        uint16_t *vr  = v_plane + (y / 2) * v_stride_shorts;
 
        for (int x = 0; x < width; x += 2) {
            const int x1 = std::min(x + 1, width - 1);
 
            // Load 2x2 block of sRGB 8-bit pixels.
            auto loadPq = [](const uint8_t *px,
                             float &Y, float &U, float &V) {
                // sRGB 8-bit -> linear [0,1]
                const float r = srgbEotf(px[0] * (1.0f / 255.0f));
                const float g = srgbEotf(px[1] * (1.0f / 255.0f));
                const float b = srgbEotf(px[2] * (1.0f / 255.0f));
                // Scale SDR linear [0,1] (reference 100 nits) to PQ fractional.
                const float rL = r * kSdrRefFraction;
                const float gL = g * kSdrRefFraction;
                const float bL = b * kSdrRefFraction;
                // PQ encode per channel (RGB PQ).
                const float rp = pqOetf(rL);
                const float gp = pqOetf(gL);
                const float bp = pqOetf(bL);
                // BT.2020 RGB' -> YUV'.
                Y = kKr * rp + kKg * gp + kKb * bp;
                U = (bp - Y) * kPbDiv;
                V = (rp - Y) * kPrDiv;
            };
 
            float Y00, U00, V00;
            float Y01, U01, V01;
            float Y10, U10, V10;
            float Y11, U11, V11;
            loadPq(row0 + x  * 4, Y00, U00, V00);
            loadPq(row0 + x1 * 4, Y01, U01, V01);
            loadPq(row1 + x  * 4, Y10, U10, V10);
            loadPq(row1 + x1 * 4, Y11, U11, V11);
 
            // Y: per-pixel, limited-range 10-bit.
            yr0[x]  = clamp10(Y00 * 876.0f + 64.0f);
            yr0[x1] = clamp10(Y01 * 876.0f + 64.0f);
            yr1[x]  = clamp10(Y10 * 876.0f + 64.0f);
            yr1[x1] = clamp10(Y11 * 876.0f + 64.0f);
 
            // UV: 4:2:0 average of 2x2 block.
            const float Uavg = 0.25f * (U00 + U01 + U10 + U11);
            const float Vavg = 0.25f * (V00 + V01 + V10 + V11);
            ur[x / 2] = clamp10(Uavg * 896.0f + 512.0f);
            vr[x / 2] = clamp10(Vavg * 896.0f + 512.0f);
        }
    }
}

is_valid_x264_preset()

bool anonymous_namespace{mxwrite.cpp}::is_valid_x264_preset

(

const std::string &

p

)

Definition at line 455 of file mxwrite.cpp.

                                              {
    static const char *presets[] = {
        "ultrafast","superfast","veryfast","faster","fast",
        "medium","slow","slower","veryslow","placebo"
    };
    for (const char *n : presets) if (p == n) return true;
    return false;
}

lowercase_ascii()

std::string anonymous_namespace{mxwrite.cpp}::lowercase_ascii

(

std::string

text

)

Definition at line 464 of file mxwrite.cpp.

                                          {
    std::transform(text.begin(), text.end(), text.begin(), [](unsigned char ch) {
        return static_cast<char>(std::tolower(ch));
    });
    return text;
}

pqOetf()

float anonymous_namespace{mxwrite.cpp}::pqOetf ( float L )

inline

Definition at line 42 of file mxwrite.cpp.

                             {
    // L in [0,1] where 1.0 == 10000 nits; returns PQ code value in [0,1].
    const float Lm = std::pow(std::max(0.0f, L), kPqM1);
    const float num = kPqC1 + kPqC2 * Lm;
    const float den = 1.0f + kPqC3 * Lm;
    return std::pow(num / den, kPqM2);
}

srgbEotf()

float anonymous_namespace{mxwrite.cpp}::srgbEotf ( float v )

inline

Definition at line 36 of file mxwrite.cpp.

                               {
    // sRGB non-linear -> linear light.
    return (v <= 0.04045f) ? (v / 12.92f)
                           : std::pow((v + 0.055f) / 1.055f, 2.4f);
}

x264_preset_to_nvenc()

const char * anonymous_namespace{mxwrite.cpp}::x264_preset_to_nvenc

(

const std::string &

p

)

Definition at line 443 of file mxwrite.cpp.

                                                     {
    if (p == "ultrafast") return "p1";
    if (p == "superfast") return "p2";
    if (p == "veryfast" || p == "faster") return "p3";
    if (p == "fast") return "p4";
    if (p == "medium" || p.empty()) return "p5";
    if (p == "slow" || p == "slower") return "p6";
    if (p == "veryslow") return "p7";
    // Allow passing NVENC preset names through directly.
    return p.c_str();
}

Variable Documentation

kPqC1

float anonymous_namespace{mxwrite.cpp}::kPqC1 = 3424.0f / 4096.0f

constexpr

Definition at line 30 of file mxwrite.cpp.

kPqC2

float anonymous_namespace{mxwrite.cpp}::kPqC2 = (2413.0f / 4096.0f) * 32.0f

constexpr

Definition at line 31 of file mxwrite.cpp.

kPqC3

float anonymous_namespace{mxwrite.cpp}::kPqC3 = (2392.0f / 4096.0f) * 32.0f

constexpr

Definition at line 32 of file mxwrite.cpp.

kPqM1

float anonymous_namespace{mxwrite.cpp}::kPqM1 = 2610.0f / 16384.0f

constexpr

Definition at line 28 of file mxwrite.cpp.

kPqM2

float anonymous_namespace{mxwrite.cpp}::kPqM2 = (2523.0f / 4096.0f) * 128.0f

constexpr

Definition at line 29 of file mxwrite.cpp.

kSdrRefFraction

float anonymous_namespace{mxwrite.cpp}::kSdrRefFraction = 100.0f / 10000.0f

constexpr

Definition at line 34 of file mxwrite.cpp.