mxvk::anonymous_namespace{mxvk_ff_capture.cpp} Namespace Reference

Functions
bool	convertBt2020Yuv10LimitedToRgba16 (const AVFrame *source, std::vector< uint16_t > &rgba, int &width, int &height, int &pitch, bool flipY)
double	rationalToDouble (AVRational rational)

Function Documentation

convertBt2020Yuv10LimitedToRgba16()

bool mxvk::anonymous_namespace{mxvk_ff_capture.cpp}::convertBt2020Yuv10LimitedToRgba16 ( const AVFrame * source, std::vector< uint16_t > & rgba, int & width, int & height, int & pitch, bool flipY )

nodiscard

Definition at line 31 of file mxvk_ff_capture.cpp.

                                                                                                                                                                {
            if (source == nullptr || source->data[0] == nullptr || source->data[1] == nullptr) {
                return false;
            }
            const bool p010 = source->format == AV_PIX_FMT_P010LE;
            if (!p010 && (source->format != AV_PIX_FMT_YUV420P10LE || source->data[2] == nullptr)) {
                return false;
            }
 
            width = source->width;
            height = source->height;
            pitch = width * 8;
            if (width <= 0 || height <= 0) {
                return false;
            }
            rgba.resize(static_cast<size_t>(width) * static_cast<size_t>(height) * 4U);
 
            const int sampleShift = p010 ? 6 : 0;
            const auto sample10 = [sampleShift](const uint8_t *plane, int stride, int x, int y) {
                uint16_t raw = 0;
                std::memcpy(&raw, plane + static_cast<size_t>(y) * stride + static_cast<size_t>(x) * 2U, sizeof(raw));
                return static_cast<int>(raw >> sampleShift);
            };
 
            constexpr float CR_R = 1.4746F;
            constexpr float CB_G = -0.16455312684366F;
            constexpr float CR_G = -0.57135313725490F;
            constexpr float CB_B = 1.8814F;
            constexpr float INV_Y = 1.0F / 876.0F;
            constexpr float INV_C = 1.0F / 896.0F;
 
            for (int y = 0; y < height; ++y) {
                uint16_t *destination = rgba.data() + static_cast<size_t>(y) * width * 4U;
                const int chromaY = y >> 1;
                for (int x = 0; x < width; ++x) {
                    const int chromaX = x >> 1;
                    const int ySample = sample10(source->data[0], source->linesize[0], x, y);
                    int cbSample = 0;
                    int crSample = 0;
                    if (p010) {
                        cbSample = sample10(source->data[1], source->linesize[1], chromaX * 2, chromaY);
                        crSample = sample10(source->data[1], source->linesize[1], chromaX * 2 + 1, chromaY);
                    } else {
                        cbSample = sample10(source->data[1], source->linesize[1], chromaX, chromaY);
                        crSample = sample10(source->data[2], source->linesize[2], chromaX, chromaY);
                    }
 
                    const float yValue = (ySample - 64) * INV_Y;
                    const float cb = (cbSample - 512) * INV_C;
                    const float cr = (crSample - 512) * INV_C;
                    const float red = std::clamp(yValue + CR_R * cr, 0.0F, 1.0F);
                    const float green = std::clamp(yValue + CB_G * cb + CR_G * cr, 0.0F, 1.0F);
                    const float blue = std::clamp(yValue + CB_B * cb, 0.0F, 1.0F);
 
                    destination[x * 4 + 0] = static_cast<uint16_t>(red * 65535.0F + 0.5F);
                    destination[x * 4 + 1] = static_cast<uint16_t>(green * 65535.0F + 0.5F);
                    destination[x * 4 + 2] = static_cast<uint16_t>(blue * 65535.0F + 0.5F);
                    destination[x * 4 + 3] = UINT16_MAX;
                }
            }
 
            if (flipY) {
                std::vector<uint16_t> row(static_cast<size_t>(width) * 4U);
                for (int y = 0; y < height / 2; ++y) {
                    uint16_t *top = rgba.data() + static_cast<size_t>(y) * width * 4U;
                    uint16_t *bottom = rgba.data() + static_cast<size_t>(height - 1 - y) * width * 4U;
                    std::copy_n(top, row.size(), row.data());
                    std::copy_n(bottom, row.size(), top);
                    std::copy_n(row.data(), row.size(), bottom);
                }
            }
            return true;
        }

rationalToDouble()

double mxvk::anonymous_namespace{mxvk_ff_capture.cpp}::rationalToDouble ( AVRational rational )

nodiscard

Definition at line 24 of file mxvk_ff_capture.cpp.

                                                                   {
            if (rational.num <= 0 || rational.den <= 0) {
                return 0.0;
            }
            return av_q2d(rational);
        }