VCodecOneVpl C++ lib. Fast HEVC, H264 and JPEG encoding/decoding on Intel GPU

namespace cr
{
namespace video
{
/**
 * @brief VCodecOneVpl class.
 */
class VCodecOneVplImpl : public VCodec
{
public:

    /// Class constructor.
    VCodecOneVplImpl();

    /// Class destructor.
    ~VCodecOneVplImpl();

    /// Set parameter value.
    bool setParam(VCodecParam id, float value) override;

    /// Get parameter value.
    float getParam(VCodecParam id) override;

    /// Encode/Decode video frame.
    bool transcode(Frame& src, Frame& dst) override;

    /// Execute command.
    bool executeCommand(VCodecCommand id) override;
};
}
}

#include <iostream>
#include "VCodecOneVpl.h"

int main(void)
{
    // Set codec parameters.
    cr::video::VCodec* videoCodec = new cr::video::VCodecOneVpl();
    videoCodec->setParam(cr::video::VCodecParam::BITRATE_KBPS, 7500);
    videoCodec->setParam(cr::video::VCodecParam::GOP, 30);
    videoCodec->setParam(cr::video::VCodecParam::FPS, 30);

    // Create NV12 frame and fill color planes by random values.
    const int width = 1280;
    const int height = 720;
    cr::video::Frame frameNv12(width, height, cr::video::Fourcc::NV12);
    for (uint32_t i = 0; i < frameNv12.size; ++i)
        frameNv12.data[i] = (uint8_t)i;

    // Create output HEVC frame.
    cr::video::Frame frameHEVC(width, height, cr::video::Fourcc::HEVC);

    // Create output file.
    FILE *outputFile = fopen("out.hevc", "w+b");

    // Params for moving object.
    int objectWidth = 128;
    int objectHeight = 128;
    int directionX = 1;
    int directionY = 1;
    int objectX = width / 4;
    int objectY = height / 2;

    // Encode and record 200 frames.
    for (uint32_t n = 0; n < 200; ++n)
    {
        // Draw moving object.
        memset(frameNv12.data, 128, width * height);
        for (int y = objectY; y < objectY + objectHeight; ++y)
            for (int x = objectX; x < objectX + objectHeight; ++x)
                frameNv12.data[y * width + x] = 255;
        objectX += directionX;
        objectY += directionY;
        if (objectX >= width - objectWidth - 5 || objectX <= objectWidth + 5)
            directionX = -directionX;
        if (objectY >= height - objectHeight - 5 || objectY <= objectHeight + 5)
            directionY = -directionY;

        // Encode.
        if (!videoCodec->transcode(frameNv12, frameHEVC))
        {
            std::cout << "Can't encode frame" << std::endl;
            continue;
        }

        // Write to file.
        fwrite(frameHEVC.data, frameHEVC.size, 1, outputFile);  
    }

    // Close file.
    fclose(outputFile);

    return 1;
}