1063 lines
40 KiB
C++
1063 lines
40 KiB
C++
/*
|
|
* 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.
|
|
*/
|
|
|
|
#define LOG_TAG "OMXVideoEncoderAVC"
|
|
#include "OMXVideoEncoderAVC.h"
|
|
#include "IntelMetadataBuffer.h"
|
|
|
|
static const char *AVC_MIME_TYPE = "video/h264";
|
|
|
|
struct ProfileMap {
|
|
OMX_VIDEO_AVCPROFILETYPE key;
|
|
VAProfile value;
|
|
const char *name;
|
|
};
|
|
|
|
struct LevelMap {
|
|
OMX_VIDEO_AVCLEVELTYPE key;
|
|
uint32_t value;
|
|
const char *name;
|
|
};
|
|
|
|
static ProfileMap ProfileTable[] = {
|
|
{ OMX_VIDEO_AVCProfileBaseline, VAProfileH264Baseline, "AVC Baseline" },
|
|
{ OMX_VIDEO_AVCProfileMain, VAProfileH264Main, "AVC Main" },
|
|
{ OMX_VIDEO_AVCProfileHigh, VAProfileH264High, "AVC High" },
|
|
{ (OMX_VIDEO_AVCPROFILETYPE) 0, (VAProfile) 0, "Not Supported" },
|
|
};
|
|
|
|
static LevelMap LevelTable[] = {
|
|
{ OMX_VIDEO_AVCLevel4, 40, "AVC Level4" },
|
|
{ OMX_VIDEO_AVCLevel41, 41, "AVC Level41" },
|
|
{ OMX_VIDEO_AVCLevel42, 42, "AVC Level42" },
|
|
{ OMX_VIDEO_AVCLevel5, 50, "AVC Level5" },
|
|
{ OMX_VIDEO_AVCLevel51, 51, "AVC Level51" },
|
|
{ (OMX_VIDEO_AVCLEVELTYPE) 0, 0, "Not Supported" },
|
|
};
|
|
|
|
#define FIND_BYKEY(table, x, y) {\
|
|
for(int ii = 0; ; ii++) { \
|
|
if (table[ii].key == x || table[ii].key == 0) { \
|
|
y = ii; \
|
|
break; \
|
|
} \
|
|
} \
|
|
}\
|
|
|
|
#define FIND_BYVALUE(table, x, y) {\
|
|
for(int ii = 0; ; ii++) { \
|
|
if (table[ii].value == x || table[ii].value == 0) { \
|
|
y = ii; \
|
|
break; \
|
|
} \
|
|
} \
|
|
} \
|
|
|
|
OMXVideoEncoderAVC::OMXVideoEncoderAVC() {
|
|
BuildHandlerList();
|
|
mVideoEncoder = createVideoEncoder(AVC_MIME_TYPE);
|
|
if (!mVideoEncoder) {
|
|
LOGE("OMX_ErrorInsufficientResources");
|
|
return;
|
|
}
|
|
|
|
mAVCParams = new VideoParamsAVC();
|
|
if (!mAVCParams) {
|
|
LOGE("OMX_ErrorInsufficientResources");
|
|
return;
|
|
}
|
|
|
|
//Query supported Profile/Level
|
|
mPLTableCount = 0;
|
|
|
|
VAProfile profiles[MAX_H264_PROFILE] = {VAProfileH264High, VAProfileH264Main, VAProfileH264Baseline};
|
|
|
|
VideoParamsProfileLevel pl;
|
|
for (int i=0; i < MAX_H264_PROFILE; i++) {
|
|
pl.profile = profiles[i];
|
|
pl.level = 0;
|
|
pl.isSupported = false;
|
|
|
|
mVideoEncoder->getParameters(&pl);
|
|
if (pl.isSupported) {
|
|
uint32_t profile_index;
|
|
uint32_t level_index;
|
|
|
|
FIND_BYVALUE(ProfileTable, pl.profile, profile_index);
|
|
if (ProfileTable[profile_index].key == (OMX_VIDEO_AVCPROFILETYPE) 0)
|
|
continue;
|
|
|
|
FIND_BYVALUE(LevelTable, pl.level, level_index);
|
|
if (LevelTable[level_index].key == (OMX_VIDEO_AVCLEVELTYPE) 0)
|
|
continue;
|
|
|
|
mPLTable[mPLTableCount].profile = ProfileTable[profile_index].key;
|
|
mPLTable[mPLTableCount].level = LevelTable[level_index].key;
|
|
mPLTableCount ++;
|
|
LOGV("Support Profile:%s, Level:%s\n", ProfileTable[profile_index].name, LevelTable[level_index].name);
|
|
}
|
|
}
|
|
|
|
mEmptyEOSBuf = OMX_FALSE;
|
|
}
|
|
|
|
OMXVideoEncoderAVC::~OMXVideoEncoderAVC() {
|
|
if(mAVCParams) {
|
|
delete mAVCParams;
|
|
mAVCParams = NULL;
|
|
}
|
|
}
|
|
|
|
OMX_ERRORTYPE OMXVideoEncoderAVC::InitOutputPortFormatSpecific(OMX_PARAM_PORTDEFINITIONTYPE *paramPortDefinitionOutput) {
|
|
// OMX_VIDEO_PARAM_AVCTYPE
|
|
memset(&mParamAvc, 0, sizeof(mParamAvc));
|
|
SetTypeHeader(&mParamAvc, sizeof(mParamAvc));
|
|
mParamAvc.nPortIndex = OUTPORT_INDEX;
|
|
|
|
if (mPLTableCount > 0) {
|
|
mParamAvc.eProfile = (OMX_VIDEO_AVCPROFILETYPE) mPLTable[0].profile;
|
|
mParamAvc.eLevel = (OMX_VIDEO_AVCLEVELTYPE)mPLTable[0].level;
|
|
} else {
|
|
LOGE("No supported profile/level\n");
|
|
return OMX_ErrorUndefined;
|
|
}
|
|
mParamAvc.nAllowedPictureTypes = OMX_VIDEO_PictureTypeI | OMX_VIDEO_PictureTypeP;
|
|
mParamAvc.nPFrames = 29;
|
|
mParamAvc.nBFrames = 0;
|
|
|
|
// OMX_NALSTREAMFORMATTYPE
|
|
memset(&mNalStreamFormat, 0, sizeof(mNalStreamFormat));
|
|
SetTypeHeader(&mNalStreamFormat, sizeof(mNalStreamFormat));
|
|
mNalStreamFormat.nPortIndex = OUTPORT_INDEX;
|
|
// TODO: check if this is desired Nalu Format
|
|
//mNalStreamFormat.eNaluFormat = OMX_NaluFormatLengthPrefixedSeparateFirstHeader;
|
|
// OMX_VIDEO_CONFIG_AVCINTRAPERIOD
|
|
memset(&mConfigAvcIntraPeriod, 0, sizeof(mConfigAvcIntraPeriod));
|
|
SetTypeHeader(&mConfigAvcIntraPeriod, sizeof(mConfigAvcIntraPeriod));
|
|
mConfigAvcIntraPeriod.nPortIndex = OUTPORT_INDEX;
|
|
// TODO: need to be populated from Video Encoder
|
|
mConfigAvcIntraPeriod.nIDRPeriod = 1;
|
|
mConfigAvcIntraPeriod.nPFrames = 29;
|
|
|
|
// OMX_VIDEO_CONFIG_NALSIZE
|
|
memset(&mConfigNalSize, 0, sizeof(mConfigNalSize));
|
|
SetTypeHeader(&mConfigNalSize, sizeof(mConfigNalSize));
|
|
mConfigNalSize.nPortIndex = OUTPORT_INDEX;
|
|
mConfigNalSize.nNaluBytes = 0;
|
|
|
|
// OMX_VIDEO_PARAM_INTEL_AVCVUI
|
|
memset(&mParamIntelAvcVui, 0, sizeof(mParamIntelAvcVui));
|
|
SetTypeHeader(&mParamIntelAvcVui, sizeof(mParamIntelAvcVui));
|
|
mParamIntelAvcVui.nPortIndex = OUTPORT_INDEX;
|
|
mParamIntelAvcVui.bVuiGeneration = OMX_FALSE;
|
|
|
|
// OMX_VIDEO_CONFIG_INTEL_SLICE_NUMBERS
|
|
memset(&mConfigIntelSliceNumbers, 0, sizeof(mConfigIntelSliceNumbers));
|
|
SetTypeHeader(&mConfigIntelSliceNumbers, sizeof(mConfigIntelSliceNumbers));
|
|
mConfigIntelSliceNumbers.nPortIndex = OUTPORT_INDEX;
|
|
mConfigIntelSliceNumbers.nISliceNumber = 1;
|
|
mConfigIntelSliceNumbers.nPSliceNumber = 1;
|
|
|
|
// Override OMX_PARAM_PORTDEFINITIONTYPE
|
|
paramPortDefinitionOutput->nBufferCountActual = OUTPORT_ACTUAL_BUFFER_COUNT;
|
|
paramPortDefinitionOutput->nBufferCountMin = OUTPORT_MIN_BUFFER_COUNT;
|
|
paramPortDefinitionOutput->nBufferSize = OUTPORT_BUFFER_SIZE;
|
|
paramPortDefinitionOutput->format.video.cMIMEType = (OMX_STRING)AVC_MIME_TYPE;
|
|
paramPortDefinitionOutput->format.video.eCompressionFormat = OMX_VIDEO_CodingAVC;
|
|
|
|
// Override OMX_VIDEO_PARAM_PROFILELEVELTYPE
|
|
// TODO: check if profile/level supported is correct
|
|
mParamProfileLevel.eProfile = mParamAvc.eProfile;
|
|
mParamProfileLevel.eLevel = mParamAvc.eLevel;
|
|
|
|
// Override OMX_VIDEO_PARAM_BITRATETYPE
|
|
mParamBitrate.nTargetBitrate = 192000;
|
|
|
|
// Override OMX_VIDEO_CONFIG_INTEL_BITRATETYPE
|
|
mConfigIntelBitrate.nInitialQP = 0; // Initial QP for I frames
|
|
|
|
return OMX_ErrorNone;
|
|
}
|
|
|
|
OMX_ERRORTYPE OMXVideoEncoderAVC::SetVideoEncoderParam(void) {
|
|
|
|
Encode_Status ret = ENCODE_SUCCESS;
|
|
LOGV("OMXVideoEncoderAVC::SetVideoEncoderParam");
|
|
|
|
if (!mEncoderParams) {
|
|
LOGE("NULL pointer: mEncoderParams");
|
|
return OMX_ErrorBadParameter;
|
|
}
|
|
|
|
mVideoEncoder->getParameters(mEncoderParams);
|
|
uint32_t index;
|
|
FIND_BYKEY(ProfileTable, mParamAvc.eProfile, index);
|
|
if (ProfileTable[index].value != 0)
|
|
mEncoderParams->profile = ProfileTable[index].value;
|
|
|
|
if (mParamAvc.nAllowedPictureTypes & OMX_VIDEO_PictureTypeB)
|
|
mEncoderParams->intraPeriod = mParamAvc.nPFrames + mParamAvc.nBFrames;
|
|
else
|
|
mEncoderParams->intraPeriod = mParamAvc.nPFrames + 1;
|
|
|
|
// 0 - all luma and chroma block edges of the slice are filtered
|
|
// 1 - deblocking is disabled for all block edges of the slice
|
|
// 2 - all luma and chroma block edges of the slice are filtered
|
|
// with exception of the block edges that coincide with slice boundaries
|
|
mEncoderParams->disableDeblocking = 0;
|
|
|
|
OMXVideoEncoderBase::SetVideoEncoderParam();
|
|
|
|
mVideoEncoder->getParameters(mAVCParams);
|
|
if(mParamIntelAvcVui.bVuiGeneration == OMX_TRUE) {
|
|
mAVCParams->VUIFlag = 1;
|
|
}
|
|
// For resolution below VGA, single core can hit the performance target and provide VQ gain
|
|
if (mEncoderParams->resolution.width <= 640 && mEncoderParams->resolution.height <= 480) {
|
|
mConfigIntelSliceNumbers.nISliceNumber = 1;
|
|
mConfigIntelSliceNumbers.nPSliceNumber = 1;
|
|
}
|
|
mAVCParams->sliceNum.iSliceNum = mConfigIntelSliceNumbers.nISliceNumber;
|
|
mAVCParams->sliceNum.pSliceNum = mConfigIntelSliceNumbers.nPSliceNumber;
|
|
mAVCParams->maxSliceSize = mConfigNalSize.nNaluBytes * 8;
|
|
|
|
if (mEncoderParams->intraPeriod == 0) {
|
|
mAVCParams->idrInterval = 0;
|
|
mAVCParams->ipPeriod = 1;
|
|
} else {
|
|
mAVCParams->idrInterval = mConfigAvcIntraPeriod.nIDRPeriod; //idrinterval
|
|
if (mParamAvc.nAllowedPictureTypes & OMX_VIDEO_PictureTypeB)
|
|
mAVCParams->ipPeriod = mEncoderParams->intraPeriod / mParamAvc.nPFrames;
|
|
else
|
|
mAVCParams->ipPeriod = 1;
|
|
}
|
|
|
|
ret = mVideoEncoder ->setParameters(mAVCParams);
|
|
CHECK_ENCODE_STATUS("setParameters");
|
|
|
|
LOGV("VUIFlag = %d\n", mAVCParams->VUIFlag);
|
|
LOGV("sliceNum.iSliceNum = %d\n", mAVCParams->sliceNum.iSliceNum);
|
|
LOGV("sliceNum.pSliceNum = %d\n", mAVCParams->sliceNum.pSliceNum);
|
|
LOGV("maxSliceSize = %d\n ", mAVCParams->maxSliceSize);
|
|
LOGV("intraPeriod = %d\n ", mEncoderParams->intraPeriod);
|
|
LOGV("idrInterval = %d\n ", mAVCParams->idrInterval);
|
|
LOGV("ipPeriod = %d\n ", mAVCParams->ipPeriod);
|
|
return OMX_ErrorNone;
|
|
}
|
|
|
|
OMX_ERRORTYPE OMXVideoEncoderAVC::ProcessorInit(void) {
|
|
mCSDOutputted = OMX_FALSE;
|
|
mInputPictureCount = 0;
|
|
mFrameEncodedCount = 0;
|
|
return OMXVideoEncoderBase::ProcessorInit();
|
|
}
|
|
|
|
OMX_ERRORTYPE OMXVideoEncoderAVC::ProcessorDeinit(void) {
|
|
return OMXVideoEncoderBase::ProcessorDeinit();
|
|
}
|
|
|
|
OMX_ERRORTYPE OMXVideoEncoderAVC::ProcessorStop(void) {
|
|
OMX_BUFFERHEADERTYPE *omxbuf = NULL;
|
|
|
|
while(!mBFrameList.empty()) {
|
|
omxbuf = * mBFrameList.begin();
|
|
this->ports[INPORT_INDEX]->ReturnThisBuffer(omxbuf);
|
|
mBFrameList.erase(mBFrameList.begin());
|
|
}
|
|
|
|
mEmptyEOSBuf = OMX_FALSE;
|
|
return OMXVideoEncoderBase::ProcessorStop();
|
|
}
|
|
|
|
OMX_ERRORTYPE OMXVideoEncoderAVC::ProcessorPreEmptyBuffer(OMX_BUFFERHEADERTYPE* buffer) {
|
|
OMX_U32 EncodeInfo = 0;
|
|
OMX_U32 EncodeFrameType = 0;
|
|
|
|
uint32_t poc = 0;
|
|
uint32_t idrPeriod = mAVCParams->idrInterval;
|
|
uint32_t IntraPeriod = mEncoderParams->intraPeriod;
|
|
uint32_t IpPeriod = mAVCParams->ipPeriod;
|
|
bool BFrameEnabled = IpPeriod > 1;
|
|
uint32_t GOP = 0;
|
|
|
|
if (idrPeriod == 0 || IntraPeriod == 0) {
|
|
GOP = 0xFFFFFFFF;
|
|
if (IntraPeriod == 0)
|
|
IntraPeriod = 0xFFFFFFFF;
|
|
} else if (BFrameEnabled)
|
|
GOP = IntraPeriod*idrPeriod + 1;
|
|
else
|
|
GOP = IntraPeriod*idrPeriod;
|
|
|
|
LOGV("ProcessorPreEmptyBuffer idrPeriod=%d, IntraPeriod=%d, IpPeriod=%d, BFrameEnabled=%d\n", idrPeriod, IntraPeriod, IpPeriod, BFrameEnabled);
|
|
|
|
//decide frame type, refer Merrifield Video Encoder Driver HLD Chapter 3.17
|
|
poc = mInputPictureCount % GOP;
|
|
|
|
if (poc == 0 /*IDR*/) {
|
|
EncodeFrameType = F_IDR;
|
|
} else if (IntraPeriod == 1) {
|
|
EncodeFrameType = F_I;
|
|
}else if ((poc > IpPeriod) && ((poc - IpPeriod) % IntraPeriod == 0))/*I*/{
|
|
EncodeFrameType = F_I;
|
|
if (BFrameEnabled)
|
|
SET_CO(EncodeInfo, CACHE_POP);
|
|
} else if ((poc % IpPeriod == 0) /*P*/ || (buffer->nFlags & OMX_BUFFERFLAG_EOS)/*EOS,always P*/) {
|
|
EncodeFrameType = F_P;
|
|
if (BFrameEnabled)
|
|
SET_CO(EncodeInfo, CACHE_POP);
|
|
} else { /*B*/
|
|
EncodeFrameType = F_B;
|
|
SET_CO(EncodeInfo, CACHE_PUSH);
|
|
}
|
|
|
|
SET_FT(EncodeInfo, EncodeFrameType);
|
|
SET_FC(EncodeInfo, mInputPictureCount);
|
|
|
|
buffer->pPlatformPrivate = (OMX_PTR) EncodeInfo;
|
|
|
|
LOGV("ProcessorPreEmptyBuffer Frame %d, Type %s, EncodeInfo %x\n", mInputPictureCount, FrameTypeStr[EncodeFrameType], EncodeInfo);
|
|
|
|
mInputPictureCount ++;
|
|
return OMX_ErrorNone;
|
|
}
|
|
|
|
OMX_BOOL OMXVideoEncoderAVC::ProcessCacheOperation(OMX_BUFFERHEADERTYPE **buffers) {
|
|
|
|
OMX_BOOL Cached = OMX_FALSE;
|
|
|
|
//get frame encode info
|
|
Encode_Info eInfo;
|
|
uint32_t encodeInfo = (uint32_t) buffers[INPORT_INDEX]->pPlatformPrivate;
|
|
eInfo.FrameType = GET_FT(encodeInfo);
|
|
|
|
eInfo.CacheOperation = GET_CO(encodeInfo);
|
|
eInfo.NotStopFrame = encodeInfo & ENC_NSTOP;
|
|
eInfo.FrameCount = GET_FC(encodeInfo);
|
|
|
|
LOGV("ProcessCacheOperation Frame %d, type:%s, CacheOps:%s, NoSTOP=%d, EOS=%d\n",
|
|
eInfo.FrameCount, FrameTypeStr[eInfo.FrameType], CacheOperationStr[eInfo.CacheOperation],
|
|
eInfo.NotStopFrame, buffers[INPORT_INDEX]->nFlags & OMX_BUFFERFLAG_EOS);
|
|
|
|
OMX_BOOL emptyEOSBuf = OMX_FALSE;
|
|
if (buffers[INPORT_INDEX]->nFilledLen == 0 && buffers[INPORT_INDEX]->nFlags & OMX_BUFFERFLAG_EOS) {
|
|
//meet an empty EOS buffer
|
|
emptyEOSBuf = OMX_TRUE;
|
|
LOGV("ProcessCacheOperation: This frame is Empty EOS buffer\n");
|
|
}
|
|
|
|
if (eInfo.CacheOperation == CACHE_NONE) {
|
|
//nothing to do
|
|
} else if (eInfo.CacheOperation == CACHE_PUSH) {
|
|
mBFrameList.push_front(buffers[INPORT_INDEX]);
|
|
Cached = OMX_TRUE;
|
|
LOGV("ProcessCacheOperation: This B frame is cached\n");
|
|
|
|
} else if (eInfo.CacheOperation == CACHE_POP) {
|
|
eInfo.NotStopFrame = true; //it is also a nstop frame
|
|
|
|
OMX_BUFFERHEADERTYPE *omxbuf = NULL;
|
|
uint32_t i = 0;
|
|
uint32_t bframecount = mBFrameList.size();
|
|
|
|
LOGV("BFrameList size = %d\n", bframecount);
|
|
|
|
while(!mBFrameList.empty()) {
|
|
/*TODO: need to handle null data buffer with EOS
|
|
!NULL EOS case: B1 B2 P(EOS) -> P B1 B2(EOS)
|
|
NULL EOS case: B1 B2 NULL(EOS) -> B2 B1 NULL(EOS)
|
|
*/
|
|
|
|
if (emptyEOSBuf) {
|
|
omxbuf = *mBFrameList.begin();
|
|
ports[INPORT_INDEX]->PushThisBuffer(omxbuf);
|
|
mBFrameList.erase(mBFrameList.begin()); //clear it from internal queue
|
|
|
|
} else {
|
|
omxbuf = *mBFrameList.begin();
|
|
|
|
if (buffers[INPORT_INDEX]->nFlags & OMX_BUFFERFLAG_EOS && i == 0 ) {
|
|
//this is final encode frame, mark it is new EOS and remove original EOS
|
|
omxbuf->nFlags |= OMX_BUFFERFLAG_EOS;
|
|
buffers[INPORT_INDEX]->nFlags &= ~OMX_BUFFERFLAG_EOS;
|
|
} else {
|
|
//all these frames except final B frame in miniGOP can't be stopped at any time
|
|
//to avoid not breaking miniGOP integrity
|
|
if (i > 0) {
|
|
uint32_t tmp = (uint32_t) omxbuf->pPlatformPrivate;
|
|
tmp |= ENC_NSTOP;
|
|
omxbuf->pPlatformPrivate = (OMX_PTR) tmp;
|
|
}
|
|
}
|
|
ports[INPORT_INDEX]->RetainThisBuffer(omxbuf, false); //push bufferq head
|
|
|
|
mBFrameList.erase(mBFrameList.begin()); //clear it from internal queue
|
|
}
|
|
|
|
i++;
|
|
}
|
|
|
|
if (emptyEOSBuf)
|
|
ports[INPORT_INDEX]->PushThisBuffer(buffers[INPORT_INDEX]); //put it at the tail
|
|
|
|
} else if (eInfo.CacheOperation == CACHE_RESET) {
|
|
// mBFrameList.clear();
|
|
}
|
|
|
|
eInfo.CacheOperation = CACHE_NONE;
|
|
|
|
/* restore all states into input OMX buffer
|
|
*/
|
|
if (eInfo.NotStopFrame)
|
|
encodeInfo |= ENC_NSTOP;
|
|
else
|
|
encodeInfo &= ~ENC_NSTOP;
|
|
|
|
SET_CO(encodeInfo, eInfo.CacheOperation);
|
|
buffers[INPORT_INDEX]->pPlatformPrivate = (OMX_PTR) encodeInfo;
|
|
|
|
LOGV("ProcessCacheOperation Completed return %d\n", Cached);
|
|
return Cached;
|
|
}
|
|
|
|
OMX_ERRORTYPE OMXVideoEncoderAVC::ProcessDataRetrieve(
|
|
OMX_BUFFERHEADERTYPE **buffers, OMX_BOOL *outBufReturned) {
|
|
|
|
OMX_NALUFORMATSTYPE NaluFormat = mNalStreamFormat.eNaluFormat;
|
|
|
|
// NaluFormat not set, setting default
|
|
if (NaluFormat == 0) {
|
|
NaluFormat = (OMX_NALUFORMATSTYPE)OMX_NaluFormatStartCodesSeparateFirstHeader;
|
|
mNalStreamFormat.eNaluFormat = NaluFormat;
|
|
}
|
|
|
|
VideoEncOutputBuffer outBuf;
|
|
outBuf.data = buffers[OUTPORT_INDEX]->pBuffer;
|
|
outBuf.bufferSize = buffers[OUTPORT_INDEX]->nAllocLen;
|
|
outBuf.dataSize = 0;
|
|
outBuf.remainingSize = 0;
|
|
outBuf.flag = 0;
|
|
outBuf.timeStamp = 0;
|
|
outBuf.offset = 0;
|
|
|
|
switch (NaluFormat) {
|
|
case OMX_NaluFormatStartCodes:
|
|
outBuf.format = OUTPUT_EVERYTHING;
|
|
break;
|
|
|
|
case OMX_NaluFormatOneNaluPerBuffer:
|
|
outBuf.format = OUTPUT_ONE_NAL;
|
|
break;
|
|
|
|
default:
|
|
if (NaluFormat == (OMX_NALUFORMATSTYPE)OMX_NaluFormatStartCodesSeparateFirstHeader||
|
|
NaluFormat == (OMX_NALUFORMATSTYPE)OMX_NaluFormatLengthPrefixedSeparateFirstHeader){
|
|
if(!mCSDOutputted) {
|
|
LOGV("Output codec data for first frame\n");
|
|
outBuf.format = OUTPUT_CODEC_DATA;
|
|
} else {
|
|
if (NaluFormat == (OMX_NALUFORMATSTYPE)OMX_NaluFormatStartCodesSeparateFirstHeader)
|
|
outBuf.format = OUTPUT_EVERYTHING;
|
|
else
|
|
outBuf.format = OUTPUT_NALULENGTHS_PREFIXED;
|
|
}
|
|
break;
|
|
} else {
|
|
return OMX_ErrorUndefined;
|
|
}
|
|
}
|
|
|
|
//start getOutput
|
|
Encode_Status ret = mVideoEncoder->getOutput(&outBuf, FUNC_NONBLOCK);
|
|
|
|
if (ret < ENCODE_SUCCESS) {
|
|
LOGE("libMIX getOutput Failed. ret = 0x%08x\n", ret);
|
|
outBuf.dataSize = 0;
|
|
outBuf.flag |= ENCODE_BUFFERFLAG_ENDOFFRAME;
|
|
if (ret == ENCODE_NO_REQUEST_DATA) {
|
|
if (mEmptyEOSBuf) {
|
|
//make sure no data encoding in HW, then emit one empty out buffer with EOS
|
|
outBuf.flag |= ENCODE_BUFFERFLAG_ENDOFSTREAM;
|
|
LOGV("no more data encoding, will signal empty EOS output buf\n");
|
|
} else {
|
|
//if not meet Empty EOS buffer, shouldn't get this error
|
|
LOGE("sever error, should not happend here\n");
|
|
//return OMX_ErrorUndefined; //not return error here to avoid omxcodec crash
|
|
}
|
|
}
|
|
|
|
} else if (ret == ENCODE_BUFFER_TOO_SMALL) {
|
|
LOGE("output buffer too small\n");
|
|
// Return code could not be ENCODE_BUFFER_TOO_SMALL, or we will have dead lock issue
|
|
return OMX_ErrorUndefined;
|
|
} else if (ret == ENCODE_DATA_NOT_READY) {
|
|
LOGV("Call libMIX getOutput againe due to 'data not ready'\n");
|
|
ret = mVideoEncoder->getOutput(&outBuf);
|
|
}
|
|
|
|
LOGV("libMIX getOutput data size= %d, flag=0x%08x", outBuf.dataSize, outBuf.flag);
|
|
OMX_U32 outfilledlen = outBuf.dataSize;
|
|
OMX_U32 outoffset = outBuf.offset;
|
|
OMX_S64 outtimestamp = outBuf.timeStamp;
|
|
OMX_U32 outflags = 0;
|
|
|
|
//if codecconfig
|
|
if (outBuf.flag & ENCODE_BUFFERFLAG_CODECCONFIG)
|
|
outflags |= OMX_BUFFERFLAG_CODECCONFIG;
|
|
|
|
//if syncframe
|
|
if (outBuf.flag & ENCODE_BUFFERFLAG_SYNCFRAME)
|
|
outflags |= OMX_BUFFERFLAG_SYNCFRAME;
|
|
|
|
//if eos
|
|
if (outBuf.flag & ENCODE_BUFFERFLAG_ENDOFSTREAM)
|
|
outflags |= OMX_BUFFERFLAG_EOS;
|
|
|
|
//if full encoded data retrieved
|
|
if(outBuf.flag & ENCODE_BUFFERFLAG_ENDOFFRAME) {
|
|
LOGV("got a complete libmix Frame\n");
|
|
outflags |= OMX_BUFFERFLAG_ENDOFFRAME;
|
|
|
|
if ((NaluFormat == (OMX_NALUFORMATSTYPE)OMX_NaluFormatStartCodesSeparateFirstHeader
|
|
|| NaluFormat == (OMX_NALUFORMATSTYPE)OMX_NaluFormatLengthPrefixedSeparateFirstHeader )
|
|
&& !mCSDOutputted && outfilledlen > 0) {
|
|
mCSDOutputted = OMX_TRUE;
|
|
|
|
} else {
|
|
ports[INPORT_INDEX]->ReturnOneRetainedBuffer(); //return one retained frame from head
|
|
mFrameOutputCount ++;
|
|
}
|
|
}
|
|
|
|
if (outfilledlen == 0) {
|
|
if (mEmptyEOSBuf) {
|
|
//emit empty EOS out buf since meet empty EOS input buf
|
|
buffers[OUTPORT_INDEX]->nFilledLen = 0;
|
|
buffers[OUTPORT_INDEX]->nTimeStamp = 0;
|
|
buffers[OUTPORT_INDEX]->nFlags = outflags;
|
|
*outBufReturned = OMX_TRUE;
|
|
LOGV("emit one empty EOS OMX output buf = %p:%d, flag = 0x%08x, ts=%lld", buffers[OUTPORT_INDEX]->pBuffer, outfilledlen, outflags, outtimestamp);
|
|
} else
|
|
//not emit out buf since something wrong
|
|
*outBufReturned = OMX_FALSE;
|
|
|
|
} else {
|
|
buffers[OUTPORT_INDEX]->nOffset = outoffset;
|
|
buffers[OUTPORT_INDEX]->nFilledLen = outfilledlen;
|
|
buffers[OUTPORT_INDEX]->nTimeStamp = outtimestamp;
|
|
buffers[OUTPORT_INDEX]->nFlags = outflags;
|
|
if (outBuf.flag & ENCODE_BUFFERFLAG_NSTOPFRAME)
|
|
buffers[OUTPORT_INDEX]->pPlatformPrivate = (OMX_PTR) 0x00000001; //indicate it is nstop frame
|
|
*outBufReturned = OMX_TRUE;
|
|
LOGV("emit one OMX output buf = %p:%d, flag = 0x%08x, ts=%lld", buffers[OUTPORT_INDEX]->pBuffer, outfilledlen, outflags, outtimestamp);
|
|
|
|
}
|
|
|
|
LOGV("ProcessDataRetrieve OK, mFrameEncodedCount=%d , mFrameOutputCount=%d\n", mFrameEncodedCount, mFrameOutputCount);
|
|
return OMX_ErrorNone;
|
|
}
|
|
|
|
OMX_ERRORTYPE OMXVideoEncoderAVC::ProcessorProcess(
|
|
OMX_BUFFERHEADERTYPE **buffers,
|
|
buffer_retain_t *retains,
|
|
OMX_U32) {
|
|
|
|
OMX_ERRORTYPE oret = OMX_ErrorNone;
|
|
Encode_Status ret = ENCODE_SUCCESS;
|
|
|
|
bool FrameEncoded = false;
|
|
|
|
if (buffers[INPORT_INDEX]) {
|
|
LOGV("input buffer has new frame\n");
|
|
|
|
//get frame encode info
|
|
Encode_Info eInfo;
|
|
uint32_t encodeInfo = (uint32_t) buffers[INPORT_INDEX]->pPlatformPrivate;
|
|
eInfo.FrameType = GET_FT(encodeInfo);
|
|
eInfo.CacheOperation = GET_CO(encodeInfo);
|
|
eInfo.NotStopFrame = encodeInfo & ENC_NSTOP;
|
|
eInfo.FrameCount = GET_FC(encodeInfo);
|
|
|
|
//handle frame cache operation
|
|
if (ProcessCacheOperation(buffers)) {
|
|
//frame is cached, nothing should be done in this case, just store status and return
|
|
retains[INPORT_INDEX] = BUFFER_RETAIN_CACHE;
|
|
retains[OUTPORT_INDEX] = BUFFER_RETAIN_GETAGAIN;
|
|
return OMX_ErrorNone;
|
|
}
|
|
|
|
//try encode if frame is not cached
|
|
VideoEncRawBuffer inBuf;
|
|
|
|
inBuf.data = buffers[INPORT_INDEX]->pBuffer + buffers[INPORT_INDEX]->nOffset;
|
|
inBuf.size = buffers[INPORT_INDEX]->nFilledLen;
|
|
inBuf.flag = 0;
|
|
inBuf.timeStamp = buffers[INPORT_INDEX]->nTimeStamp;
|
|
|
|
if (inBuf.size == 0 && buffers[INPORT_INDEX]->nFlags & OMX_BUFFERFLAG_EOS) {
|
|
//meet an empty EOS buffer, retain it directly and return from here
|
|
retains[INPORT_INDEX] = BUFFER_RETAIN_ACCUMULATE;
|
|
retains[OUTPORT_INDEX] = BUFFER_RETAIN_GETAGAIN;
|
|
mEmptyEOSBuf = OMX_TRUE;
|
|
return OMX_ErrorNone;
|
|
}
|
|
|
|
if (buffers[INPORT_INDEX]->nFlags & OMX_BUFFERFLAG_EOS)
|
|
inBuf.flag |= ENCODE_BUFFERFLAG_ENDOFSTREAM;
|
|
if (eInfo.NotStopFrame)
|
|
inBuf.flag |= ENCODE_BUFFERFLAG_NSTOPFRAME;
|
|
inBuf.type = (FrameType) eInfo.FrameType;
|
|
|
|
LOGV("start libmix encoding\n");
|
|
// encode and setConfig need to be thread safe
|
|
pthread_mutex_lock(&mSerializationLock);
|
|
ret = mVideoEncoder->encode(&inBuf, FUNC_NONBLOCK);
|
|
pthread_mutex_unlock(&mSerializationLock);
|
|
LOGV("end libmix encoding\n");
|
|
|
|
retains[INPORT_INDEX] = BUFFER_RETAIN_NOT_RETAIN;
|
|
if (ret == ENCODE_DEVICE_BUSY) {
|
|
//encoder is busy, put buf back and come again
|
|
LOGV("encoder is busy, push buffer back to get again\n");
|
|
retains[INPORT_INDEX] = BUFFER_RETAIN_GETAGAIN;
|
|
} else {
|
|
//if error, this buf will be returned
|
|
CHECK_ENCODE_STATUS("encode");
|
|
|
|
LOGV("put buffer to encoder and retain this buffer\n");
|
|
mFrameEncodedCount ++;
|
|
FrameEncoded = true;
|
|
retains[INPORT_INDEX] = BUFFER_RETAIN_ACCUMULATE;
|
|
}
|
|
|
|
} else {
|
|
//no new coming frames, but maybe still have frames not outputted
|
|
LOGV("input buffer is null\n");
|
|
}
|
|
|
|
retains[OUTPORT_INDEX] = BUFFER_RETAIN_GETAGAIN; //set to default value
|
|
//just call getoutput if no frame encoded in this cycle to avoid retained buffer queue wrong state
|
|
if (!FrameEncoded) {
|
|
OMX_BOOL OutBufReturned = OMX_FALSE;
|
|
oret = ProcessDataRetrieve(buffers, &OutBufReturned);
|
|
if (OutBufReturned)
|
|
retains[OUTPORT_INDEX] = BUFFER_RETAIN_NOT_RETAIN;
|
|
}
|
|
|
|
LOGV("ProcessorProcess ret=%x", oret);
|
|
return oret;
|
|
|
|
}
|
|
|
|
OMX_ERRORTYPE OMXVideoEncoderAVC::BuildHandlerList(void) {
|
|
OMXVideoEncoderBase::BuildHandlerList();
|
|
AddHandler(OMX_IndexParamVideoAvc, GetParamVideoAvc, SetParamVideoAvc);
|
|
AddHandler((OMX_INDEXTYPE)OMX_IndexParamNalStreamFormat, GetParamNalStreamFormat, SetParamNalStreamFormat);
|
|
AddHandler((OMX_INDEXTYPE)OMX_IndexParamNalStreamFormatSupported, GetParamNalStreamFormatSupported, SetParamNalStreamFormatSupported);
|
|
AddHandler((OMX_INDEXTYPE)OMX_IndexParamNalStreamFormatSelect, GetParamNalStreamFormatSelect, SetParamNalStreamFormatSelect);
|
|
AddHandler(OMX_IndexConfigVideoAVCIntraPeriod, GetConfigVideoAVCIntraPeriod, SetConfigVideoAVCIntraPeriod);
|
|
AddHandler(OMX_IndexConfigVideoNalSize, GetConfigVideoNalSize, SetConfigVideoNalSize);
|
|
AddHandler((OMX_INDEXTYPE)OMX_IndexConfigIntelSliceNumbers, GetConfigIntelSliceNumbers, SetConfigIntelSliceNumbers);
|
|
AddHandler((OMX_INDEXTYPE)OMX_IndexParamIntelAVCVUI, GetParamIntelAVCVUI, SetParamIntelAVCVUI);
|
|
AddHandler((OMX_INDEXTYPE)OMX_IndexParamVideoBytestream, GetParamVideoBytestream, SetParamVideoBytestream);
|
|
AddHandler((OMX_INDEXTYPE)OMX_IndexParamVideoProfileLevelQuerySupported, GetParamVideoProfileLevelQuerySupported, SetParamVideoProfileLevelQuerySupported);
|
|
return OMX_ErrorNone;
|
|
}
|
|
|
|
OMX_ERRORTYPE OMXVideoEncoderAVC::GetParamVideoProfileLevelQuerySupported(OMX_PTR pStructure) {
|
|
OMX_ERRORTYPE ret;
|
|
OMX_VIDEO_PARAM_PROFILELEVELTYPE *p = (OMX_VIDEO_PARAM_PROFILELEVELTYPE *)pStructure;
|
|
CHECK_TYPE_HEADER(p);
|
|
CHECK_PORT_INDEX(p, OUTPORT_INDEX);
|
|
|
|
CHECK_ENUMERATION_RANGE(p->nProfileIndex,mPLTableCount);
|
|
|
|
p->eProfile = mPLTable[p->nProfileIndex].profile;
|
|
p->eLevel = mPLTable[p->nProfileIndex].level;
|
|
|
|
return OMX_ErrorNone;
|
|
}
|
|
|
|
OMX_ERRORTYPE OMXVideoEncoderAVC::SetParamVideoProfileLevelQuerySupported(OMX_PTR) {
|
|
LOGW("SetParamVideoAVCProfileLevel is not supported.");
|
|
return OMX_ErrorUnsupportedSetting;
|
|
}
|
|
|
|
OMX_ERRORTYPE OMXVideoEncoderAVC::GetParamVideoAvc(OMX_PTR pStructure) {
|
|
OMX_ERRORTYPE ret;
|
|
OMX_VIDEO_PARAM_AVCTYPE *p = (OMX_VIDEO_PARAM_AVCTYPE *)pStructure;
|
|
CHECK_TYPE_HEADER(p);
|
|
CHECK_PORT_INDEX(p, OUTPORT_INDEX);
|
|
|
|
mVideoEncoder->getParameters(mAVCParams);
|
|
if(mParamAvc.eProfile == OMX_VIDEO_AVCProfileHigh)
|
|
{
|
|
mAVCParams->bEntropyCodingCABAC = 1;
|
|
mAVCParams->bDirect8x8Inference = 1;
|
|
}
|
|
mParamAvc.bEntropyCodingCABAC = (OMX_BOOL)mAVCParams->bEntropyCodingCABAC;
|
|
mParamAvc.bWeightedPPrediction = (OMX_BOOL)mAVCParams->bWeightedPPrediction;
|
|
mParamAvc.nRefIdx10ActiveMinus1 = mAVCParams->refIdx10ActiveMinus1;
|
|
mParamAvc.nRefIdx11ActiveMinus1 = mAVCParams->refIdx11ActiveMinus1;
|
|
mParamAvc.nWeightedBipredicitonMode = mAVCParams->weightedBipredicitonMode;
|
|
mParamAvc.bDirect8x8Inference = (OMX_BOOL)mAVCParams->bDirect8x8Inference;
|
|
mParamAvc.bDirectSpatialTemporal = (OMX_BOOL)mAVCParams->bDirectSpatialTemporal;
|
|
mParamAvc.nCabacInitIdc = mAVCParams->cabacInitIdc;
|
|
mParamAvc.bFrameMBsOnly = (OMX_BOOL)mAVCParams->bFrameMBsOnly;
|
|
mParamAvc.bconstIpred = (OMX_BOOL)mAVCParams->bConstIpred;
|
|
memcpy(p, &mParamAvc, sizeof(*p));
|
|
return OMX_ErrorNone;
|
|
}
|
|
|
|
OMX_ERRORTYPE OMXVideoEncoderAVC::SetParamVideoAvc(OMX_PTR pStructure) {
|
|
OMX_ERRORTYPE ret;
|
|
OMX_VIDEO_PARAM_AVCTYPE *p = (OMX_VIDEO_PARAM_AVCTYPE *)pStructure;
|
|
CHECK_TYPE_HEADER(p);
|
|
CHECK_PORT_INDEX(p, OUTPORT_INDEX);
|
|
CHECK_SET_PARAM_STATE();
|
|
|
|
//Check if parameters are valid
|
|
|
|
if(p->bEnableASO == OMX_TRUE)
|
|
return OMX_ErrorUnsupportedSetting;
|
|
|
|
if(p->bEnableFMO == OMX_TRUE)
|
|
return OMX_ErrorUnsupportedSetting;
|
|
|
|
if(p->bEnableUEP == OMX_TRUE)
|
|
return OMX_ErrorUnsupportedSetting;
|
|
|
|
if(p->bEnableRS == OMX_TRUE)
|
|
return OMX_ErrorUnsupportedSetting;
|
|
|
|
if (p->eProfile == OMX_VIDEO_AVCProfileBaseline &&
|
|
(p->nAllowedPictureTypes & OMX_VIDEO_PictureTypeB) )
|
|
return OMX_ErrorBadParameter;
|
|
|
|
if (p->nAllowedPictureTypes & OMX_VIDEO_PictureTypeP && (p->nPFrames == 0))
|
|
return OMX_ErrorBadParameter;
|
|
|
|
if (p->nAllowedPictureTypes & OMX_VIDEO_PictureTypeB ) {
|
|
if (p->nBFrames == 0)
|
|
return OMX_ErrorBadParameter;
|
|
|
|
//IpPeriod must be integer
|
|
uint32_t IntraPeriod = mParamAvc.nPFrames + mParamAvc.nBFrames ;
|
|
if (IntraPeriod % mParamAvc.nPFrames != 0)
|
|
return OMX_ErrorBadParameter;
|
|
|
|
//IntraPeriod must be multipe of IpPeriod.
|
|
uint32_t IpPeriod = IntraPeriod /mParamAvc.nPFrames;
|
|
if (IntraPeriod % IpPeriod != 0)
|
|
return OMX_ErrorBadParameter;
|
|
}
|
|
|
|
// TODO: do we need to check if port is enabled?
|
|
// TODO: see SetPortAvcParam implementation - Can we make simple copy????
|
|
memcpy(&mParamAvc, p, sizeof(mParamAvc));
|
|
mVideoEncoder->getParameters(mAVCParams);
|
|
mAVCParams->bEntropyCodingCABAC = mParamAvc.bEntropyCodingCABAC;
|
|
mAVCParams->bDirect8x8Inference = mParamAvc.bDirect8x8Inference;
|
|
if(mParamAvc.eProfile == OMX_VIDEO_AVCProfileBaseline){
|
|
mAVCParams->bEntropyCodingCABAC = 0;
|
|
mAVCParams->bDirect8x8Inference = 0;
|
|
}
|
|
mVideoEncoder->setParameters(mAVCParams);
|
|
|
|
|
|
return OMX_ErrorNone;
|
|
}
|
|
|
|
OMX_ERRORTYPE OMXVideoEncoderAVC::GetParamNalStreamFormat(OMX_PTR pStructure) {
|
|
OMX_ERRORTYPE ret;
|
|
OMX_NALSTREAMFORMATTYPE *p = (OMX_NALSTREAMFORMATTYPE *)pStructure;
|
|
|
|
CHECK_TYPE_HEADER(p);
|
|
CHECK_PORT_INDEX(p, OUTPORT_INDEX);
|
|
// TODO: check if this is desired format
|
|
p->eNaluFormat = mNalStreamFormat.eNaluFormat; //OMX_NaluFormatStartCodes;
|
|
return OMX_ErrorNone;
|
|
}
|
|
|
|
OMX_ERRORTYPE OMXVideoEncoderAVC::SetParamNalStreamFormat(OMX_PTR pStructure) {
|
|
OMX_ERRORTYPE ret;
|
|
OMX_NALSTREAMFORMATTYPE *p = (OMX_NALSTREAMFORMATTYPE *)pStructure;
|
|
|
|
CHECK_TYPE_HEADER(p);
|
|
CHECK_PORT_INDEX(p, OUTPORT_INDEX);
|
|
LOGV("p->eNaluFormat =%d\n",p->eNaluFormat);
|
|
if(p->eNaluFormat != OMX_NaluFormatStartCodes &&
|
|
p->eNaluFormat != (OMX_NALUFORMATSTYPE)OMX_NaluFormatStartCodesSeparateFirstHeader &&
|
|
p->eNaluFormat != OMX_NaluFormatOneNaluPerBuffer &&
|
|
p->eNaluFormat != (OMX_NALUFORMATSTYPE)OMX_NaluFormatLengthPrefixedSeparateFirstHeader) {
|
|
LOGE("Format not support\n");
|
|
return OMX_ErrorUnsupportedSetting;
|
|
}
|
|
mNalStreamFormat.eNaluFormat = p->eNaluFormat;
|
|
return OMX_ErrorNone;
|
|
}
|
|
|
|
OMX_ERRORTYPE OMXVideoEncoderAVC::GetParamNalStreamFormatSupported(OMX_PTR pStructure) {
|
|
OMX_ERRORTYPE ret;
|
|
OMX_NALSTREAMFORMATTYPE *p = (OMX_NALSTREAMFORMATTYPE *)pStructure;
|
|
|
|
CHECK_TYPE_HEADER(p);
|
|
CHECK_PORT_INDEX(p, OUTPORT_INDEX);
|
|
p->eNaluFormat = (OMX_NALUFORMATSTYPE)
|
|
(OMX_NaluFormatStartCodes |
|
|
OMX_NaluFormatStartCodesSeparateFirstHeader |
|
|
OMX_NaluFormatOneNaluPerBuffer|
|
|
OMX_NaluFormatLengthPrefixedSeparateFirstHeader);
|
|
|
|
// TODO: check if this is desired format
|
|
// OMX_NaluFormatFourByteInterleaveLength |
|
|
// OMX_NaluFormatZeroByteInterleaveLength);
|
|
return OMX_ErrorNone;
|
|
}
|
|
|
|
OMX_ERRORTYPE OMXVideoEncoderAVC::SetParamNalStreamFormatSupported(OMX_PTR) {
|
|
LOGW("SetParamNalStreamFormatSupported is not supported.");
|
|
return OMX_ErrorUnsupportedSetting;
|
|
}
|
|
|
|
OMX_ERRORTYPE OMXVideoEncoderAVC::GetParamNalStreamFormatSelect(OMX_PTR) {
|
|
LOGW("GetParamNalStreamFormatSelect is not supported.");
|
|
return OMX_ErrorUnsupportedSetting;
|
|
}
|
|
|
|
OMX_ERRORTYPE OMXVideoEncoderAVC::SetParamNalStreamFormatSelect(OMX_PTR pStructure) {
|
|
OMX_ERRORTYPE ret;
|
|
OMX_NALSTREAMFORMATTYPE *p = (OMX_NALSTREAMFORMATTYPE *)pStructure;
|
|
CHECK_TYPE_HEADER(p);
|
|
CHECK_PORT_INDEX(p, OUTPORT_INDEX);
|
|
|
|
// return OMX_ErrorIncorrectStateOperation if not in Loaded state
|
|
CHECK_SET_PARAM_STATE();
|
|
|
|
if (p->eNaluFormat != OMX_NaluFormatStartCodes &&
|
|
p->eNaluFormat != (OMX_NALUFORMATSTYPE)OMX_NaluFormatStartCodesSeparateFirstHeader &&
|
|
p->eNaluFormat != OMX_NaluFormatOneNaluPerBuffer&&
|
|
p->eNaluFormat != (OMX_NALUFORMATSTYPE)OMX_NaluFormatLengthPrefixedSeparateFirstHeader) {
|
|
//p->eNaluFormat != OMX_NaluFormatFourByteInterleaveLength &&
|
|
//p->eNaluFormat != OMX_NaluFormatZeroByteInterleaveLength) {
|
|
// TODO: check if this is desried
|
|
return OMX_ErrorBadParameter;
|
|
}
|
|
|
|
mNalStreamFormat = *p;
|
|
return OMX_ErrorNone;
|
|
}
|
|
|
|
OMX_ERRORTYPE OMXVideoEncoderAVC::GetConfigVideoAVCIntraPeriod(OMX_PTR pStructure) {
|
|
OMX_ERRORTYPE ret;
|
|
OMX_VIDEO_CONFIG_AVCINTRAPERIOD *p = (OMX_VIDEO_CONFIG_AVCINTRAPERIOD *)pStructure;
|
|
|
|
CHECK_TYPE_HEADER(p);
|
|
CHECK_PORT_INDEX(p, OUTPORT_INDEX);
|
|
// TODO: populate mConfigAvcIntraPeriod from VideoEncoder
|
|
// return OMX_ErrorNotReady if VideoEncoder is not created.
|
|
memcpy(p, &mConfigAvcIntraPeriod, sizeof(*p));
|
|
return OMX_ErrorNone;
|
|
}
|
|
|
|
OMX_ERRORTYPE OMXVideoEncoderAVC::SetConfigVideoAVCIntraPeriod(OMX_PTR pStructure) {
|
|
OMX_ERRORTYPE ret;
|
|
Encode_Status retStatus = ENCODE_SUCCESS;
|
|
OMX_VIDEO_CONFIG_AVCINTRAPERIOD *p = (OMX_VIDEO_CONFIG_AVCINTRAPERIOD *)pStructure;
|
|
CHECK_TYPE_HEADER(p);
|
|
CHECK_PORT_INDEX(p, OUTPORT_INDEX);
|
|
|
|
// return OMX_ErrorNone if not in Executing state
|
|
// TODO: return OMX_ErrorIncorrectStateOperation?
|
|
CHECK_SET_CONFIG_STATE();
|
|
|
|
//check if parameters are valid
|
|
if ( ( (mParamAvc.nAllowedPictureTypes & OMX_VIDEO_PictureTypeP) ||
|
|
(mParamAvc.nAllowedPictureTypes & OMX_VIDEO_PictureTypeB) ) &&
|
|
p->nPFrames == 0 )
|
|
return OMX_ErrorBadParameter;
|
|
|
|
// TODO: apply AVC Intra Period configuration in Executing state
|
|
VideoConfigAVCIntraPeriod avcIntraPreriod;
|
|
|
|
if (mParamAvc.nAllowedPictureTypes & OMX_VIDEO_PictureTypeB) {
|
|
avcIntraPreriod.intraPeriod = p->nPFrames;
|
|
if (p->nPFrames % mParamAvc.nBFrames != 0)
|
|
return OMX_ErrorBadParameter;
|
|
avcIntraPreriod.ipPeriod = p->nPFrames / mParamAvc.nBFrames;
|
|
|
|
if (avcIntraPreriod.intraPeriod % avcIntraPreriod.ipPeriod != 0)
|
|
return OMX_ErrorBadParameter;
|
|
|
|
avcIntraPreriod.idrInterval = p->nIDRPeriod;
|
|
} else {
|
|
avcIntraPreriod.intraPeriod = p->nPFrames + 1;
|
|
avcIntraPreriod.ipPeriod = 1;
|
|
if (avcIntraPreriod.intraPeriod == 0)
|
|
avcIntraPreriod.idrInterval = 0;
|
|
else
|
|
avcIntraPreriod.idrInterval = p->nIDRPeriod;
|
|
}
|
|
|
|
retStatus = mVideoEncoder->setConfig(&avcIntraPreriod);
|
|
if(retStatus != ENCODE_SUCCESS) {
|
|
LOGW("set avc intra period config failed");
|
|
}
|
|
|
|
mEncoderParams->intraPeriod = avcIntraPreriod.intraPeriod;
|
|
mAVCParams->idrInterval = avcIntraPreriod.idrInterval;
|
|
mAVCParams->ipPeriod = avcIntraPreriod.ipPeriod;
|
|
|
|
mConfigAvcIntraPeriod = *p;
|
|
mConfigAvcIntraPeriod.nIDRPeriod = avcIntraPreriod.idrInterval;
|
|
|
|
return OMX_ErrorNone;
|
|
}
|
|
|
|
OMX_ERRORTYPE OMXVideoEncoderAVC::GetConfigVideoNalSize(OMX_PTR pStructure) {
|
|
OMX_ERRORTYPE ret;
|
|
OMX_VIDEO_CONFIG_NALSIZE *p = (OMX_VIDEO_CONFIG_NALSIZE *)pStructure;
|
|
|
|
CHECK_TYPE_HEADER(p);
|
|
CHECK_PORT_INDEX(p, OUTPORT_INDEX);
|
|
memcpy(p, &mConfigNalSize, sizeof(*p));
|
|
return OMX_ErrorNone;
|
|
}
|
|
|
|
OMX_ERRORTYPE OMXVideoEncoderAVC::SetConfigVideoNalSize(OMX_PTR pStructure) {
|
|
OMX_ERRORTYPE ret;
|
|
Encode_Status retStatus = ENCODE_SUCCESS;
|
|
if (mParamBitrate.eControlRate == OMX_Video_ControlRateMax) {
|
|
LOGE("SetConfigVideoNalSize failed. Feature is disabled.");
|
|
return OMX_ErrorUnsupportedIndex;
|
|
}
|
|
OMX_VIDEO_CONFIG_NALSIZE *p = (OMX_VIDEO_CONFIG_NALSIZE *)pStructure;
|
|
CHECK_TYPE_HEADER(p);
|
|
CHECK_PORT_INDEX(p, OUTPORT_INDEX);
|
|
|
|
// set in either Loaded state (ComponentSetParam) or Executing state (ComponentSetConfig)
|
|
mConfigNalSize = *p;
|
|
|
|
// return OMX_ErrorNone if not in Executing state
|
|
// TODO: return OMX_ErrorIncorrectStateOperation?
|
|
CHECK_SET_CONFIG_STATE();
|
|
|
|
if (mParamBitrate.eControlRate != (OMX_VIDEO_CONTROLRATETYPE)OMX_Video_Intel_ControlRateVideoConferencingMode) {
|
|
LOGE("SetConfigVideoNalSize failed. Feature is supported only in VCM.");
|
|
return OMX_ErrorUnsupportedSetting;
|
|
}
|
|
VideoConfigNALSize configNalSize;
|
|
configNalSize.maxSliceSize = mConfigNalSize.nNaluBytes * 8;
|
|
retStatus = mVideoEncoder->setConfig(&configNalSize);
|
|
if(retStatus != ENCODE_SUCCESS) {
|
|
LOGW("set NAL size config failed");
|
|
}
|
|
return OMX_ErrorNone;
|
|
}
|
|
|
|
OMX_ERRORTYPE OMXVideoEncoderAVC::GetConfigIntelSliceNumbers(OMX_PTR pStructure) {
|
|
OMX_ERRORTYPE ret;
|
|
OMX_VIDEO_CONFIG_INTEL_SLICE_NUMBERS *p = (OMX_VIDEO_CONFIG_INTEL_SLICE_NUMBERS *)pStructure;
|
|
|
|
CHECK_TYPE_HEADER(p);
|
|
CHECK_PORT_INDEX(p, OUTPORT_INDEX);
|
|
memcpy(p, &mConfigIntelSliceNumbers, sizeof(*p));
|
|
return OMX_ErrorNone;
|
|
}
|
|
|
|
OMX_ERRORTYPE OMXVideoEncoderAVC::SetConfigIntelSliceNumbers(OMX_PTR pStructure) {
|
|
OMX_ERRORTYPE ret;
|
|
Encode_Status retStatus = ENCODE_SUCCESS;
|
|
if (mParamBitrate.eControlRate == OMX_Video_ControlRateMax) {
|
|
LOGE("SetConfigIntelSliceNumbers failed. Feature is disabled.");
|
|
return OMX_ErrorUnsupportedIndex;
|
|
}
|
|
OMX_VIDEO_CONFIG_INTEL_SLICE_NUMBERS *p = (OMX_VIDEO_CONFIG_INTEL_SLICE_NUMBERS *)pStructure;
|
|
CHECK_TYPE_HEADER(p);
|
|
CHECK_PORT_INDEX(p, OUTPORT_INDEX);
|
|
|
|
// set in either Loaded state (ComponentSetParam) or Executing state (ComponentSetConfig)
|
|
mConfigIntelSliceNumbers = *p;
|
|
|
|
// return OMX_ErrorNone if not in Executing state
|
|
// TODO: return OMX_ErrorIncorrectStateOperation?
|
|
CHECK_SET_CONFIG_STATE();
|
|
|
|
if (mParamBitrate.eControlRate != (OMX_VIDEO_CONTROLRATETYPE)OMX_Video_Intel_ControlRateVideoConferencingMode) {
|
|
LOGE("SetConfigIntelSliceNumbers failed. Feature is supported only in VCM.");
|
|
return OMX_ErrorUnsupportedSetting;
|
|
}
|
|
VideoConfigSliceNum sliceNum;
|
|
sliceNum.sliceNum.iSliceNum = mConfigIntelSliceNumbers.nISliceNumber;
|
|
sliceNum.sliceNum.pSliceNum = mConfigIntelSliceNumbers.nPSliceNumber;
|
|
retStatus = mVideoEncoder->setConfig(&sliceNum);
|
|
if(retStatus != ENCODE_SUCCESS) {
|
|
LOGW("set silce num config failed!\n");
|
|
}
|
|
return OMX_ErrorNone;
|
|
}
|
|
|
|
OMX_ERRORTYPE OMXVideoEncoderAVC::GetParamIntelAVCVUI(OMX_PTR pStructure) {
|
|
|
|
OMX_ERRORTYPE ret;
|
|
OMX_VIDEO_PARAM_INTEL_AVCVUI *p = (OMX_VIDEO_PARAM_INTEL_AVCVUI *)pStructure;
|
|
|
|
CHECK_TYPE_HEADER(p);
|
|
CHECK_PORT_INDEX(p, OUTPORT_INDEX);
|
|
memcpy(p, &mParamIntelAvcVui, sizeof(*p));
|
|
|
|
return OMX_ErrorNone;
|
|
}
|
|
|
|
OMX_ERRORTYPE OMXVideoEncoderAVC::SetParamIntelAVCVUI(OMX_PTR pStructure) {
|
|
|
|
OMX_ERRORTYPE ret;
|
|
OMX_VIDEO_PARAM_INTEL_AVCVUI *p = (OMX_VIDEO_PARAM_INTEL_AVCVUI *)pStructure;
|
|
CHECK_TYPE_HEADER(p);
|
|
CHECK_PORT_INDEX(p, OUTPORT_INDEX);
|
|
|
|
// set only in Loaded state (ComponentSetParam)
|
|
CHECK_SET_PARAM_STATE();
|
|
|
|
mParamIntelAvcVui = *p;
|
|
return OMX_ErrorNone;
|
|
}
|
|
|
|
OMX_ERRORTYPE OMXVideoEncoderAVC::GetParamVideoBytestream(OMX_PTR) {
|
|
return OMX_ErrorUnsupportedSetting;
|
|
}
|
|
|
|
OMX_ERRORTYPE OMXVideoEncoderAVC::SetParamVideoBytestream(OMX_PTR pStructure) {
|
|
OMX_ERRORTYPE ret;
|
|
OMX_VIDEO_PARAM_BYTESTREAMTYPE *p = (OMX_VIDEO_PARAM_BYTESTREAMTYPE *)pStructure;
|
|
CHECK_TYPE_HEADER(p);
|
|
CHECK_PORT_INDEX(p, OUTPORT_INDEX);
|
|
|
|
// set only in Loaded state (ComponentSetParam)
|
|
CHECK_SET_PARAM_STATE();
|
|
|
|
if (p->bBytestream == OMX_TRUE) {
|
|
mNalStreamFormat.eNaluFormat = OMX_NaluFormatStartCodes;
|
|
} else {
|
|
// TODO: do we need to override the Nalu format?
|
|
mNalStreamFormat.eNaluFormat = (OMX_NALUFORMATSTYPE)OMX_NaluFormatZeroByteInterleaveLength;
|
|
}
|
|
|
|
return OMX_ErrorNone;
|
|
}
|
|
|
|
|
|
DECLARE_OMX_COMPONENT("OMX.Intel.VideoEncoder.AVC", "video_encoder.avc", OMXVideoEncoderAVC);
|