fuquan/android_mt6572_jiabo
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions
android_mt6572_jiabo/hardware/intel/common/libmix/videoencoder/VideoEncoderDef.h
FuQuan 3ff2876a30 first commit
2025-09-05 16:56:03 +08:00

729 lines
19 KiB
C
Raw Blame History

/*
* Copyright (c) 2009-2011 Intel Corporation. All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef __VIDEO_ENCODER_DEF_H__
#define __VIDEO_ENCODER_DEF_H__
#include <stdint.h>
#define STRING_TO_FOURCC(format) ((uint32_t)(((format)[0])|((format)[1]<<8)|((format)[2]<<16)|((format)[3]<<24)))
typedef int32_t Encode_Status;
// Video encode error code
enum {
ENCODE_INVALID_SURFACE = -11,
ENCODE_NO_REQUEST_DATA = -10,
ENCODE_WRONG_STATE = -9,
ENCODE_NOTIMPL = -8,
ENCODE_NO_MEMORY = -7,
ENCODE_NOT_INIT = -6,
ENCODE_DRIVER_FAIL = -5,
ENCODE_INVALID_PARAMS = -4,
ENCODE_NOT_SUPPORTED = -3,
ENCODE_NULL_PTR = -2,
ENCODE_FAIL = -1,
ENCODE_SUCCESS = 0,
ENCODE_ALREADY_INIT = 1,
ENCODE_SLICESIZE_OVERFLOW = 2,
ENCODE_BUFFER_TOO_SMALL = 3, // The buffer passed to encode is too small to contain encoded data
ENCODE_DEVICE_BUSY = 4,
ENCODE_DATA_NOT_READY = 5,
};
typedef enum {
OUTPUT_EVERYTHING = 0, //Output whatever driver generates
OUTPUT_CODEC_DATA = 1,
OUTPUT_FRAME_DATA = 2, //Equal to OUTPUT_EVERYTHING when no header along with the frame data
OUTPUT_ONE_NAL = 4,
OUTPUT_ONE_NAL_WITHOUT_STARTCODE = 8,
OUTPUT_LENGTH_PREFIXED = 16,
OUTPUT_CODEDBUFFER = 32,
OUTPUT_NALULENGTHS_PREFIXED = 64,
OUTPUT_BUFFER_LAST
} VideoOutputFormat;
typedef enum {
RAW_FORMAT_NONE = 0,
RAW_FORMAT_YUV420 = 1,
RAW_FORMAT_YUV422 = 2,
RAW_FORMAT_YUV444 = 4,
RAW_FORMAT_NV12 = 8,
RAW_FORMAT_RGBA = 16,
RAW_FORMAT_OPAQUE = 32,
RAW_FORMAT_PROTECTED = 0x80000000,
RAW_FORMAT_LAST
} VideoRawFormat;
typedef enum {
RATE_CONTROL_NONE = 1,
RATE_CONTROL_CBR = 2,
RATE_CONTROL_VBR = 4,
RATE_CONTROL_VCM = 8,
RATE_CONTROL_LAST
} VideoRateControl;
typedef enum {
PROFILE_MPEG2SIMPLE = 0,
PROFILE_MPEG2MAIN,
PROFILE_MPEG4SIMPLE,
PROFILE_MPEG4ADVANCEDSIMPLE,
PROFILE_MPEG4MAIN,
PROFILE_H264BASELINE,
PROFILE_H264MAIN,
PROFILE_H264HIGH,
PROFILE_VC1SIMPLE,
PROFILE_VC1MAIN,
PROFILE_VC1ADVANCED,
PROFILE_H263BASELINE
} VideoProfile;
typedef enum {
AVC_DELIMITER_LENGTHPREFIX = 0,
AVC_DELIMITER_ANNEXB
} AVCDelimiterType;
typedef enum {
VIDEO_ENC_NONIR, // Non intra refresh
VIDEO_ENC_CIR, // Cyclic intra refresh
VIDEO_ENC_AIR, // Adaptive intra refresh
VIDEO_ENC_BOTH,
VIDEO_ENC_LAST
} VideoIntraRefreshType;
enum VideoBufferSharingMode {
BUFFER_SHARING_NONE = 1, //Means non shared buffer mode
BUFFER_SHARING_CI = 2,
BUFFER_SHARING_V4L2 = 4,
BUFFER_SHARING_SURFACE = 8,
BUFFER_SHARING_USRPTR = 16,
BUFFER_SHARING_GFXHANDLE = 32,
BUFFER_SHARING_KBUFHANDLE = 64,
BUFFER_LAST
};
typedef enum {
FTYPE_UNKNOWN = 0, // Unknown
FTYPE_I = 1, // General I-frame type
FTYPE_P = 2, // General P-frame type
FTYPE_B = 3, // General B-frame type
FTYPE_SI = 4, // H.263 SI-frame type
FTYPE_SP = 5, // H.263 SP-frame type
FTYPE_EI = 6, // H.264 EI-frame type
FTYPE_EP = 7, // H.264 EP-frame type
FTYPE_S = 8, // MPEG-4 S-frame type
FTYPE_IDR = 9, // IDR-frame type
}FrameType;
//function call mode
#define FUNC_BLOCK 0xFFFFFFFF
#define FUNC_NONBLOCK 0
// Output buffer flag
#define ENCODE_BUFFERFLAG_ENDOFFRAME 0x00000001
#define ENCODE_BUFFERFLAG_PARTIALFRAME 0x00000002
#define ENCODE_BUFFERFLAG_SYNCFRAME 0x00000004
#define ENCODE_BUFFERFLAG_CODECCONFIG 0x00000008
#define ENCODE_BUFFERFLAG_DATACORRUPT 0x00000010
#define ENCODE_BUFFERFLAG_DATAINVALID 0x00000020
#define ENCODE_BUFFERFLAG_SLICEOVERFOLOW 0x00000040
#define ENCODE_BUFFERFLAG_ENDOFSTREAM 0x00000080
#define ENCODE_BUFFERFLAG_NSTOPFRAME 0x00000100
typedef struct {
uint8_t *data;
uint32_t bufferSize; //buffer size
uint32_t dataSize; //actual size
uint32_t offset; //buffer offset
uint32_t remainingSize;
int flag; //Key frame, Codec Data etc
VideoOutputFormat format; //output format
int64_t timeStamp; //reserved
FrameType type;
void *priv; //indicate corresponding input data
} VideoEncOutputBuffer;
typedef struct {
uint8_t *data;
uint32_t size;
bool bufAvailable; //To indicate whether this buffer can be reused
int64_t timeStamp; //reserved
FrameType type; //frame type expected to be encoded
int flag; // flag to indicate buffer property
void *priv; //indicate corresponding input data
} VideoEncRawBuffer;
struct VideoEncSurfaceBuffer {
VASurfaceID surface;
uint8_t *usrptr;
uint32_t index;
bool bufAvailable;
VideoEncSurfaceBuffer *next;
};
struct CirParams {
uint32_t cir_num_mbs;
CirParams &operator=(const CirParams &other) {
if (this == &other) return *this;
this->cir_num_mbs = other.cir_num_mbs;
return *this;
}
};
struct AirParams {
uint32_t airMBs;
uint32_t airThreshold;
uint32_t airAuto;
AirParams &operator=(const AirParams &other) {
if (this == &other) return *this;
this->airMBs= other.airMBs;
this->airThreshold= other.airThreshold;
this->airAuto = other.airAuto;
return *this;
}
};
struct VideoFrameRate {
uint32_t frameRateNum;
uint32_t frameRateDenom;
VideoFrameRate &operator=(const VideoFrameRate &other) {
if (this == &other) return *this;
this->frameRateNum = other.frameRateNum;
this->frameRateDenom = other.frameRateDenom;
return *this;
}
};
struct VideoResolution {
uint32_t width;
uint32_t height;
VideoResolution &operator=(const VideoResolution &other) {
if (this == &other) return *this;
this->width = other.width;
this->height = other.height;
return *this;
}
};
struct VideoRateControlParams {
uint32_t bitRate;
uint32_t initQP;
uint32_t minQP;
uint32_t maxQP;
uint32_t I_minQP;
uint32_t I_maxQP;
uint32_t windowSize;
uint32_t targetPercentage;
uint32_t disableFrameSkip;
uint32_t disableBitsStuffing;
uint32_t enableIntraFrameQPControl;
uint32_t temporalFrameRate;
uint32_t temporalID;
VideoRateControlParams &operator=(const VideoRateControlParams &other) {
if (this == &other) return *this;
this->bitRate = other.bitRate;
this->initQP = other.initQP;
this->minQP = other.minQP;
this->maxQP = other.maxQP;
this->I_minQP = other.I_minQP;
this->I_maxQP = other.I_maxQP;
this->windowSize = other.windowSize;
this->targetPercentage = other.targetPercentage;
this->disableFrameSkip = other.disableFrameSkip;
this->disableBitsStuffing = other.disableBitsStuffing;
this->enableIntraFrameQPControl = other.enableIntraFrameQPControl;
this->temporalFrameRate = other.temporalFrameRate;
this->temporalID = other.temporalID;
return *this;
}
};
struct SliceNum {
uint32_t iSliceNum;
uint32_t pSliceNum;
SliceNum &operator=(const SliceNum &other) {
if (this == &other) return *this;
this->iSliceNum = other.iSliceNum;
this->pSliceNum= other.pSliceNum;
return *this;
}
};
typedef struct {
uint32_t realWidth;
uint32_t realHeight;
uint32_t lumaStride;
uint32_t chromStride;
uint32_t format;
} ExternalBufferAttrib;
struct Cropping {
uint32_t LeftOffset;
uint32_t RightOffset;
uint32_t TopOffset;
uint32_t BottomOffset;
Cropping &operator=(const Cropping &other) {
if (this == &other) return *this;
this->LeftOffset = other.LeftOffset;
this->RightOffset = other.RightOffset;
this->TopOffset = other.TopOffset;
this->BottomOffset = other.BottomOffset;
return *this;
}
};
struct SamplingAspectRatio {
uint16_t SarWidth;
uint16_t SarHeight;
SamplingAspectRatio &operator=(const SamplingAspectRatio &other) {
if (this == &other) return *this;
this->SarWidth = other.SarWidth;
this->SarHeight = other.SarHeight;
return *this;
}
};
enum VideoParamConfigType {
VideoParamsTypeStartUnused = 0x01000000,
VideoParamsTypeCommon,
VideoParamsTypeAVC,
VideoParamsTypeH263,
VideoParamsTypeMP4,
VideoParamsTypeVC1,
VideoParamsTypeUpSteamBuffer,
VideoParamsTypeUsrptrBuffer,
VideoParamsTypeHRD,
VideoParamsTypeStoreMetaDataInBuffers,
VideoParamsTypeProfileLevel,
VideoParamsTypeVP8,
VideoParamsTypeTemporalLayer,
VideoConfigTypeFrameRate,
VideoConfigTypeBitRate,
VideoConfigTypeResolution,
VideoConfigTypeIntraRefreshType,
VideoConfigTypeAIR,
VideoConfigTypeCyclicFrameInterval,
VideoConfigTypeAVCIntraPeriod,
VideoConfigTypeNALSize,
VideoConfigTypeIDRRequest,
VideoConfigTypeSliceNum,
VideoConfigTypeVP8,
VideoConfigTypeVP8ReferenceFrame,
VideoConfigTypeCIR,
VideoConfigTypeVP8MaxFrameSizeRatio,
VideoConfigTypeTemperalLayerBitrateFramerate,
VideoParamsConfigExtension
};
struct VideoParamConfigSet {
VideoParamConfigType type;
uint32_t size;
VideoParamConfigSet &operator=(const VideoParamConfigSet &other) {
if (this == &other) return *this;
this->type = other.type;
this->size = other.size;
return *this;
}
};
struct VideoParamsCommon : VideoParamConfigSet {
VAProfile profile;
uint8_t level;
VideoRawFormat rawFormat;
VideoResolution resolution;
VideoFrameRate frameRate;
int32_t intraPeriod;
VideoRateControl rcMode;
VideoRateControlParams rcParams;
VideoIntraRefreshType refreshType;
int32_t cyclicFrameInterval;
AirParams airParams;
CirParams cirParams;
uint32_t disableDeblocking;
bool syncEncMode;
//CodedBuffer properties
uint32_t codedBufNum;
uint32_t numberOfLayer;
uint32_t nPeriodicity;
uint32_t nLayerID[32];
VideoParamsCommon() {
type = VideoParamsTypeCommon;
size = sizeof(VideoParamsCommon);
}
VideoParamsCommon &operator=(const VideoParamsCommon &other) {
if (this == &other) return *this;
VideoParamConfigSet::operator=(other);
this->profile = other.profile;
this->level = other.level;
this->rawFormat = other.rawFormat;
this->resolution = other.resolution;
this->frameRate = other.frameRate;
this->intraPeriod = other.intraPeriod;
this->rcMode = other.rcMode;
this->rcParams = other.rcParams;
this->refreshType = other.refreshType;
this->cyclicFrameInterval = other.cyclicFrameInterval;
this->airParams = other.airParams;
this->disableDeblocking = other.disableDeblocking;
this->syncEncMode = other.syncEncMode;
this->codedBufNum = other.codedBufNum;
this->numberOfLayer = other.numberOfLayer;
return *this;
}
};
struct VideoParamsAVC : VideoParamConfigSet {
uint32_t basicUnitSize; //for rate control
uint8_t VUIFlag;
int32_t maxSliceSize;
uint32_t idrInterval;
uint32_t ipPeriod;
uint32_t refFrames;
SliceNum sliceNum;
AVCDelimiterType delimiterType;
Cropping crop;
SamplingAspectRatio SAR;
uint32_t refIdx10ActiveMinus1;
uint32_t refIdx11ActiveMinus1;
bool bFrameMBsOnly;
bool bMBAFF;
bool bEntropyCodingCABAC;
bool bWeightedPPrediction;
uint32_t weightedBipredicitonMode;
bool bConstIpred ;
bool bDirect8x8Inference;
bool bDirectSpatialTemporal;
uint32_t cabacInitIdc;
VideoParamsAVC() {
type = VideoParamsTypeAVC;
size = sizeof(VideoParamsAVC);
}
VideoParamsAVC &operator=(const VideoParamsAVC &other) {
if (this == &other) return *this;
VideoParamConfigSet::operator=(other);
this->basicUnitSize = other.basicUnitSize;
this->VUIFlag = other.VUIFlag;
this->maxSliceSize = other.maxSliceSize;
this->idrInterval = other.idrInterval;
this->ipPeriod = other.ipPeriod;
this->refFrames = other.refFrames;
this->sliceNum = other.sliceNum;
this->delimiterType = other.delimiterType;
this->crop.LeftOffset = other.crop.LeftOffset;
this->crop.RightOffset = other.crop.RightOffset;
this->crop.TopOffset = other.crop.TopOffset;
this->crop.BottomOffset = other.crop.BottomOffset;
this->SAR.SarWidth = other.SAR.SarWidth;
this->SAR.SarHeight = other.SAR.SarHeight;
this->refIdx10ActiveMinus1 = other.refIdx10ActiveMinus1;
this->refIdx11ActiveMinus1 = other.refIdx11ActiveMinus1;
this->bFrameMBsOnly = other.bFrameMBsOnly;
this->bMBAFF = other.bMBAFF;
this->bEntropyCodingCABAC = other.bEntropyCodingCABAC;
this->bWeightedPPrediction = other.bWeightedPPrediction;
this->weightedBipredicitonMode = other.weightedBipredicitonMode;
this->bConstIpred = other.bConstIpred;
this->bDirect8x8Inference = other.bDirect8x8Inference;
this->bDirectSpatialTemporal = other.bDirectSpatialTemporal;
this->cabacInitIdc = other.cabacInitIdc;
return *this;
}
};
struct VideoParamsUpstreamBuffer : VideoParamConfigSet {
VideoParamsUpstreamBuffer() {
type = VideoParamsTypeUpSteamBuffer;
size = sizeof(VideoParamsUpstreamBuffer);
}
VideoBufferSharingMode bufferMode;
intptr_t *bufList;
uint32_t bufCnt;
ExternalBufferAttrib *bufAttrib;
void *display;
};
struct VideoParamsUsrptrBuffer : VideoParamConfigSet {
VideoParamsUsrptrBuffer() {
type = VideoParamsTypeUsrptrBuffer;
size = sizeof(VideoParamsUsrptrBuffer);
}
//input
uint32_t width;
uint32_t height;
uint32_t format;
uint32_t expectedSize;
//output
uint32_t actualSize;
uint32_t stride;
uint8_t *usrPtr;
};
struct VideoParamsHRD : VideoParamConfigSet {
VideoParamsHRD() {
type = VideoParamsTypeHRD;
size = sizeof(VideoParamsHRD);
}
uint32_t bufferSize;
uint32_t initBufferFullness;
};
struct VideoParamsStoreMetaDataInBuffers : VideoParamConfigSet {
VideoParamsStoreMetaDataInBuffers() {
type = VideoParamsTypeStoreMetaDataInBuffers;
size = sizeof(VideoParamsStoreMetaDataInBuffers);
}
bool isEnabled;
};
struct VideoParamsProfileLevel : VideoParamConfigSet {
VideoParamsProfileLevel() {
type = VideoParamsTypeProfileLevel;
size = sizeof(VideoParamsProfileLevel);
}
VAProfile profile;
uint32_t level;
bool isSupported;
};
struct VideoParamsTemporalLayer : VideoParamConfigSet {
VideoParamsTemporalLayer() {
type = VideoParamsTypeTemporalLayer;
size = sizeof(VideoParamsTemporalLayer);
}
uint32_t numberOfLayer;
uint32_t nPeriodicity;
uint32_t nLayerID[32];
};
struct VideoConfigFrameRate : VideoParamConfigSet {
VideoConfigFrameRate() {
type = VideoConfigTypeFrameRate;
size = sizeof(VideoConfigFrameRate);
}
VideoFrameRate frameRate;
};
struct VideoConfigBitRate : VideoParamConfigSet {
VideoConfigBitRate() {
type = VideoConfigTypeBitRate;
size = sizeof(VideoConfigBitRate);
}
VideoRateControlParams rcParams;
};
struct VideoConfigAVCIntraPeriod : VideoParamConfigSet {
VideoConfigAVCIntraPeriod() {
type = VideoConfigTypeAVCIntraPeriod;
size = sizeof(VideoConfigAVCIntraPeriod);
}
uint32_t idrInterval; //How many Intra frame will have a IDR frame
uint32_t intraPeriod;
uint32_t ipPeriod;
};
struct VideoConfigNALSize : VideoParamConfigSet {
VideoConfigNALSize() {
type = VideoConfigTypeNALSize;
size = sizeof(VideoConfigNALSize);
}
uint32_t maxSliceSize;
};
struct VideoConfigResolution : VideoParamConfigSet {
VideoConfigResolution() {
type = VideoConfigTypeResolution;
size = sizeof(VideoConfigResolution);
}
VideoResolution resolution;
};
struct VideoConfigIntraRefreshType : VideoParamConfigSet {
VideoConfigIntraRefreshType() {
type = VideoConfigTypeIntraRefreshType;
size = sizeof(VideoConfigIntraRefreshType);
}
VideoIntraRefreshType refreshType;
};
struct VideoConfigCyclicFrameInterval : VideoParamConfigSet {
VideoConfigCyclicFrameInterval() {
type = VideoConfigTypeCyclicFrameInterval;
size = sizeof(VideoConfigCyclicFrameInterval);
}
int32_t cyclicFrameInterval;
};
struct VideoConfigCIR : VideoParamConfigSet {
VideoConfigCIR() {
type = VideoConfigTypeCIR;
size = sizeof(VideoConfigCIR);
}
CirParams cirParams;
};
struct VideoConfigAIR : VideoParamConfigSet {
VideoConfigAIR() {
type = VideoConfigTypeAIR;
size = sizeof(VideoConfigAIR);
}
AirParams airParams;
};
struct VideoConfigSliceNum : VideoParamConfigSet {
VideoConfigSliceNum() {
type = VideoConfigTypeSliceNum;
size = sizeof(VideoConfigSliceNum);
}
SliceNum sliceNum;
};
struct VideoParamsVP8 : VideoParamConfigSet {
uint32_t profile;
uint32_t error_resilient;
uint32_t num_token_partitions;
uint32_t kf_auto;
uint32_t kf_min_dist;
uint32_t kf_max_dist;
uint32_t min_qp;
uint32_t max_qp;
uint32_t init_qp;
uint32_t rc_undershoot;
uint32_t rc_overshoot;
uint32_t hrd_buf_size;
uint32_t hrd_buf_initial_fullness;
uint32_t hrd_buf_optimal_fullness;
uint32_t max_frame_size_ratio;
VideoParamsVP8() {
type = VideoParamsTypeVP8;
size = sizeof(VideoParamsVP8);
}
};
struct VideoConfigVP8 : VideoParamConfigSet {
uint32_t force_kf;
uint32_t refresh_entropy_probs;
uint32_t value;
unsigned char sharpness_level;
VideoConfigVP8 () {
type = VideoConfigTypeVP8;
size = sizeof(VideoConfigVP8);
}
};
struct VideoConfigVP8ReferenceFrame : VideoParamConfigSet {
uint32_t no_ref_last;
uint32_t no_ref_gf;
uint32_t no_ref_arf;
uint32_t refresh_last;
uint32_t refresh_golden_frame;
uint32_t refresh_alternate_frame;
VideoConfigVP8ReferenceFrame () {
type = VideoConfigTypeVP8ReferenceFrame;
size = sizeof(VideoConfigVP8ReferenceFrame);
}
};
struct VideoConfigVP8MaxFrameSizeRatio : VideoParamConfigSet {
VideoConfigVP8MaxFrameSizeRatio() {
type = VideoConfigTypeVP8MaxFrameSizeRatio;
size = sizeof(VideoConfigVP8MaxFrameSizeRatio);
}
uint32_t max_frame_size_ratio;
};
struct VideoConfigTemperalLayerBitrateFramerate : VideoParamConfigSet {
VideoConfigTemperalLayerBitrateFramerate() {
type = VideoConfigTypeTemperalLayerBitrateFramerate;
size = sizeof(VideoConfigTemperalLayerBitrateFramerate);
}
uint32_t nLayerID;
uint32_t bitRate;
uint32_t frameRate;
};
#endif /* __VIDEO_ENCODER_DEF_H__ */
Reference in a new issue View git blame Copy permalink