/* * 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 #define STRING_TO_FOURCC(format) ((uint32_t)(((format)[0])|((format)[1]<<8)|((format)[2]<<16)|((format)[3]<<24))) #define min(X,Y) (((X) < (Y)) ? (X) : (Y)) #define max(X,Y) (((X) > (Y)) ? (X) : (Y)) 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__ */