vmxcodec.h

Go to the documentation of this file.

/*
* MIT License
*
* Copyright (c) 2025 Open Media Transport Contributors
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in all
* copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
* SOFTWARE.
*
*/
 
#pragma once
#include <cstdint>
#include <cstring>
#include "thread_tasks.h"
#ifdef _MSC_VER
#define VMX_API __declspec(dllexport)
#else
#define VMX_API extern "C" __attribute__((visibility("default")))
#endif
#if defined(_M_ARM64) | defined(__arm64) | defined(__aarch64__)
#define ARM64
#endif
#if defined(_M_X64) | defined(__x86_64__)
#define X64
#define AVX2 //Include AVX2 in all Intel builds as these functions will be dynamically called only if instruction set available.
#endif
 
const int VMX_SLICE_HEIGHT = 16;
const int VMX_QUALITY_COUNT = 25;
const int VMX_MAX_PLANES = 4;
 
typedef unsigned long long buffer_t;
typedef unsigned char       BYTE;
 
typedef struct {
    int width;
    int height;
} VMX_SIZE;
 
typedef enum {
    VMX_FORMAT_PROGRESSIVE,
    VMX_FORMAT_INTERLACED
} VMX_FORMAT;
 
typedef enum {
    VMX_ERR_OK,
    VMX_ERR_UNKNOWN,
    VMX_ERR_INVALID_CODEC_FORMAT,
    VMX_ERR_INVALID_SLICE_COUNT,
    VMX_ERR_BUFFER_OVERFLOW,
    VMX_ERR_INVALID_INSTANCE,
    VMX_ERR_INVALID_PARAMETERS
} VMX_ERR;
 
typedef enum {
    VMX_PROFILE_DEFAULT = 0,
    VMX_PROFILE_LQ = 33,
    VMX_PROFILE_SQ = 66,
    VMX_PROFILE_HQ = 99,
    VMX_PROFILE_OMT_LQ = 133,
    VMX_PROFILE_OMT_SQ = 166,
    VMX_PROFILE_OMT_HQ = 199
} VMX_PROFILE;

typedef enum {
    VMX_COLORSPACE_UNDEFINED = 0,
    VMX_COLORSPACE_BT601 = 601,
    VMX_COLORSPACE_BT709 = 709
} VMX_COLORSPACE;
 
typedef enum {
    VMX_CODEC_FORMAT_NONE,
    VMX_CODEC_FORMAT_PROGRESSIVE,
    VMX_CODEC_FORMAT_INTERLACED,
    VMX_CODEC_FORMAT_EXTENDED
} VMX_CODEC_FORMAT;
 
typedef enum {
    VMX_IMAGE_UYVY,
    VMX_IMAGE_YUY2,
    VMX_IMAGE_NV12,
    VMX_IMAGE_YV12,
    VMX_IMAGE_YUVPLANAR422,
    VMX_IMAGE_BGRA,
    VMX_IMAGE_BGRX,
    VMX_IMAGE_UYVA,
    VMX_IMAGE_P216,
    VMX_IMAGE_PA16,
} VMX_IMAGE_FORMAT;
 
struct VMX_SLICE_DATA
{
    unsigned char* Stream;
    unsigned char* StreamPos;
    int MaxStreamLength;
    int StreamLength;
    //buffer_t BitsLeft;
    int BitsLeft; //Bad data may lead to wraparound if unsigned. Going negative is preferred
    buffer_t Temp;
    buffer_t TempRead;
    VMX_SIZE Size[3];
};
 
struct VMX_SLICE_SET
{
    VMX_SLICE_DATA DC;
    VMX_SLICE_DATA AC;
    int Offset[VMX_MAX_PLANES];
    int Offset16[VMX_MAX_PLANES]; //Offset for working with 16bit data
    VMX_SIZE PixelSize; //Size in pixels of the slice, for copying from source image data. Due to alignment last slice will be only 8 pixels height for 1080 for example.
    VMX_SIZE PixelSizeInterlaced; //Same as above but for second field alignment adjustment at the mid point.
    int LowerField; //=1 when this is a lower field slice
    __declspec(align(64)) short TempBlock[128];
    __declspec(align(64)) short TempBlock2[128];
    __declspec(align(64)) short TempBlock3[128];
};
 
struct VMX_PLANE
{
    int Index;
    VMX_SIZE Size;
    int Stride; //Double this when dealing with 16bit data
    BYTE* Data;
    BYTE* DataLowerPreview;
};
 
struct VMX_INSTANCE
{
    int avx2;
    VMX_FORMAT Format;
    VMX_PROFILE Profile;
    VMX_COLORSPACE ColorSpace;
 
    int Quality;
    int MinQuality;
    int DCShift;
 
    unsigned short* DecodeQualityPresets[VMX_QUALITY_COUNT];
    unsigned short* EncodeQualityPresets[VMX_QUALITY_COUNT];
    unsigned short* DecodeMatrix;
    unsigned short* EncodeMatrix;
 
    unsigned short* DecodeQualityPresets256[VMX_QUALITY_COUNT];
    unsigned short* EncodeQualityPresets256[VMX_QUALITY_COUNT];
    unsigned short* DecodeMatrix256;
    unsigned short* EncodeMatrix256;
 
    VMX_PLANE Planes[VMX_MAX_PLANES];
    int SliceCount;
    int AlignedHeight;
    VMX_SLICE_SET** Slices;
    int TargetBytesPerFrameMin;
    int TargetBytesPerFrameMax;
    int Threads;
    ThreadTasks * Tasks;
    VMX_SIZE PreviewSize;
    VMX_SIZE PreviewSizeInterlaced;
 
    BYTE* ImageData;
    int ImageStride;
 
    BYTE* ImageDataU;
    int ImageStrideU;
 
    BYTE* ImageDataV;
    int ImageStrideV;
 
    BYTE* ImageDataA;
    int ImageStrideA;
 
    VMX_IMAGE_FORMAT ImageFormat;
};
 
const int VMX_DECODE_MATRIX_COUNT = 64;
const int VMX_ENCODE_MATRIX_COUNT = 192;
 
//Public exports

VMX_API VMX_INSTANCE* VMX_Create(VMX_SIZE dimensions, VMX_PROFILE profile, VMX_COLORSPACE colorSpace);

VMX_API void VMX_Destroy(VMX_INSTANCE* instance);

VMX_API void VMX_SetQuality(VMX_INSTANCE* instance, int q);

VMX_API int VMX_GetQuality(VMX_INSTANCE* instance);

VMX_API void VMX_GetEncodingParameters(VMX_INSTANCE* instance, int* frameMin, int* frameMax, int* minQuality, int* dcShift);

VMX_API void VMX_SetEncodingParameters(VMX_INSTANCE* instance, int frameMin, int frameMax, int minQuality, int dcShift);

VMX_API VMX_ERR VMX_DecodeBGRA(VMX_INSTANCE* instance, BYTE* dst, int stride);

VMX_API VMX_ERR VMX_DecodeBGRX(VMX_INSTANCE* instance, BYTE* dst, int stride);

VMX_API VMX_ERR VMX_DecodeP216(VMX_INSTANCE* instance, BYTE* dst, int stride);

VMX_API VMX_ERR VMX_DecodePA16(VMX_INSTANCE* instance, BYTE* dst, int stride);

VMX_API VMX_ERR VMX_DecodeUYVY(VMX_INSTANCE* instance, BYTE* dst, int stride);

VMX_API VMX_ERR VMX_DecodeUYVA(VMX_INSTANCE* instance, BYTE* dst, int stride);

VMX_API VMX_ERR VMX_DecodeYUY2(VMX_INSTANCE* instance, BYTE* dst, int stride);

VMX_API VMX_ERR VMX_DecodePreviewBGRA(VMX_INSTANCE* instance, BYTE* dst, int stride);

VMX_API VMX_ERR VMX_DecodePreviewBGRX(VMX_INSTANCE* instance, BYTE* dst, int stride);

VMX_API VMX_ERR VMX_DecodePreviewUYVY(VMX_INSTANCE* instance, BYTE* dst, int stride);

VMX_API VMX_ERR VMX_DecodePreviewUYVA(VMX_INSTANCE* instance, BYTE* dst, int stride);

VMX_API VMX_ERR VMX_DecodePreviewYUY2(VMX_INSTANCE* instance, BYTE* dst, int stride);
 

VMX_API VMX_ERR VMX_EncodeBGRA(VMX_INSTANCE* instance, BYTE* src, int stride, int interlaced);

VMX_API VMX_ERR VMX_EncodeBGRX(VMX_INSTANCE* instance, BYTE* src, int stride, int interlaced);

VMX_API VMX_ERR VMX_EncodeUYVY(VMX_INSTANCE* instance, BYTE* src, int stride, int interlaced);

VMX_API VMX_ERR VMX_EncodeUYVA(VMX_INSTANCE* instance, BYTE* src, int stride, int interlaced);

VMX_API VMX_ERR VMX_EncodeYUY2(VMX_INSTANCE* instance, BYTE* src, int stride, int interlaced);

VMX_API VMX_ERR VMX_EncodeNV12(VMX_INSTANCE* instance, BYTE* srcY, int srcStrideY, BYTE* srcUV, int srcStrideUV, int interlaced);

VMX_API VMX_ERR VMX_EncodeYV12(VMX_INSTANCE* instance, BYTE* srcY, int srcStrideY, BYTE* srcU, int srcStrideU, BYTE* srcV, int srcStrideV, int interlaced);

VMX_API VMX_ERR VMX_EncodeP216(VMX_INSTANCE* instance, BYTE* src, int stride, int interlaced);

VMX_API VMX_ERR VMX_EncodePA16(VMX_INSTANCE* instance, BYTE* src, int stride, int interlaced);
 
 
VMX_API VMX_ERR VMX_EncodePlanar(VMX_INSTANCE* instance, int interlaced);

VMX_API VMX_ERR VMX_LoadFrom(VMX_INSTANCE* instance, BYTE* data, int dataLen);

VMX_API int VMX_SaveTo(VMX_INSTANCE* instance, BYTE* dst, int maxLen);

VMX_API int VMX_GetEncodedPreviewLength(VMX_INSTANCE* instance);

VMX_API void VMX_BGRXToUYVY(BYTE* pSrc, int srcStride, BYTE* pDst, int dstStride, VMX_SIZE size);

VMX_API int VMX_BGRXToUYVYConditional(BYTE* pSrc, BYTE* pSrcPrev, int srcStride, BYTE* pDst, int dstStride, VMX_SIZE size);

VMX_API float VMX_CalculatePSNR(BYTE* p1, BYTE* p2, int stride, int bytesPerPixel, VMX_SIZE sz);

VMX_API int VMX_GetThreads(VMX_INSTANCE* instance);

VMX_API void VMX_SetThreads(VMX_INSTANCE* instance, int numThreads);
 
VMX_API int VMX_Test(VMX_INSTANCE* instance, short* src, short* dst);
//Private functions
void VMX_ResetData(VMX_SLICE_DATA* s);
void VMX_ResetStream(VMX_INSTANCE* instance);