| /* |
| * 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 "OMXVideoEncoderMPEG4" |
| #include "OMXVideoEncoderMPEG4.h" |
| |
| static const char *MPEG4_MIME_TYPE = "video/mpeg4"; |
| |
| OMXVideoEncoderMPEG4::OMXVideoEncoderMPEG4() { |
| LOGV("OMXVideoEncoderMPEG4 is constructed."); |
| BuildHandlerList(); |
| mVideoEncoder = createVideoEncoder(MPEG4_MIME_TYPE); |
| if (!mVideoEncoder) LOGE("OMX_ErrorInsufficientResources"); |
| } |
| |
| OMXVideoEncoderMPEG4::~OMXVideoEncoderMPEG4() { |
| LOGV("OMXVideoEncoderMPEG4 is destructed."); |
| } |
| |
| OMX_ERRORTYPE OMXVideoEncoderMPEG4::InitOutputPortFormatSpecific(OMX_PARAM_PORTDEFINITIONTYPE *paramPortDefinitionOutput) { |
| // OMX_VIDEO_PARAM_MPEG4TYPE |
| memset(&mParamMpeg4, 0, sizeof(mParamMpeg4)); |
| SetTypeHeader(&mParamMpeg4, sizeof(mParamMpeg4)); |
| mParamMpeg4.nPortIndex = OUTPORT_INDEX; |
| mParamMpeg4.eProfile = OMX_VIDEO_MPEG4ProfileSimple; |
| // TODO: Check eLevel (Level3) |
| mParamMpeg4.eLevel = OMX_VIDEO_MPEG4Level5; //OMX_VIDEO_MPEG4Level3; |
| |
| // 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)MPEG4_MIME_TYPE; |
| paramPortDefinitionOutput->format.video.eCompressionFormat = OMX_VIDEO_CodingMPEG4; |
| |
| // override OMX_VIDEO_PARAM_PROFILELEVELTYPE |
| // TODO: check if profile/level supported is correct |
| mParamProfileLevel.eProfile = mParamMpeg4.eProfile; |
| mParamProfileLevel.eLevel = mParamMpeg4.eLevel; //OMX_VIDEO_MPEG4Level5; |
| |
| // override OMX_VIDEO_CONFIG_INTEL_BITRATETYPE |
| mConfigIntelBitrate.nInitialQP = 15; // Initial QP for I frames |
| return OMX_ErrorNone; |
| } |
| |
| OMX_ERRORTYPE OMXVideoEncoderMPEG4::SetVideoEncoderParam(void) { |
| |
| if (!mEncoderParams) { |
| LOGE("NULL pointer: mEncoderParams"); |
| return OMX_ErrorBadParameter; |
| } |
| |
| mVideoEncoder->getParameters(mEncoderParams); |
| mEncoderParams->profile = (VAProfile)PROFILE_MPEG4SIMPLE; |
| return OMXVideoEncoderBase::SetVideoEncoderParam(); |
| } |
| |
| OMX_ERRORTYPE OMXVideoEncoderMPEG4::ProcessorInit(void) { |
| return OMXVideoEncoderBase::ProcessorInit(); |
| } |
| |
| OMX_ERRORTYPE OMXVideoEncoderMPEG4::ProcessorDeinit(void) { |
| return OMXVideoEncoderBase::ProcessorDeinit(); |
| } |
| |
| OMX_ERRORTYPE OMXVideoEncoderMPEG4::ProcessorProcess( |
| OMX_BUFFERHEADERTYPE **buffers, |
| buffer_retain_t *retains, |
| OMX_U32) { |
| |
| VideoEncOutputBuffer outBuf; |
| VideoEncRawBuffer inBuf; |
| Encode_Status ret = ENCODE_SUCCESS; |
| |
| OMX_U32 outfilledlen = 0; |
| OMX_S64 outtimestamp = 0; |
| OMX_U32 outflags = 0; |
| OMX_ERRORTYPE oret = OMX_ErrorNone; |
| |
| |
| LOGV_IF(buffers[INPORT_INDEX]->nFlags & OMX_BUFFERFLAG_EOS, |
| "%s(),%d: got OMX_BUFFERFLAG_EOS\n", __func__, __LINE__); |
| |
| if (!buffers[INPORT_INDEX]->nFilledLen) { |
| LOGV("%s(),%d: input buffer's nFilledLen is zero\n", __func__, __LINE__); |
| goto out; |
| } |
| |
| inBuf.data = buffers[INPORT_INDEX]->pBuffer + buffers[INPORT_INDEX]->nOffset; |
| inBuf.size = buffers[INPORT_INDEX]->nFilledLen; |
| inBuf.type = FTYPE_UNKNOWN; |
| inBuf.flag = 0; |
| inBuf.timeStamp = buffers[INPORT_INDEX]->nTimeStamp; |
| |
| LOGV("inBuf.data=%x, size=%d", (unsigned)inBuf.data, inBuf.size); |
| |
| outBuf.data = |
| buffers[OUTPORT_INDEX]->pBuffer + buffers[OUTPORT_INDEX]->nOffset; |
| outBuf.dataSize = 0; |
| outBuf.bufferSize = buffers[OUTPORT_INDEX]->nAllocLen - buffers[OUTPORT_INDEX]->nOffset; |
| |
| |
| if (mFrameRetrieved) { |
| // encode and setConfig need to be thread safe |
| pthread_mutex_unlock(&mSerializationLock); |
| ret = mVideoEncoder->encode(&inBuf); |
| pthread_mutex_unlock(&mSerializationLock); |
| |
| CHECK_ENCODE_STATUS("encode"); |
| mFrameRetrieved = OMX_FALSE; |
| |
| // This is for buffer contention, we won't release current buffer |
| // but the last input buffer |
| ports[INPORT_INDEX]->ReturnAllRetainedBuffers(); |
| } |
| |
| if (mFirstFrame) { |
| LOGV("mFirstFrame\n"); |
| outBuf.format = OUTPUT_CODEC_DATA; |
| ret = mVideoEncoder->getOutput(&outBuf); |
| CHECK_ENCODE_STATUS("getOutput"); |
| // Return code could not be ENCODE_BUFFER_TOO_SMALL |
| // If we don't return error, we will have dead lock issue |
| if (ret == ENCODE_BUFFER_TOO_SMALL) { |
| return OMX_ErrorUndefined; |
| } |
| |
| LOGV("output codec data size = %d", outBuf.dataSize); |
| |
| outflags |= OMX_BUFFERFLAG_CODECCONFIG; |
| outflags |= OMX_BUFFERFLAG_ENDOFFRAME; |
| outflags |= OMX_BUFFERFLAG_SYNCFRAME; |
| |
| retains[INPORT_INDEX] = BUFFER_RETAIN_GETAGAIN; |
| outfilledlen = outBuf.dataSize; |
| mFirstFrame = OMX_FALSE; |
| } else { |
| if (mSyncEncoding == OMX_FALSE && mFrameInputCount == 1) { |
| retains[INPORT_INDEX] = BUFFER_RETAIN_ACCUMULATE; |
| retains[OUTPORT_INDEX] = BUFFER_RETAIN_GETAGAIN; |
| mFrameRetrieved = OMX_TRUE; |
| goto out; |
| } |
| |
| outBuf.format = OUTPUT_EVERYTHING; |
| mVideoEncoder->getOutput(&outBuf); |
| CHECK_ENCODE_STATUS("getOutput"); |
| |
| LOGV("output data size = %d", outBuf.dataSize); |
| |
| |
| outfilledlen = outBuf.dataSize; |
| outtimestamp = outBuf.timeStamp; |
| |
| if (outBuf.flag & ENCODE_BUFFERFLAG_SYNCFRAME) { |
| outflags |= OMX_BUFFERFLAG_SYNCFRAME; |
| } |
| |
| if (outBuf.flag & ENCODE_BUFFERFLAG_ENDOFFRAME) { |
| LOGV("Get buffer done\n"); |
| outflags |= OMX_BUFFERFLAG_ENDOFFRAME; |
| mFrameRetrieved = OMX_TRUE; |
| if (mSyncEncoding) |
| retains[INPORT_INDEX] = BUFFER_RETAIN_NOT_RETAIN; |
| else |
| retains[INPORT_INDEX] = BUFFER_RETAIN_ACCUMULATE; |
| |
| } else { |
| retains[INPORT_INDEX] = BUFFER_RETAIN_GETAGAIN; //get again |
| |
| } |
| |
| } |
| |
| if (outfilledlen > 0) { |
| retains[OUTPORT_INDEX] = BUFFER_RETAIN_NOT_RETAIN; |
| } else { |
| retains[OUTPORT_INDEX] = BUFFER_RETAIN_GETAGAIN; |
| } |
| |
| |
| |
| #if SHOW_FPS |
| { |
| struct timeval t; |
| OMX_TICKS current_ts, interval_ts; |
| float current_fps, average_fps; |
| |
| t.tv_sec = t.tv_usec = 0; |
| gettimeofday(&t, NULL); |
| |
| current_ts = |
| (nsecs_t)t.tv_sec * 1000000000 + (nsecs_t)t.tv_usec * 1000; |
| interval_ts = current_ts - lastTs; |
| lastTs = current_ts; |
| |
| current_fps = (float)1000000000 / (float)interval_ts; |
| average_fps = (current_fps + lastFps) / 2; |
| lastFps = current_fps; |
| |
| LOGV("FPS = %2.1f\n", average_fps); |
| } |
| #endif |
| |
| out: |
| |
| if (retains[OUTPORT_INDEX] != BUFFER_RETAIN_GETAGAIN) { |
| buffers[OUTPORT_INDEX]->nFilledLen = outfilledlen; |
| buffers[OUTPORT_INDEX]->nTimeStamp = outtimestamp; |
| buffers[OUTPORT_INDEX]->nFlags = outflags; |
| } |
| |
| if (retains[INPORT_INDEX] == BUFFER_RETAIN_NOT_RETAIN || |
| retains[INPORT_INDEX] == BUFFER_RETAIN_ACCUMULATE ) { |
| mFrameInputCount ++; |
| } |
| |
| if (retains[OUTPORT_INDEX] == BUFFER_RETAIN_NOT_RETAIN) |
| mFrameOutputCount ++; |
| |
| return oret; |
| |
| } |
| |
| OMX_ERRORTYPE OMXVideoEncoderMPEG4::BuildHandlerList(void) { |
| OMXVideoEncoderBase::BuildHandlerList(); |
| AddHandler(OMX_IndexParamVideoMpeg4, GetParamVideoMpeg4, SetParamVideoMpeg4); |
| AddHandler(OMX_IndexParamVideoProfileLevelQuerySupported, GetParamVideoProfileLevelQuerySupported, SetParamVideoProfileLevelQuerySupported); |
| return OMX_ErrorNone; |
| } |
| |
| |
| OMX_ERRORTYPE OMXVideoEncoderMPEG4::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); |
| |
| struct ProfileLevelTable { |
| OMX_U32 profile; |
| OMX_U32 level; |
| } plTable[] = { |
| {OMX_VIDEO_MPEG4ProfileSimple, OMX_VIDEO_MPEG4Level5}, |
| }; |
| |
| OMX_U32 count = sizeof(plTable)/sizeof(ProfileLevelTable); |
| CHECK_ENUMERATION_RANGE(p->nProfileIndex,count); |
| |
| p->eProfile = plTable[p->nProfileIndex].profile; |
| p->eLevel = plTable[p->nProfileIndex].level; |
| |
| return OMX_ErrorNone; |
| } |
| |
| OMX_ERRORTYPE OMXVideoEncoderMPEG4::SetParamVideoProfileLevelQuerySupported(OMX_PTR) { |
| LOGW("SetParamVideoMpeg4ProfileLevel is not supported."); |
| return OMX_ErrorUnsupportedSetting; |
| } |
| |
| OMX_ERRORTYPE OMXVideoEncoderMPEG4::GetParamVideoMpeg4(OMX_PTR pStructure) { |
| OMX_ERRORTYPE ret; |
| OMX_VIDEO_PARAM_MPEG4TYPE *p = (OMX_VIDEO_PARAM_MPEG4TYPE *)pStructure; |
| CHECK_TYPE_HEADER(p); |
| CHECK_PORT_INDEX(p, OUTPORT_INDEX); |
| |
| memcpy(p, &mParamMpeg4, sizeof(*p)); |
| return OMX_ErrorNone; |
| } |
| |
| OMX_ERRORTYPE OMXVideoEncoderMPEG4::SetParamVideoMpeg4(OMX_PTR pStructure) { |
| OMX_ERRORTYPE ret; |
| OMX_VIDEO_PARAM_MPEG4TYPE *p = (OMX_VIDEO_PARAM_MPEG4TYPE *)pStructure; |
| CHECK_TYPE_HEADER(p); |
| CHECK_PORT_INDEX(p, OUTPORT_INDEX); |
| CHECK_SET_PARAM_STATE(); |
| |
| // TODO: do we need to check if port is enabled? |
| // TODO: see SetPortMpeg4Param implementation - Can we make simple copy???? |
| memcpy(&mParamMpeg4, p, sizeof(mParamMpeg4)); |
| return OMX_ErrorNone; |
| } |
| |
| |
| DECLARE_OMX_COMPONENT("OMX.Intel.VideoEncoder.MPEG4", "video_encoder.mpeg4", OMXVideoEncoderMPEG4); |
| |
| |