/*
* 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_NDEBUG 0
#define LOG_TAG "PVSoftMPEG4Encoder"
#include <wrs_omxil_core/log.h>
#include "mp4enc_api.h"
#include "OMX_Video.h"
#include <media/stagefright/foundation/ADebug.h>
#include <media/stagefright/MediaDefs.h>
#include <media/stagefright/MediaErrors.h>
#include <media/stagefright/MetaData.h>
#include <media/stagefright/Utils.h>
#include <ui/GraphicBufferMapper.h>
#include <ui/Rect.h>
#include "PVSoftMPEG4Encoder.h"
#include "VideoEncoderLog.h"
#define ALIGN(x, align) (((x) + (align) - 1) & (~((align) - 1)))
inline static void ConvertYUV420SemiPlanarToYUV420Planar(
uint8_t *inyuv, uint8_t* outyuv,
int32_t width, int32_t height) {
int32_t outYsize = width * height;
uint32_t *outy = (uint32_t *) outyuv;
uint16_t *outcb = (uint16_t *) (outyuv + outYsize);
uint16_t *outcr = (uint16_t *) (outyuv + outYsize + (outYsize >> 2));
/* Y copying */
memcpy(outy, inyuv, outYsize);
/* U & V copying */
uint32_t *inyuv_4 = (uint32_t *) (inyuv + outYsize);
for (int32_t i = height >> 1; i > 0; --i) {
for (int32_t j = width >> 2; j > 0; --j) {
uint32_t temp = *inyuv_4++;
uint32_t tempU = temp & 0xFF;
tempU = tempU | ((temp >> 8) & 0xFF00);
uint32_t tempV = (temp >> 8) & 0xFF;
tempV = tempV | ((temp >> 16) & 0xFF00);
// Flip U and V
*outcb++ = tempU;
*outcr++ = tempV;
}
}
}
inline static void trimBuffer(uint8_t *dataIn, uint8_t *dataOut,
int32_t width, int32_t height,
int32_t alignedHeight, int32_t stride) {
int32_t h;
uint8_t *y_start, *uv_start, *_y_start, *_uv_start;
y_start = dataOut;
uv_start = dataOut + width * height;
_y_start = dataIn;
_uv_start = dataIn + stride * alignedHeight;
for (h = 0; h < height; h++)
memcpy(y_start + h * width, _y_start + h * stride, width);
for (h = 0; h < height / 2; h++)
memcpy(uv_start + h * width,
_uv_start + h * stride, width);
}
PVSoftMPEG4Encoder::PVSoftMPEG4Encoder(const char *name)
: mEncodeMode(COMBINE_MODE_WITH_ERR_RES),
mVideoWidth(176),
mVideoHeight(144),
mVideoFrameRate(30),
mVideoBitRate(192000),
mVideoColorFormat(OMX_COLOR_FormatYUV420SemiPlanar),
mStoreMetaDataInBuffers(false),
mIDRFrameRefreshIntervalInSec(1),
mNumInputFrames(-1),
mStarted(false),
mSawInputEOS(false),
mSignalledError(false),
mHandle(new tagvideoEncControls),
mEncParams(new tagvideoEncOptions),
mInputFrameData(NULL)
{
if (!strcmp(name, "OMX.google.h263.encoder")) {
mEncodeMode = H263_MODE;
LOG_I("construct h263 encoder");
} else {
CHECK(!strcmp(name, "OMX.google.mpeg4.encoder"));
LOG_I("construct mpeg4 encoder");
}
setDefaultParams();
#if NO_BUFFER_SHARE
mVASurfaceMappingAction |= MAPACT_COPY;
#endif
LOG_I("Construct PVSoftMPEG4Encoder");
}
PVSoftMPEG4Encoder::~PVSoftMPEG4Encoder() {
LOG_I("Destruct PVSoftMPEG4Encoder");
releaseEncoder();
}
void PVSoftMPEG4Encoder::setDefaultParams() {
// Set default value for input parameters
mComParams.profile = VAProfileH264Baseline;
mComParams.level = 41;
mComParams.rawFormat = RAW_FORMAT_NV12;
mComParams.frameRate.frameRateNum = 30;
mComParams.frameRate.frameRateDenom = 1;
mComParams.resolution.width = 0;
mComParams.resolution.height = 0;
mComParams.intraPeriod = 30;
mComParams.rcMode = RATE_CONTROL_NONE;
mComParams.rcParams.initQP = 15;
mComParams.rcParams.minQP = 0;
mComParams.rcParams.bitRate = 640000;
mComParams.rcParams.targetPercentage= 0;
mComParams.rcParams.windowSize = 0;
mComParams.rcParams.disableFrameSkip = 0;
mComParams.rcParams.disableBitsStuffing = 1;
mComParams.cyclicFrameInterval = 30;
mComParams.refreshType = VIDEO_ENC_NONIR;
mComParams.airParams.airMBs = 0;
mComParams.airParams.airThreshold = 0;
mComParams.airParams.airAuto = 1;
mComParams.disableDeblocking = 2;
mComParams.syncEncMode = false;
mComParams.codedBufNum = 2;
}
Encode_Status PVSoftMPEG4Encoder::initEncParams() {
CHECK(mHandle != NULL);
memset(mHandle, 0, sizeof(tagvideoEncControls));
CHECK(mEncParams != NULL);
memset(mEncParams, 0, sizeof(tagvideoEncOptions));
if (!PVGetDefaultEncOption(mEncParams, 0)) {
LOG_E("Failed to get default encoding parameters");
return ENCODE_FAIL;
}
mEncParams->encMode = mEncodeMode;
mEncParams->encWidth[0] = mVideoWidth;
mEncParams->encHeight[0] = mVideoHeight;
mEncParams->encFrameRate[0] = mVideoFrameRate;
mEncParams->rcType = VBR_1;
mEncParams->vbvDelay = 5.0f;
// FIXME:
// Add more profile and level support for MPEG4 encoder
mEncParams->profile_level = CORE_PROFILE_LEVEL2;
mEncParams->packetSize = 32;
mEncParams->rvlcEnable = PV_OFF;
mEncParams->numLayers = 1;
mEncParams->timeIncRes = 1000;
mEncParams->tickPerSrc = mEncParams->timeIncRes / mVideoFrameRate;
mEncParams->bitRate[0] = mVideoBitRate <= 2000000 ? mVideoBitRate : 2000000;
mEncParams->iQuant[0] = 15;
mEncParams->pQuant[0] = 12;
mEncParams->quantType[0] = 0;
mEncParams->noFrameSkipped = PV_OFF;
mTrimedInputData =
(uint8_t *) malloc((mVideoWidth * mVideoHeight * 3 ) >> 1);
CHECK(mTrimedInputData != NULL);
if (mVideoColorFormat == OMX_COLOR_FormatYUV420SemiPlanar) {
// Color conversion is needed.
CHECK(mInputFrameData == NULL);
mInputFrameData =
(uint8_t *) malloc((mVideoWidth * mVideoHeight * 3 ) >> 1);
CHECK(mInputFrameData != NULL);
}
// PV's MPEG4 encoder requires the video dimension of multiple
if (mVideoWidth % 16 != 0 || mVideoHeight % 16 != 0) {
LOG_E("Video frame size %dx%d must be a multiple of 16",
mVideoWidth, mVideoHeight);
return ENCODE_INVALID_PARAMS;
}
// Set IDR frame refresh interval
if (mIDRFrameRefreshIntervalInSec < 0) {
mEncParams->intraPeriod = -1;
} else if (mIDRFrameRefreshIntervalInSec == 0) {
mEncParams->intraPeriod = 1; // All I frames
} else {
mEncParams->intraPeriod =
(mIDRFrameRefreshIntervalInSec * mVideoFrameRate);
}
mEncParams->numIntraMB = 0;
mEncParams->sceneDetect = PV_ON;
mEncParams->searchRange = 16;
mEncParams->mv8x8Enable = PV_OFF;
mEncParams->gobHeaderInterval = 0;
mEncParams->useACPred = PV_ON;
mEncParams->intraDCVlcTh = 0;
return ENCODE_SUCCESS;
}
Encode_Status PVSoftMPEG4Encoder::initEncoder() {
LOG_V("Begin\n");
CHECK(!mStarted);
Encode_Status ret = ENCODE_SUCCESS;
if (ENCODE_SUCCESS != (ret = initEncParams())) {
LOG_E("Failed to initialized encoder params");
mSignalledError = true;
return ret;
}
if (!PVInitVideoEncoder(mHandle, mEncParams)) {
LOG_E("Failed to initialize the encoder");
mSignalledError = true;
return ENCODE_FAIL;
}
mNumInputFrames = -1; // 1st buffer for codec specific data
mStarted = true;
mCurTimestampUs = 0;
mLastTimestampUs = 0;
mVolHeaderLength = 256;
LOG_V("End\n");
return ENCODE_SUCCESS;
}
Encode_Status PVSoftMPEG4Encoder::releaseEncoder() {
LOG_V("Begin\n");
if (!mStarted) {
return ENCODE_SUCCESS;
}
PVCleanUpVideoEncoder(mHandle);
delete mTrimedInputData;
mTrimedInputData = NULL;
delete mInputFrameData;
mInputFrameData = NULL;
delete mEncParams;
mEncParams = NULL;
delete mHandle;
mHandle = NULL;
mStarted = false;
LOG_V("End\n");
return ENCODE_SUCCESS;
}
Encode_Status PVSoftMPEG4Encoder::setParameters(
VideoParamConfigSet *videoEncParams)
{
Encode_Status ret = ENCODE_SUCCESS;
CHECK_NULL_RETURN_IFFAIL(videoEncParams);
LOG_I("Config type = %d\n", (int)videoEncParams->type);
if (mStarted) {
LOG_E("Encoder has been initialized, should use setConfig to change configurations\n");
return ENCODE_ALREADY_INIT;
}
switch (videoEncParams->type) {
case VideoParamsTypeCommon: {
VideoParamsCommon *paramsCommon =
reinterpret_cast <VideoParamsCommon *> (videoEncParams);
if (paramsCommon->size != sizeof (VideoParamsCommon)) {
return ENCODE_INVALID_PARAMS;
}
if(paramsCommon->codedBufNum < 2)
paramsCommon->codedBufNum =2;
mComParams = *paramsCommon;
mVideoWidth = mComParams.resolution.width;
mVideoHeight = mComParams.resolution.height;
mVideoFrameRate = mComParams.frameRate.frameRateNum / \
mComParams.frameRate.frameRateDenom;
mVideoBitRate = mComParams.rcParams.bitRate;
mVideoColorFormat = OMX_COLOR_FormatYUV420SemiPlanar;
break;
}
case VideoParamsTypeStoreMetaDataInBuffers: {
VideoParamsStoreMetaDataInBuffers *metadata =
reinterpret_cast <VideoParamsStoreMetaDataInBuffers *> (videoEncParams);
if (metadata->size != sizeof (VideoParamsStoreMetaDataInBuffers)) {
return ENCODE_INVALID_PARAMS;
}
mStoreMetaDataInBuffers = metadata->isEnabled;
break;
}
default: {
LOG_I ("Wrong ParamType here\n");
break;
}
}
return ret;
}
Encode_Status PVSoftMPEG4Encoder::getParameters(
VideoParamConfigSet *videoEncParams) {
Encode_Status ret = ENCODE_SUCCESS;
CHECK_NULL_RETURN_IFFAIL(videoEncParams);
LOG_I("Config type = %d\n", (int)videoEncParams->type);
switch (videoEncParams->type) {
case VideoParamsTypeCommon: {
VideoParamsCommon *paramsCommon =
reinterpret_cast <VideoParamsCommon *> (videoEncParams);
if (paramsCommon->size != sizeof (VideoParamsCommon)) {
return ENCODE_INVALID_PARAMS;
}
*paramsCommon = mComParams;
break;
}
case VideoParamsTypeStoreMetaDataInBuffers: {
VideoParamsStoreMetaDataInBuffers *metadata =
reinterpret_cast <VideoParamsStoreMetaDataInBuffers *> (videoEncParams);
if (metadata->size != sizeof (VideoParamsStoreMetaDataInBuffers)) {
return ENCODE_INVALID_PARAMS;
}
metadata->isEnabled = mStoreMetaDataInBuffers;
break;
}
default: {
LOG_I ("Wrong ParamType here\n");
break;
}
}
return ret;
}
Encode_Status PVSoftMPEG4Encoder::encode(VideoEncRawBuffer *inBuffer, uint32_t timeout)
{
LOG_V("Begin\n");
Encode_Status ret = ENCODE_SUCCESS;
if (mCurTimestampUs <= inBuffer->timeStamp) {
mLastTimestampUs = mCurTimestampUs;
mCurTimestampUs = inBuffer->timeStamp;
}
if (mNumInputFrames < 0) {
if (!PVGetVolHeader(mHandle, mVolHeader, &mVolHeaderLength, 0)) {
LOG_E("Failed to get VOL header");
mSignalledError = true;
return ENCODE_FAIL;
}
LOG_I("Output VOL header: %d bytes", mVolHeaderLength);
mNumInputFrames++;
//return ENCODE_SUCCESS;
}
if (mStoreMetaDataInBuffers) {
IntelMetadataBuffer imb;
int32_t type;
int32_t value;
uint8_t *img;
const android::Rect rect(mVideoWidth, mVideoHeight);
android::status_t res;
ValueInfo vinfo;
ValueInfo *pvinfo = &vinfo;
CHECK(IMB_SUCCESS == imb.UnSerialize(inBuffer->data, inBuffer->size));
imb.GetType((::IntelMetadataBufferType&)type);
imb.GetValue(value);
imb.GetValueInfo(pvinfo);
if(pvinfo == NULL) {
res = android::GraphicBufferMapper::get().lock((buffer_handle_t)value,
GRALLOC_USAGE_SW_READ_MASK,
rect, (void**)&img);
} else {
img = (uint8_t*)value;
}
if (pvinfo != NULL)
trimBuffer(img, mTrimedInputData, pvinfo->width, pvinfo->height,
pvinfo->height, pvinfo->lumaStride);
else {
//NV12 Y-TILED
trimBuffer(img, mTrimedInputData, mVideoWidth, mVideoHeight,
ALIGN(mVideoHeight, 32), ALIGN(mVideoWidth, 128));
android::GraphicBufferMapper::get().unlock((buffer_handle_t)value);
}
} else {
memcpy(mTrimedInputData, inBuffer->data,
(mVideoWidth * mVideoHeight * 3 ) >> 1);
}
if (mVideoColorFormat != OMX_COLOR_FormatYUV420Planar) {
ConvertYUV420SemiPlanarToYUV420Planar(
mTrimedInputData, mInputFrameData, mVideoWidth, mVideoHeight);
} else {
memcpy(mTrimedInputData, mInputFrameData,
(mVideoWidth * mVideoHeight * 3 ) >> 1);
}
LOG_V("End\n");
return ret;
}
Encode_Status PVSoftMPEG4Encoder::getOutput(VideoEncOutputBuffer *outBuffer, uint32_t timeout)
{
LOG_V("Begin\n");
Encode_Status ret = ENCODE_SUCCESS;
uint8_t *outPtr = outBuffer->data;
int32_t dataLength = outBuffer->bufferSize;
outBuffer->flag = 0;
if ((mEncodeMode == COMBINE_MODE_WITH_ERR_RES) &&
(outBuffer->format == OUTPUT_CODEC_DATA)) {
memcpy(outPtr, mVolHeader, mVolHeaderLength);
++mNumInputFrames;
outBuffer->flag |= ENCODE_BUFFERFLAG_CODECCONFIG;
outBuffer->flag |= ENCODE_BUFFERFLAG_ENDOFFRAME;
outBuffer->flag |= ENCODE_BUFFERFLAG_SYNCFRAME;
outBuffer->dataSize = mVolHeaderLength;
outBuffer->remainingSize = 0;
return ENCODE_SUCCESS;
}
outBuffer->timeStamp = mCurTimestampUs;
LOG_I("info.mTimeUs %lld\n", outBuffer->timeStamp);
VideoEncFrameIO vin, vout;
memset(&vin, 0, sizeof(vin));
memset(&vout, 0, sizeof(vout));
vin.height = ((mVideoHeight + 15) >> 4) << 4;
vin.pitch = ((mVideoWidth + 15) >> 4) << 4;
vin.timestamp = (outBuffer->timeStamp + 500) / 1000; // in ms
vin.yChan = mInputFrameData;
vin.uChan = vin.yChan + vin.height * vin.pitch;
vin.vChan = vin.uChan + ((vin.height * vin.pitch) >> 2);
unsigned long modTimeMs = 0;
int32_t nLayer = 0;
MP4HintTrack hintTrack;
if (!PVEncodeVideoFrame(mHandle, &vin, &vout,
&modTimeMs, outPtr, &dataLength, &nLayer) ||
!PVGetHintTrack(mHandle, &hintTrack)) {
LOG_E("Failed to encode frame or get hink track at frame %lld",
mNumInputFrames);
mSignalledError = true;
hintTrack.CodeType = 0;
ret = ENCODE_FAIL;
}
LOG_I("dataLength %d\n", dataLength);
CHECK(NULL == PVGetOverrunBuffer(mHandle));
if (hintTrack.CodeType == 0) { // I-frame serves as sync frame
outBuffer->flag |= ENCODE_BUFFERFLAG_SYNCFRAME;
}
++mNumInputFrames;
outBuffer->flag |= ENCODE_BUFFERFLAG_ENDOFFRAME;
outBuffer->dataSize = dataLength;
LOG_V("End\n");
return ret;
}