Method run

test/speed/ImageProcessSpeedTest.cpp:634–709

public:
    virtual ~ImageProcessSpeedNV21ToRGBTest() = default;
    virtual bool run(int precision) {
        ImageProcess::Config config;
        config.sourceFormat = YUV_NV21;
        config.destFormat   = RGB;
        config.filterType   = NEAREST;
        config.wrap         = CLAMP_TO_EDGE;
        std::shared_ptr<ImageProcess> process(ImageProcess::create(config));

        int sw = 1920;
        int sh = 1080;
        Matrix tr;
        process->setMatrix(tr);
        std::shared_ptr<unsigned char> nv12(new unsigned char[sw * sh + (sw / 2) * (sh / 2) * 2]);
        auto pixels = nv12.get();
        for (int y = 0; y < sh; ++y) {
            auto pixelY  = pixels + sw * y;
            auto pixelUV = pixels + sw * sh + (y / 2) * sw;
            int magicY   = ((sh - y) * (sh - y)) % 79;
            for (int x = 0; x < sw; ++x) {
                auto pixelX = pixelY + x;
                int magicX  = (x * x) % 113;
                int magic   = (magicX + magicY) % 255;
                pixelX[0]   = magic;
            }
            for (int x = 0; x < sw / 2; ++x) {
                auto pixelX = pixelUV + 2 * x;
                int magicX  = ((((x % 283) * (x % 283)) % 283) * (((x % 283) * (x % 283)) % 283)) % 283;
                int magic0  = (magicX + magicY) % 255;
                int magic1  = (magicX + magicY * 179) % 255;
                pixelX[0]   = magic0;
                pixelX[1]   = magic1;
            }
        }

        std::shared_ptr<Tensor> tensor(
            Tensor::create<uint8_t>(std::vector<int>{1, sh, sw, 3}, nullptr, Tensor::TENSORFLOW));
        process->convert(nv12.get(), sw, sh, 0, tensor.get());
        for (int y = 0; y < sh; ++y) {
            auto dstY    = tensor->host<uint8_t>() + 3 * y * sw;
            auto srcY_Y  = nv12.get() + y * sw;
            auto srcY_UV = nv12.get() + (y / 2) * (sw / 2) * 2 + sw * sh;
            for (int x = 0; x < sw; ++x) {
                auto dstX    = dstY + 3 * x;
                auto srcX_Y  = srcY_Y + x;
                auto srcX_UV = srcY_UV + (x / 2) * 2;
                int Y        = srcX_Y[0];
                int U        = (int)srcX_UV[1] - 128;
                int V        = (int)srcX_UV[0] - 128;

                Y     = Y << 6;
                int r = (Y + 73 * V) >> 6;
                int g = (Y - 25 * U - 37 * V) >> 6;
                int b = (Y + 130 * U) >> 6;

                r         = r < 0 ? 0 : r;
                r         = r > 255 ? 255 : r;
                g         = g < 0 ? 0 : g;
                g         = g > 255 ? 255 : g;