SoftAVCEncoder.cpp revision 2edda09a2ad1d112c52acd37d323f63f0a492d67
1fb5e23c327cd5f8f93d1eaa7c10f34d6fd3efb6cRomain Guy/* 2fb5e23c327cd5f8f93d1eaa7c10f34d6fd3efb6cRomain Guy * Copyright (C) 2012 The Android Open Source Project 3fb5e23c327cd5f8f93d1eaa7c10f34d6fd3efb6cRomain Guy * 4fb5e23c327cd5f8f93d1eaa7c10f34d6fd3efb6cRomain Guy * Licensed under the Apache License, Version 2.0 (the "License"); 5fb5e23c327cd5f8f93d1eaa7c10f34d6fd3efb6cRomain Guy * you may not use this file except in compliance with the License. 6fb5e23c327cd5f8f93d1eaa7c10f34d6fd3efb6cRomain Guy * You may obtain a copy of the License at 7fb5e23c327cd5f8f93d1eaa7c10f34d6fd3efb6cRomain Guy * 8fb5e23c327cd5f8f93d1eaa7c10f34d6fd3efb6cRomain Guy * http://www.apache.org/licenses/LICENSE-2.0 9fb5e23c327cd5f8f93d1eaa7c10f34d6fd3efb6cRomain Guy * 10fb5e23c327cd5f8f93d1eaa7c10f34d6fd3efb6cRomain Guy * Unless required by applicable law or agreed to in writing, software 11fb5e23c327cd5f8f93d1eaa7c10f34d6fd3efb6cRomain Guy * distributed under the License is distributed on an "AS IS" BASIS, 12fb5e23c327cd5f8f93d1eaa7c10f34d6fd3efb6cRomain Guy * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13fb5e23c327cd5f8f93d1eaa7c10f34d6fd3efb6cRomain Guy * See the License for the specific language governing permissions and 14fb5e23c327cd5f8f93d1eaa7c10f34d6fd3efb6cRomain Guy * limitations under the License. 15fb5e23c327cd5f8f93d1eaa7c10f34d6fd3efb6cRomain Guy */ 16fb5e23c327cd5f8f93d1eaa7c10f34d6fd3efb6cRomain Guy 17fb5e23c327cd5f8f93d1eaa7c10f34d6fd3efb6cRomain Guy//#define LOG_NDEBUG 0 18fb5e23c327cd5f8f93d1eaa7c10f34d6fd3efb6cRomain Guy#define LOG_TAG "SoftAVCEncoder" 196820ac8b14b4558f5d8b833dde80895306a3e137Romain Guy#include <utils/Log.h> 20fb5e23c327cd5f8f93d1eaa7c10f34d6fd3efb6cRomain Guy 214bb942083a0d4db746adf95349108dd8ef842e32Romain Guy#include "avcenc_api.h" 224bb942083a0d4db746adf95349108dd8ef842e32Romain Guy#include "avcenc_int.h" 2303750a067e818ca7fbd0f590e2ff6a8fded21e6cRomain Guy#include "OMX_Video.h" 243b748a44c6bd2ea05fe16839caf73dbe50bd7ae9Romain Guy 25a5ef39a21683189e5906c9f252b997f0508e350dRomain Guy#include <HardwareAPI.h> 263b748a44c6bd2ea05fe16839caf73dbe50bd7ae9Romain Guy#include <MetadataBufferType.h> 27fb5e23c327cd5f8f93d1eaa7c10f34d6fd3efb6cRomain Guy#include <media/stagefright/foundation/ADebug.h> 28fb5e23c327cd5f8f93d1eaa7c10f34d6fd3efb6cRomain Guy#include <media/stagefright/MediaDefs.h> 29fb5e23c327cd5f8f93d1eaa7c10f34d6fd3efb6cRomain Guy#include <media/stagefright/MediaErrors.h> 30fb5e23c327cd5f8f93d1eaa7c10f34d6fd3efb6cRomain Guy#include <media/stagefright/MetaData.h> 31fb5e23c327cd5f8f93d1eaa7c10f34d6fd3efb6cRomain Guy#include <media/stagefright/Utils.h> 32fb5e23c327cd5f8f93d1eaa7c10f34d6fd3efb6cRomain Guy#include <ui/Rect.h> 33fb5e23c327cd5f8f93d1eaa7c10f34d6fd3efb6cRomain Guy#include <ui/GraphicBufferMapper.h> 34fb5e23c327cd5f8f93d1eaa7c10f34d6fd3efb6cRomain Guy 3503c00b5a135e68d22ca5bb829b899ebda6ed7e9dRomain Guy#include "SoftAVCEncoder.h" 36fb5e23c327cd5f8f93d1eaa7c10f34d6fd3efb6cRomain Guy 37fb5e23c327cd5f8f93d1eaa7c10f34d6fd3efb6cRomain Guy#if LOG_NDEBUG 38fb5e23c327cd5f8f93d1eaa7c10f34d6fd3efb6cRomain Guy#define UNUSED_UNLESS_VERBOSE(x) (void)(x) 39fb5e23c327cd5f8f93d1eaa7c10f34d6fd3efb6cRomain Guy#else 40fb5e23c327cd5f8f93d1eaa7c10f34d6fd3efb6cRomain Guy#define UNUSED_UNLESS_VERBOSE(x) 41fb5e23c327cd5f8f93d1eaa7c10f34d6fd3efb6cRomain Guy#endif 423b748a44c6bd2ea05fe16839caf73dbe50bd7ae9Romain Guy 436f72bebe92a4db7b5dc83f4ac5b5fd02e3b4e2cdRomain Guynamespace android { 446f72bebe92a4db7b5dc83f4ac5b5fd02e3b4e2cdRomain Guy 453b748a44c6bd2ea05fe16839caf73dbe50bd7ae9Romain Guytemplate<class T> 463b748a44c6bd2ea05fe16839caf73dbe50bd7ae9Romain Guystatic void InitOMXParams(T *params) { 476f72bebe92a4db7b5dc83f4ac5b5fd02e3b4e2cdRomain Guy params->nSize = sizeof(T); 486f72bebe92a4db7b5dc83f4ac5b5fd02e3b4e2cdRomain Guy params->nVersion.s.nVersionMajor = 1; 493b748a44c6bd2ea05fe16839caf73dbe50bd7ae9Romain Guy params->nVersion.s.nVersionMinor = 0; 5003c00b5a135e68d22ca5bb829b899ebda6ed7e9dRomain Guy params->nVersion.s.nRevision = 0; 513b748a44c6bd2ea05fe16839caf73dbe50bd7ae9Romain Guy params->nVersion.s.nStep = 0; 5203c00b5a135e68d22ca5bb829b899ebda6ed7e9dRomain Guy} 536f72bebe92a4db7b5dc83f4ac5b5fd02e3b4e2cdRomain Guy 546f72bebe92a4db7b5dc83f4ac5b5fd02e3b4e2cdRomain Guytypedef struct LevelConversion { 553b748a44c6bd2ea05fe16839caf73dbe50bd7ae9Romain Guy OMX_U32 omxLevel; 5603c00b5a135e68d22ca5bb829b899ebda6ed7e9dRomain Guy AVCLevel avcLevel; 5703c00b5a135e68d22ca5bb829b899ebda6ed7e9dRomain Guy} LevelConcersion; 585341cead27070656458750a789ba211a505b57b5Romain Guy 593b748a44c6bd2ea05fe16839caf73dbe50bd7ae9Romain Guystatic LevelConversion ConversionTable[] = { 606381dd4ff212a95be30d2b445d40ff419ab076b4Narayan Kamath { OMX_VIDEO_AVCLevel1, AVC_LEVEL1_B }, 613b748a44c6bd2ea05fe16839caf73dbe50bd7ae9Romain Guy { OMX_VIDEO_AVCLevel1b, AVC_LEVEL1 }, 626cad75744ed3b81cf2c96f545368067b62c726ecRomain Guy { OMX_VIDEO_AVCLevel11, AVC_LEVEL1_1 }, 633b748a44c6bd2ea05fe16839caf73dbe50bd7ae9Romain Guy { OMX_VIDEO_AVCLevel12, AVC_LEVEL1_2 }, 643b748a44c6bd2ea05fe16839caf73dbe50bd7ae9Romain Guy { OMX_VIDEO_AVCLevel13, AVC_LEVEL1_3 }, 656cad75744ed3b81cf2c96f545368067b62c726ecRomain Guy { OMX_VIDEO_AVCLevel2, AVC_LEVEL2 }, 663b748a44c6bd2ea05fe16839caf73dbe50bd7ae9Romain Guy#if 0 673b748a44c6bd2ea05fe16839caf73dbe50bd7ae9Romain Guy // encoding speed is very poor if video 683b748a44c6bd2ea05fe16839caf73dbe50bd7ae9Romain Guy // resolution is higher than CIF 696f72bebe92a4db7b5dc83f4ac5b5fd02e3b4e2cdRomain Guy { OMX_VIDEO_AVCLevel21, AVC_LEVEL2_1 }, 706f72bebe92a4db7b5dc83f4ac5b5fd02e3b4e2cdRomain Guy { OMX_VIDEO_AVCLevel22, AVC_LEVEL2_2 }, 713b748a44c6bd2ea05fe16839caf73dbe50bd7ae9Romain Guy { OMX_VIDEO_AVCLevel3, AVC_LEVEL3 }, 726f72bebe92a4db7b5dc83f4ac5b5fd02e3b4e2cdRomain Guy { OMX_VIDEO_AVCLevel31, AVC_LEVEL3_1 }, 733b748a44c6bd2ea05fe16839caf73dbe50bd7ae9Romain Guy { OMX_VIDEO_AVCLevel32, AVC_LEVEL3_2 }, 743b748a44c6bd2ea05fe16839caf73dbe50bd7ae9Romain Guy { OMX_VIDEO_AVCLevel4, AVC_LEVEL4 }, 756f72bebe92a4db7b5dc83f4ac5b5fd02e3b4e2cdRomain Guy { OMX_VIDEO_AVCLevel41, AVC_LEVEL4_1 }, 763b748a44c6bd2ea05fe16839caf73dbe50bd7ae9Romain Guy { OMX_VIDEO_AVCLevel42, AVC_LEVEL4_2 }, 773b748a44c6bd2ea05fe16839caf73dbe50bd7ae9Romain Guy { OMX_VIDEO_AVCLevel5, AVC_LEVEL5 }, 78fb5e23c327cd5f8f93d1eaa7c10f34d6fd3efb6cRomain Guy { OMX_VIDEO_AVCLevel51, AVC_LEVEL5_1 }, 79f296dca95f09be9832b5dcc79717986525d2b6cbRomain Guy#endif 80f296dca95f09be9832b5dcc79717986525d2b6cbRomain Guy}; 81a5ef39a21683189e5906c9f252b997f0508e350dRomain Guy 826381dd4ff212a95be30d2b445d40ff419ab076b4Narayan Kamathstatic status_t ConvertOmxAvcLevelToAvcSpecLevel( 836381dd4ff212a95be30d2b445d40ff419ab076b4Narayan Kamath OMX_U32 omxLevel, AVCLevel *avcLevel) { 845b3b35296e8b2c8d3f07d32bb645d5414db41a1dRomain Guy for (size_t i = 0, n = sizeof(ConversionTable)/sizeof(ConversionTable[0]); 853b748a44c6bd2ea05fe16839caf73dbe50bd7ae9Romain Guy i < n; ++i) { 863b748a44c6bd2ea05fe16839caf73dbe50bd7ae9Romain Guy if (omxLevel == ConversionTable[i].omxLevel) { 87fb5e23c327cd5f8f93d1eaa7c10f34d6fd3efb6cRomain Guy *avcLevel = ConversionTable[i].avcLevel; 886820ac8b14b4558f5d8b833dde80895306a3e137Romain Guy return OK; 8941d35aef06c2a570a45474a01ca95a6cb9c29d9eRomain Guy } 9041d35aef06c2a570a45474a01ca95a6cb9c29d9eRomain Guy } 9141d35aef06c2a570a45474a01ca95a6cb9c29d9eRomain Guy 9241d35aef06c2a570a45474a01ca95a6cb9c29d9eRomain Guy ALOGE("ConvertOmxAvcLevelToAvcSpecLevel: %d level not supported", 93fb5e23c327cd5f8f93d1eaa7c10f34d6fd3efb6cRomain Guy (int32_t)omxLevel); 94fb5e23c327cd5f8f93d1eaa7c10f34d6fd3efb6cRomain Guy 95fb5e23c327cd5f8f93d1eaa7c10f34d6fd3efb6cRomain Guy return BAD_VALUE; 963b748a44c6bd2ea05fe16839caf73dbe50bd7ae9Romain Guy} 973b748a44c6bd2ea05fe16839caf73dbe50bd7ae9Romain Guy 98fb5e23c327cd5f8f93d1eaa7c10f34d6fd3efb6cRomain Guystatic status_t ConvertAvcSpecLevelToOmxAvcLevel( 996820ac8b14b4558f5d8b833dde80895306a3e137Romain Guy AVCLevel avcLevel, OMX_U32 *omxLevel) { 100fb5e23c327cd5f8f93d1eaa7c10f34d6fd3efb6cRomain Guy for (size_t i = 0, n = sizeof(ConversionTable)/sizeof(ConversionTable[0]); 10103c00b5a135e68d22ca5bb829b899ebda6ed7e9dRomain Guy i < n; ++i) { 1026820ac8b14b4558f5d8b833dde80895306a3e137Romain Guy if (avcLevel == ConversionTable[i].avcLevel) { 10303c00b5a135e68d22ca5bb829b899ebda6ed7e9dRomain Guy *omxLevel = ConversionTable[i].omxLevel; 104fb5e23c327cd5f8f93d1eaa7c10f34d6fd3efb6cRomain Guy return OK; 105fb5e23c327cd5f8f93d1eaa7c10f34d6fd3efb6cRomain Guy } 106fb5e23c327cd5f8f93d1eaa7c10f34d6fd3efb6cRomain Guy } 107fb5e23c327cd5f8f93d1eaa7c10f34d6fd3efb6cRomain Guy 1083b748a44c6bd2ea05fe16839caf73dbe50bd7ae9Romain Guy ALOGE("ConvertAvcSpecLevelToOmxAvcLevel: %d level not supported", 1093b748a44c6bd2ea05fe16839caf73dbe50bd7ae9Romain Guy (int32_t) avcLevel); 110fb5e23c327cd5f8f93d1eaa7c10f34d6fd3efb6cRomain Guy 1116820ac8b14b4558f5d8b833dde80895306a3e137Romain Guy return BAD_VALUE; 112fb5e23c327cd5f8f93d1eaa7c10f34d6fd3efb6cRomain Guy} 11303c00b5a135e68d22ca5bb829b899ebda6ed7e9dRomain Guy 1146820ac8b14b4558f5d8b833dde80895306a3e137Romain Guystatic void* MallocWrapper( 11503c00b5a135e68d22ca5bb829b899ebda6ed7e9dRomain Guy void * /* userData */, int32_t size, int32_t /* attrs */) { 116fb5e23c327cd5f8f93d1eaa7c10f34d6fd3efb6cRomain Guy void *ptr = malloc(size); 117fb5e23c327cd5f8f93d1eaa7c10f34d6fd3efb6cRomain Guy if (ptr) 1184bb942083a0d4db746adf95349108dd8ef842e32Romain Guy memset(ptr, 0, size); 119fb5e23c327cd5f8f93d1eaa7c10f34d6fd3efb6cRomain Guy return ptr; 1206820ac8b14b4558f5d8b833dde80895306a3e137Romain Guy} 121fb5e23c327cd5f8f93d1eaa7c10f34d6fd3efb6cRomain Guy 1226820ac8b14b4558f5d8b833dde80895306a3e137Romain Guystatic void FreeWrapper(void * /* userData */, void* ptr) { 123f504a2fa144504ca1efd39a4ef9208e3d4d336c5Romain Guy free(ptr); 1246820ac8b14b4558f5d8b833dde80895306a3e137Romain Guy} 1256820ac8b14b4558f5d8b833dde80895306a3e137Romain Guy 1263b748a44c6bd2ea05fe16839caf73dbe50bd7ae9Romain Guystatic int32_t DpbAllocWrapper(void *userData, 1273b748a44c6bd2ea05fe16839caf73dbe50bd7ae9Romain Guy unsigned int sizeInMbs, unsigned int numBuffers) { 1283b748a44c6bd2ea05fe16839caf73dbe50bd7ae9Romain Guy SoftAVCEncoder *encoder = static_cast<SoftAVCEncoder *>(userData); 1293b748a44c6bd2ea05fe16839caf73dbe50bd7ae9Romain Guy CHECK(encoder != NULL); 1305e7c469c7a3039af7696789a797f8d91a45227ebRomain Guy return encoder->allocOutputBuffers(sizeInMbs, numBuffers); 1316820ac8b14b4558f5d8b833dde80895306a3e137Romain Guy} 1326820ac8b14b4558f5d8b833dde80895306a3e137Romain Guy 1338ab4079ca27e36e5c584495bcd71b573598ac021Romain Guystatic int32_t BindFrameWrapper( 134fb5e23c327cd5f8f93d1eaa7c10f34d6fd3efb6cRomain Guy void *userData, int32_t index, uint8_t **yuv) { 13541d35aef06c2a570a45474a01ca95a6cb9c29d9eRomain Guy SoftAVCEncoder *encoder = static_cast<SoftAVCEncoder *>(userData); 136fb5e23c327cd5f8f93d1eaa7c10f34d6fd3efb6cRomain Guy CHECK(encoder != NULL); 1375e7c469c7a3039af7696789a797f8d91a45227ebRomain Guy return encoder->bindOutputBuffer(index, yuv); 1385e7c469c7a3039af7696789a797f8d91a45227ebRomain Guy} 1395e7c469c7a3039af7696789a797f8d91a45227ebRomain Guy 1405e7c469c7a3039af7696789a797f8d91a45227ebRomain Guystatic void UnbindFrameWrapper(void *userData, int32_t index) { 1416820ac8b14b4558f5d8b833dde80895306a3e137Romain Guy SoftAVCEncoder *encoder = static_cast<SoftAVCEncoder *>(userData); 142eb6a4a17a07f1aa41bd58d418b2982cddb97685aRomain Guy CHECK(encoder != NULL); 1433b748a44c6bd2ea05fe16839caf73dbe50bd7ae9Romain Guy return encoder->unbindOutputBuffer(index); 14403c00b5a135e68d22ca5bb829b899ebda6ed7e9dRomain Guy} 145eb6a4a17a07f1aa41bd58d418b2982cddb97685aRomain Guy 1466820ac8b14b4558f5d8b833dde80895306a3e137Romain GuySoftAVCEncoder::SoftAVCEncoder( 1476820ac8b14b4558f5d8b833dde80895306a3e137Romain Guy const char *name, 1485e7c469c7a3039af7696789a797f8d91a45227ebRomain Guy const OMX_CALLBACKTYPE *callbacks, 1496820ac8b14b4558f5d8b833dde80895306a3e137Romain Guy OMX_PTR appData, 1506820ac8b14b4558f5d8b833dde80895306a3e137Romain Guy OMX_COMPONENTTYPE **component) 151fb5e23c327cd5f8f93d1eaa7c10f34d6fd3efb6cRomain Guy : SoftVideoEncoderOMXComponent(name, callbacks, appData, component), 152fb5e23c327cd5f8f93d1eaa7c10f34d6fd3efb6cRomain Guy mVideoWidth(176), 153fdbec3e4828f93bfa5cde758ad0e77b89c5c2ecdRomain Guy mVideoHeight(144), 15403c00b5a135e68d22ca5bb829b899ebda6ed7e9dRomain Guy mVideoFrameRate(30), 1553b748a44c6bd2ea05fe16839caf73dbe50bd7ae9Romain Guy mVideoBitRate(192000), 15603c00b5a135e68d22ca5bb829b899ebda6ed7e9dRomain Guy mVideoColorFormat(OMX_COLOR_FormatYUV420Planar), 1576f72bebe92a4db7b5dc83f4ac5b5fd02e3b4e2cdRomain Guy mStoreMetaDataInBuffers(false), 158a5ef39a21683189e5906c9f252b997f0508e350dRomain Guy mIDRFrameRefreshIntervalInSec(1), 159f296dca95f09be9832b5dcc79717986525d2b6cbRomain Guy mAVCEncProfile(AVC_BASELINE), 160f296dca95f09be9832b5dcc79717986525d2b6cbRomain Guy mAVCEncLevel(AVC_LEVEL2), 161f296dca95f09be9832b5dcc79717986525d2b6cbRomain Guy mNumInputFrames(-1), 162f296dca95f09be9832b5dcc79717986525d2b6cbRomain Guy mPrevTimestampUs(-1), 163f296dca95f09be9832b5dcc79717986525d2b6cbRomain Guy mStarted(false), 164f296dca95f09be9832b5dcc79717986525d2b6cbRomain Guy mSawInputEOS(false), 165f296dca95f09be9832b5dcc79717986525d2b6cbRomain Guy mSignalledError(false), 166f296dca95f09be9832b5dcc79717986525d2b6cbRomain Guy mHandle(new tagAVCHandle), 1673b748a44c6bd2ea05fe16839caf73dbe50bd7ae9Romain Guy mEncParams(new tagAVCEncParam), 168fb5e23c327cd5f8f93d1eaa7c10f34d6fd3efb6cRomain Guy mInputFrameData(NULL), 169fb5e23c327cd5f8f93d1eaa7c10f34d6fd3efb6cRomain Guy mSliceGroup(NULL) { 1703b748a44c6bd2ea05fe16839caf73dbe50bd7ae9Romain Guy 1713b748a44c6bd2ea05fe16839caf73dbe50bd7ae9Romain Guy initPorts(); 1723b748a44c6bd2ea05fe16839caf73dbe50bd7ae9Romain Guy ALOGI("Construct SoftAVCEncoder"); 1736820ac8b14b4558f5d8b833dde80895306a3e137Romain Guy} 1746820ac8b14b4558f5d8b833dde80895306a3e137Romain Guy 1756820ac8b14b4558f5d8b833dde80895306a3e137Romain GuySoftAVCEncoder::~SoftAVCEncoder() { 176f504a2fa144504ca1efd39a4ef9208e3d4d336c5Romain Guy ALOGV("Destruct SoftAVCEncoder"); 1776820ac8b14b4558f5d8b833dde80895306a3e137Romain Guy releaseEncoder(); 178fb5e23c327cd5f8f93d1eaa7c10f34d6fd3efb6cRomain Guy List<BufferInfo *> &outQueue = getPortQueue(1); 1796820ac8b14b4558f5d8b833dde80895306a3e137Romain Guy List<BufferInfo *> &inQueue = getPortQueue(0); 1803b748a44c6bd2ea05fe16839caf73dbe50bd7ae9Romain Guy CHECK(outQueue.empty()); 1813b748a44c6bd2ea05fe16839caf73dbe50bd7ae9Romain Guy CHECK(inQueue.empty()); 1825e7c469c7a3039af7696789a797f8d91a45227ebRomain Guy} 183fb5e23c327cd5f8f93d1eaa7c10f34d6fd3efb6cRomain Guy 1846820ac8b14b4558f5d8b833dde80895306a3e137Romain GuyOMX_ERRORTYPE SoftAVCEncoder::initEncParams() { 1858ab4079ca27e36e5c584495bcd71b573598ac021Romain Guy CHECK(mHandle != NULL); 186fb5e23c327cd5f8f93d1eaa7c10f34d6fd3efb6cRomain Guy memset(mHandle, 0, sizeof(tagAVCHandle)); 18741d35aef06c2a570a45474a01ca95a6cb9c29d9eRomain Guy mHandle->AVCObject = NULL; 188fb5e23c327cd5f8f93d1eaa7c10f34d6fd3efb6cRomain Guy mHandle->userData = this; 1895e7c469c7a3039af7696789a797f8d91a45227ebRomain Guy mHandle->CBAVC_DPBAlloc = DpbAllocWrapper; 1905e7c469c7a3039af7696789a797f8d91a45227ebRomain Guy mHandle->CBAVC_FrameBind = BindFrameWrapper; 1915e7c469c7a3039af7696789a797f8d91a45227ebRomain Guy mHandle->CBAVC_FrameUnbind = UnbindFrameWrapper; 1925e7c469c7a3039af7696789a797f8d91a45227ebRomain Guy mHandle->CBAVC_Malloc = MallocWrapper; 193fb5e23c327cd5f8f93d1eaa7c10f34d6fd3efb6cRomain Guy mHandle->CBAVC_Free = FreeWrapper; 194eb6a4a17a07f1aa41bd58d418b2982cddb97685aRomain Guy 195eb6a4a17a07f1aa41bd58d418b2982cddb97685aRomain Guy CHECK(mEncParams != NULL); 196eb6a4a17a07f1aa41bd58d418b2982cddb97685aRomain Guy memset(mEncParams, 0, sizeof(*mEncParams)); 1976820ac8b14b4558f5d8b833dde80895306a3e137Romain Guy mEncParams->rate_control = AVC_ON; 1986820ac8b14b4558f5d8b833dde80895306a3e137Romain Guy mEncParams->initQP = 0; 1995e7c469c7a3039af7696789a797f8d91a45227ebRomain Guy mEncParams->init_CBP_removal_delay = 1600; 2006820ac8b14b4558f5d8b833dde80895306a3e137Romain Guy 2016820ac8b14b4558f5d8b833dde80895306a3e137Romain Guy mEncParams->intramb_refresh = 0; 202fb5e23c327cd5f8f93d1eaa7c10f34d6fd3efb6cRomain Guy mEncParams->auto_scd = AVC_ON; 203fb5e23c327cd5f8f93d1eaa7c10f34d6fd3efb6cRomain Guy mEncParams->out_of_band_param_set = AVC_ON; 204fdbec3e4828f93bfa5cde758ad0e77b89c5c2ecdRomain Guy mEncParams->poc_type = 2; 205f504a2fa144504ca1efd39a4ef9208e3d4d336c5Romain Guy mEncParams->log2_max_poc_lsb_minus_4 = 12; 206f504a2fa144504ca1efd39a4ef9208e3d4d336c5Romain Guy mEncParams->delta_poc_zero_flag = 0; 207fdbec3e4828f93bfa5cde758ad0e77b89c5c2ecdRomain Guy mEncParams->offset_poc_non_ref = 0; 208fb5e23c327cd5f8f93d1eaa7c10f34d6fd3efb6cRomain Guy mEncParams->offset_top_bottom = 0; 209fb5e23c327cd5f8f93d1eaa7c10f34d6fd3efb6cRomain Guy mEncParams->num_ref_in_cycle = 0; 2107444da512680df0c52af39ea521e35adbe0c167dRomain Guy mEncParams->offset_poc_ref = NULL; 211eb6a4a17a07f1aa41bd58d418b2982cddb97685aRomain Guy 212a5ef39a21683189e5906c9f252b997f0508e350dRomain Guy mEncParams->num_ref_frame = 1; 213eb6a4a17a07f1aa41bd58d418b2982cddb97685aRomain Guy mEncParams->num_slice_group = 1; 214bd41a11078e94b755c8b6f78e1e4242c715fccd4Romain Guy mEncParams->fmo_type = 0; 21570561df470c31513056df181571632851fd0d081Romain Guy 21670561df470c31513056df181571632851fd0d081Romain Guy mEncParams->db_filter = AVC_ON; 21770561df470c31513056df181571632851fd0d081Romain Guy mEncParams->disable_db_idc = 0; 21870561df470c31513056df181571632851fd0d081Romain Guy 21970561df470c31513056df181571632851fd0d081Romain Guy mEncParams->alpha_offset = 0; 220a5ef39a21683189e5906c9f252b997f0508e350dRomain Guy mEncParams->beta_offset = 0; 2216cad75744ed3b81cf2c96f545368067b62c726ecRomain Guy mEncParams->constrained_intra_pred = AVC_OFF; 222fb13abd800cd610c7f46815848545feff83e5748Romain Guy 223fb13abd800cd610c7f46815848545feff83e5748Romain Guy mEncParams->data_par = AVC_OFF; 2246cad75744ed3b81cf2c96f545368067b62c726ecRomain Guy mEncParams->fullsearch = AVC_OFF; 2256cad75744ed3b81cf2c96f545368067b62c726ecRomain Guy mEncParams->search_range = 16; 226fb13abd800cd610c7f46815848545feff83e5748Romain Guy mEncParams->sub_pel = AVC_OFF; 2277444da512680df0c52af39ea521e35adbe0c167dRomain Guy mEncParams->submb_pred = AVC_OFF; 2284bb942083a0d4db746adf95349108dd8ef842e32Romain Guy mEncParams->rdopt_mode = AVC_OFF; 2294bb942083a0d4db746adf95349108dd8ef842e32Romain Guy mEncParams->bidir_pred = AVC_OFF; 230a5ef39a21683189e5906c9f252b997f0508e350dRomain Guy 2315b3b35296e8b2c8d3f07d32bb645d5414db41a1dRomain Guy mEncParams->use_overrun_buffer = AVC_OFF; 2325b3b35296e8b2c8d3f07d32bb645d5414db41a1dRomain Guy 2335b3b35296e8b2c8d3f07d32bb645d5414db41a1dRomain Guy if (mVideoColorFormat != OMX_COLOR_FormatYUV420Planar 2345b3b35296e8b2c8d3f07d32bb645d5414db41a1dRomain Guy || mStoreMetaDataInBuffers) { 2355b3b35296e8b2c8d3f07d32bb645d5414db41a1dRomain Guy // Color conversion is needed. 2363b748a44c6bd2ea05fe16839caf73dbe50bd7ae9Romain Guy free(mInputFrameData); 2373b748a44c6bd2ea05fe16839caf73dbe50bd7ae9Romain Guy mInputFrameData = 2386820ac8b14b4558f5d8b833dde80895306a3e137Romain Guy (uint8_t *) malloc((mVideoWidth * mVideoHeight * 3 ) >> 1); 2396820ac8b14b4558f5d8b833dde80895306a3e137Romain Guy CHECK(mInputFrameData != NULL); 2406820ac8b14b4558f5d8b833dde80895306a3e137Romain Guy } 2416820ac8b14b4558f5d8b833dde80895306a3e137Romain Guy 242a5ef39a21683189e5906c9f252b997f0508e350dRomain Guy // PV's AVC encoder requires the video dimension of multiple 2433b748a44c6bd2ea05fe16839caf73dbe50bd7ae9Romain Guy if (mVideoWidth % 16 != 0 || mVideoHeight % 16 != 0) { 2443b748a44c6bd2ea05fe16839caf73dbe50bd7ae9Romain Guy ALOGE("Video frame size %dx%d must be a multiple of 16", 245a5ef39a21683189e5906c9f252b997f0508e350dRomain Guy mVideoWidth, mVideoHeight); 246a5ef39a21683189e5906c9f252b997f0508e350dRomain Guy return OMX_ErrorBadParameter; 247a5ef39a21683189e5906c9f252b997f0508e350dRomain Guy } 2486cad75744ed3b81cf2c96f545368067b62c726ecRomain Guy 2496cad75744ed3b81cf2c96f545368067b62c726ecRomain Guy mEncParams->width = mVideoWidth; 250a5ef39a21683189e5906c9f252b997f0508e350dRomain Guy mEncParams->height = mVideoHeight; 251fb5e23c327cd5f8f93d1eaa7c10f34d6fd3efb6cRomain Guy mEncParams->bitrate = mVideoBitRate; 252fb5e23c327cd5f8f93d1eaa7c10f34d6fd3efb6cRomain Guy mEncParams->frame_rate = 1000 * mVideoFrameRate; // In frames/ms! 253fb5e23c327cd5f8f93d1eaa7c10f34d6fd3efb6cRomain Guy mEncParams->CPB_size = (uint32_t) (mVideoBitRate >> 1); 254fb5e23c327cd5f8f93d1eaa7c10f34d6fd3efb6cRomain Guy 255 int32_t nMacroBlocks = ((((mVideoWidth + 15) >> 4) << 4) * 256 (((mVideoHeight + 15) >> 4) << 4)) >> 8; 257 CHECK(mSliceGroup == NULL); 258 mSliceGroup = (uint32_t *) malloc(sizeof(uint32_t) * nMacroBlocks); 259 CHECK(mSliceGroup != NULL); 260 for (int ii = 0, idx = 0; ii < nMacroBlocks; ++ii) { 261 mSliceGroup[ii] = idx++; 262 if (idx >= mEncParams->num_slice_group) { 263 idx = 0; 264 } 265 } 266 mEncParams->slice_group = mSliceGroup; 267 268 // Set IDR frame refresh interval 269 if (mIDRFrameRefreshIntervalInSec < 0) { 270 mEncParams->idr_period = -1; 271 } else if (mIDRFrameRefreshIntervalInSec == 0) { 272 mEncParams->idr_period = 1; // All I frames 273 } else { 274 mEncParams->idr_period = 275 (mIDRFrameRefreshIntervalInSec * mVideoFrameRate); 276 } 277 278 // Set profile and level 279 mEncParams->profile = mAVCEncProfile; 280 mEncParams->level = mAVCEncLevel; 281 282 return OMX_ErrorNone; 283} 284 285OMX_ERRORTYPE SoftAVCEncoder::initEncoder() { 286 CHECK(!mStarted); 287 288 OMX_ERRORTYPE errType = OMX_ErrorNone; 289 if (OMX_ErrorNone != (errType = initEncParams())) { 290 ALOGE("Failed to initialized encoder params"); 291 mSignalledError = true; 292 notify(OMX_EventError, OMX_ErrorUndefined, 0, 0); 293 return errType; 294 } 295 296 AVCEnc_Status err; 297 err = PVAVCEncInitialize(mHandle, mEncParams, NULL, NULL); 298 if (err != AVCENC_SUCCESS) { 299 ALOGE("Failed to initialize the encoder: %d", err); 300 mSignalledError = true; 301 notify(OMX_EventError, OMX_ErrorUndefined, 0, 0); 302 return OMX_ErrorUndefined; 303 } 304 305 mNumInputFrames = -2; // 1st two buffers contain SPS and PPS 306 mSpsPpsHeaderReceived = false; 307 mReadyForNextFrame = true; 308 mIsIDRFrame = false; 309 mStarted = true; 310 311 return OMX_ErrorNone; 312} 313 314OMX_ERRORTYPE SoftAVCEncoder::releaseEncoder() { 315 if (!mStarted) { 316 return OMX_ErrorNone; 317 } 318 319 PVAVCCleanUpEncoder(mHandle); 320 releaseOutputBuffers(); 321 322 free(mInputFrameData); 323 mInputFrameData = NULL; 324 325 free(mSliceGroup); 326 mSliceGroup = NULL; 327 328 delete mEncParams; 329 mEncParams = NULL; 330 331 delete mHandle; 332 mHandle = NULL; 333 334 mStarted = false; 335 336 return OMX_ErrorNone; 337} 338 339void SoftAVCEncoder::releaseOutputBuffers() { 340 for (size_t i = 0; i < mOutputBuffers.size(); ++i) { 341 MediaBuffer *buffer = mOutputBuffers.editItemAt(i); 342 buffer->setObserver(NULL); 343 buffer->release(); 344 } 345 mOutputBuffers.clear(); 346} 347 348void SoftAVCEncoder::initPorts() { 349 OMX_PARAM_PORTDEFINITIONTYPE def; 350 InitOMXParams(&def); 351 352 const size_t kInputBufferSize = (mVideoWidth * mVideoHeight * 3) >> 1; 353 354 // 31584 is PV's magic number. Not sure why. 355 const size_t kOutputBufferSize = 356 (kInputBufferSize > 31584) ? kInputBufferSize: 31584; 357 358 def.nPortIndex = 0; 359 def.eDir = OMX_DirInput; 360 def.nBufferCountMin = kNumBuffers; 361 def.nBufferCountActual = def.nBufferCountMin; 362 def.nBufferSize = kInputBufferSize; 363 def.bEnabled = OMX_TRUE; 364 def.bPopulated = OMX_FALSE; 365 def.eDomain = OMX_PortDomainVideo; 366 def.bBuffersContiguous = OMX_FALSE; 367 def.nBufferAlignment = 1; 368 369 def.format.video.cMIMEType = const_cast<char *>("video/raw"); 370 def.format.video.eCompressionFormat = OMX_VIDEO_CodingUnused; 371 def.format.video.eColorFormat = OMX_COLOR_FormatYUV420Planar; 372 def.format.video.xFramerate = (mVideoFrameRate << 16); // Q16 format 373 def.format.video.nBitrate = mVideoBitRate; 374 def.format.video.nFrameWidth = mVideoWidth; 375 def.format.video.nFrameHeight = mVideoHeight; 376 def.format.video.nStride = mVideoWidth; 377 def.format.video.nSliceHeight = mVideoHeight; 378 379 addPort(def); 380 381 def.nPortIndex = 1; 382 def.eDir = OMX_DirOutput; 383 def.nBufferCountMin = kNumBuffers; 384 def.nBufferCountActual = def.nBufferCountMin; 385 def.nBufferSize = kOutputBufferSize; 386 def.bEnabled = OMX_TRUE; 387 def.bPopulated = OMX_FALSE; 388 def.eDomain = OMX_PortDomainVideo; 389 def.bBuffersContiguous = OMX_FALSE; 390 def.nBufferAlignment = 2; 391 392 def.format.video.cMIMEType = const_cast<char *>("video/avc"); 393 def.format.video.eCompressionFormat = OMX_VIDEO_CodingAVC; 394 def.format.video.eColorFormat = OMX_COLOR_FormatUnused; 395 def.format.video.xFramerate = (0 << 16); // Q16 format 396 def.format.video.nBitrate = mVideoBitRate; 397 def.format.video.nFrameWidth = mVideoWidth; 398 def.format.video.nFrameHeight = mVideoHeight; 399 def.format.video.nStride = mVideoWidth; 400 def.format.video.nSliceHeight = mVideoHeight; 401 402 addPort(def); 403} 404 405OMX_ERRORTYPE SoftAVCEncoder::internalGetParameter( 406 OMX_INDEXTYPE index, OMX_PTR params) { 407 switch (index) { 408 case OMX_IndexParamVideoErrorCorrection: 409 { 410 return OMX_ErrorNotImplemented; 411 } 412 413 case OMX_IndexParamVideoBitrate: 414 { 415 OMX_VIDEO_PARAM_BITRATETYPE *bitRate = 416 (OMX_VIDEO_PARAM_BITRATETYPE *) params; 417 418 if (bitRate->nPortIndex != 1) { 419 return OMX_ErrorUndefined; 420 } 421 422 bitRate->eControlRate = OMX_Video_ControlRateVariable; 423 bitRate->nTargetBitrate = mVideoBitRate; 424 return OMX_ErrorNone; 425 } 426 427 case OMX_IndexParamVideoPortFormat: 428 { 429 OMX_VIDEO_PARAM_PORTFORMATTYPE *formatParams = 430 (OMX_VIDEO_PARAM_PORTFORMATTYPE *)params; 431 432 if (formatParams->nPortIndex > 1) { 433 return OMX_ErrorUndefined; 434 } 435 436 if (formatParams->nIndex > 2) { 437 return OMX_ErrorNoMore; 438 } 439 440 if (formatParams->nPortIndex == 0) { 441 formatParams->eCompressionFormat = OMX_VIDEO_CodingUnused; 442 if (formatParams->nIndex == 0) { 443 formatParams->eColorFormat = OMX_COLOR_FormatYUV420Planar; 444 } else if (formatParams->nIndex == 1) { 445 formatParams->eColorFormat = OMX_COLOR_FormatYUV420SemiPlanar; 446 } else { 447 formatParams->eColorFormat = OMX_COLOR_FormatAndroidOpaque; 448 } 449 } else { 450 formatParams->eCompressionFormat = OMX_VIDEO_CodingAVC; 451 formatParams->eColorFormat = OMX_COLOR_FormatUnused; 452 } 453 454 return OMX_ErrorNone; 455 } 456 457 case OMX_IndexParamVideoAvc: 458 { 459 OMX_VIDEO_PARAM_AVCTYPE *avcParams = 460 (OMX_VIDEO_PARAM_AVCTYPE *)params; 461 462 if (avcParams->nPortIndex != 1) { 463 return OMX_ErrorUndefined; 464 } 465 466 avcParams->eProfile = OMX_VIDEO_AVCProfileBaseline; 467 OMX_U32 omxLevel = AVC_LEVEL2; 468 if (OMX_ErrorNone != 469 ConvertAvcSpecLevelToOmxAvcLevel(mAVCEncLevel, &omxLevel)) { 470 return OMX_ErrorUndefined; 471 } 472 473 avcParams->eLevel = (OMX_VIDEO_AVCLEVELTYPE) omxLevel; 474 avcParams->nRefFrames = 1; 475 avcParams->nBFrames = 0; 476 avcParams->bUseHadamard = OMX_TRUE; 477 avcParams->nAllowedPictureTypes = 478 (OMX_VIDEO_PictureTypeI | OMX_VIDEO_PictureTypeP); 479 avcParams->nRefIdx10ActiveMinus1 = 0; 480 avcParams->nRefIdx11ActiveMinus1 = 0; 481 avcParams->bWeightedPPrediction = OMX_FALSE; 482 avcParams->bEntropyCodingCABAC = OMX_FALSE; 483 avcParams->bconstIpred = OMX_FALSE; 484 avcParams->bDirect8x8Inference = OMX_FALSE; 485 avcParams->bDirectSpatialTemporal = OMX_FALSE; 486 avcParams->nCabacInitIdc = 0; 487 return OMX_ErrorNone; 488 } 489 490 case OMX_IndexParamVideoProfileLevelQuerySupported: 491 { 492 OMX_VIDEO_PARAM_PROFILELEVELTYPE *profileLevel = 493 (OMX_VIDEO_PARAM_PROFILELEVELTYPE *)params; 494 495 if (profileLevel->nPortIndex != 1) { 496 return OMX_ErrorUndefined; 497 } 498 499 const size_t size = 500 sizeof(ConversionTable) / sizeof(ConversionTable[0]); 501 502 if (profileLevel->nProfileIndex >= size) { 503 return OMX_ErrorNoMore; 504 } 505 506 profileLevel->eProfile = OMX_VIDEO_AVCProfileBaseline; 507 profileLevel->eLevel = ConversionTable[profileLevel->nProfileIndex].omxLevel; 508 509 return OMX_ErrorNone; 510 } 511 512 default: 513 return SimpleSoftOMXComponent::internalGetParameter(index, params); 514 } 515} 516 517OMX_ERRORTYPE SoftAVCEncoder::internalSetParameter( 518 OMX_INDEXTYPE index, const OMX_PTR params) { 519 int32_t indexFull = index; 520 521 switch (indexFull) { 522 case OMX_IndexParamVideoErrorCorrection: 523 { 524 return OMX_ErrorNotImplemented; 525 } 526 527 case OMX_IndexParamVideoBitrate: 528 { 529 OMX_VIDEO_PARAM_BITRATETYPE *bitRate = 530 (OMX_VIDEO_PARAM_BITRATETYPE *) params; 531 532 if (bitRate->nPortIndex != 1 || 533 bitRate->eControlRate != OMX_Video_ControlRateVariable) { 534 return OMX_ErrorUndefined; 535 } 536 537 mVideoBitRate = bitRate->nTargetBitrate; 538 return OMX_ErrorNone; 539 } 540 541 case OMX_IndexParamPortDefinition: 542 { 543 OMX_PARAM_PORTDEFINITIONTYPE *def = 544 (OMX_PARAM_PORTDEFINITIONTYPE *)params; 545 if (def->nPortIndex > 1) { 546 return OMX_ErrorUndefined; 547 } 548 549 if (def->nPortIndex == 0) { 550 if (def->format.video.eCompressionFormat != OMX_VIDEO_CodingUnused || 551 (def->format.video.eColorFormat != OMX_COLOR_FormatYUV420Planar && 552 def->format.video.eColorFormat != OMX_COLOR_FormatYUV420SemiPlanar && 553 def->format.video.eColorFormat != OMX_COLOR_FormatAndroidOpaque)) { 554 return OMX_ErrorUndefined; 555 } 556 } else { 557 if (def->format.video.eCompressionFormat != OMX_VIDEO_CodingAVC || 558 (def->format.video.eColorFormat != OMX_COLOR_FormatUnused)) { 559 return OMX_ErrorUndefined; 560 } 561 } 562 563 OMX_ERRORTYPE err = SimpleSoftOMXComponent::internalSetParameter(index, params); 564 if (OMX_ErrorNone != err) { 565 return err; 566 } 567 568 if (def->nPortIndex == 0) { 569 mVideoWidth = def->format.video.nFrameWidth; 570 mVideoHeight = def->format.video.nFrameHeight; 571 mVideoFrameRate = def->format.video.xFramerate >> 16; 572 mVideoColorFormat = def->format.video.eColorFormat; 573 574 OMX_PARAM_PORTDEFINITIONTYPE *portDef = 575 &editPortInfo(0)->mDef; 576 portDef->format.video.nFrameWidth = mVideoWidth; 577 portDef->format.video.nFrameHeight = mVideoHeight; 578 portDef->format.video.xFramerate = def->format.video.xFramerate; 579 portDef->format.video.eColorFormat = 580 (OMX_COLOR_FORMATTYPE) mVideoColorFormat; 581 portDef = &editPortInfo(1)->mDef; 582 portDef->format.video.nFrameWidth = mVideoWidth; 583 portDef->format.video.nFrameHeight = mVideoHeight; 584 } else { 585 mVideoBitRate = def->format.video.nBitrate; 586 } 587 588 return OMX_ErrorNone; 589 } 590 591 case OMX_IndexParamStandardComponentRole: 592 { 593 const OMX_PARAM_COMPONENTROLETYPE *roleParams = 594 (const OMX_PARAM_COMPONENTROLETYPE *)params; 595 596 if (strncmp((const char *)roleParams->cRole, 597 "video_encoder.avc", 598 OMX_MAX_STRINGNAME_SIZE - 1)) { 599 return OMX_ErrorUndefined; 600 } 601 602 return OMX_ErrorNone; 603 } 604 605 case OMX_IndexParamVideoPortFormat: 606 { 607 const OMX_VIDEO_PARAM_PORTFORMATTYPE *formatParams = 608 (const OMX_VIDEO_PARAM_PORTFORMATTYPE *)params; 609 610 if (formatParams->nPortIndex > 1) { 611 return OMX_ErrorUndefined; 612 } 613 614 if (formatParams->nIndex > 2) { 615 return OMX_ErrorNoMore; 616 } 617 618 if (formatParams->nPortIndex == 0) { 619 if (formatParams->eCompressionFormat != OMX_VIDEO_CodingUnused || 620 ((formatParams->nIndex == 0 && 621 formatParams->eColorFormat != OMX_COLOR_FormatYUV420Planar) || 622 (formatParams->nIndex == 1 && 623 formatParams->eColorFormat != OMX_COLOR_FormatYUV420SemiPlanar) || 624 (formatParams->nIndex == 2 && 625 formatParams->eColorFormat != OMX_COLOR_FormatAndroidOpaque) )) { 626 return OMX_ErrorUndefined; 627 } 628 mVideoColorFormat = formatParams->eColorFormat; 629 } else { 630 if (formatParams->eCompressionFormat != OMX_VIDEO_CodingAVC || 631 formatParams->eColorFormat != OMX_COLOR_FormatUnused) { 632 return OMX_ErrorUndefined; 633 } 634 } 635 636 return OMX_ErrorNone; 637 } 638 639 case OMX_IndexParamVideoAvc: 640 { 641 OMX_VIDEO_PARAM_AVCTYPE *avcType = 642 (OMX_VIDEO_PARAM_AVCTYPE *)params; 643 644 if (avcType->nPortIndex != 1) { 645 return OMX_ErrorUndefined; 646 } 647 648 // PV's AVC encoder only supports baseline profile 649 if (avcType->eProfile != OMX_VIDEO_AVCProfileBaseline || 650 avcType->nRefFrames != 1 || 651 avcType->nBFrames != 0 || 652 avcType->bUseHadamard != OMX_TRUE || 653 (avcType->nAllowedPictureTypes & OMX_VIDEO_PictureTypeB) != 0 || 654 avcType->nRefIdx10ActiveMinus1 != 0 || 655 avcType->nRefIdx11ActiveMinus1 != 0 || 656 avcType->bWeightedPPrediction != OMX_FALSE || 657 avcType->bEntropyCodingCABAC != OMX_FALSE || 658 avcType->bconstIpred != OMX_FALSE || 659 avcType->bDirect8x8Inference != OMX_FALSE || 660 avcType->bDirectSpatialTemporal != OMX_FALSE || 661 avcType->nCabacInitIdc != 0) { 662 return OMX_ErrorUndefined; 663 } 664 665 if (OK != ConvertOmxAvcLevelToAvcSpecLevel(avcType->eLevel, &mAVCEncLevel)) { 666 return OMX_ErrorUndefined; 667 } 668 669 return OMX_ErrorNone; 670 } 671 672 case kStoreMetaDataExtensionIndex: 673 { 674 StoreMetaDataInBuffersParams *storeParams = 675 (StoreMetaDataInBuffersParams*)params; 676 if (storeParams->nPortIndex != 0) { 677 ALOGE("%s: StoreMetadataInBuffersParams.nPortIndex not zero!", 678 __FUNCTION__); 679 return OMX_ErrorUndefined; 680 } 681 682 mStoreMetaDataInBuffers = storeParams->bStoreMetaData; 683 ALOGV("StoreMetaDataInBuffers set to: %s", 684 mStoreMetaDataInBuffers ? " true" : "false"); 685 686 if (mStoreMetaDataInBuffers) { 687 mVideoColorFormat = OMX_COLOR_FormatAndroidOpaque; 688 } 689 690 return OMX_ErrorNone; 691 } 692 693 default: 694 return SimpleSoftOMXComponent::internalSetParameter(index, params); 695 } 696} 697 698void SoftAVCEncoder::onQueueFilled(OMX_U32 /* portIndex */) { 699 if (mSignalledError || mSawInputEOS) { 700 return; 701 } 702 703 if (!mStarted) { 704 if (OMX_ErrorNone != initEncoder()) { 705 return; 706 } 707 } 708 709 List<BufferInfo *> &inQueue = getPortQueue(0); 710 List<BufferInfo *> &outQueue = getPortQueue(1); 711 712 while (!mSawInputEOS && !inQueue.empty() && !outQueue.empty()) { 713 BufferInfo *inInfo = *inQueue.begin(); 714 OMX_BUFFERHEADERTYPE *inHeader = inInfo->mHeader; 715 BufferInfo *outInfo = *outQueue.begin(); 716 OMX_BUFFERHEADERTYPE *outHeader = outInfo->mHeader; 717 718 outHeader->nTimeStamp = 0; 719 outHeader->nFlags = 0; 720 outHeader->nOffset = 0; 721 outHeader->nFilledLen = 0; 722 outHeader->nOffset = 0; 723 724 uint8_t *outPtr = (uint8_t *) outHeader->pBuffer; 725 uint32_t dataLength = outHeader->nAllocLen; 726 727 if (!mSpsPpsHeaderReceived && mNumInputFrames < 0) { 728 // 4 bytes are reserved for holding the start code 0x00000001 729 // of the sequence parameter set at the beginning. 730 outPtr += 4; 731 dataLength -= 4; 732 } 733 734 int32_t type; 735 AVCEnc_Status encoderStatus = AVCENC_SUCCESS; 736 737 // Combine SPS and PPS and place them in the very first output buffer 738 // SPS and PPS are separated by start code 0x00000001 739 // Assume that we have exactly one SPS and exactly one PPS. 740 while (!mSpsPpsHeaderReceived && mNumInputFrames <= 0) { 741 encoderStatus = PVAVCEncodeNAL(mHandle, outPtr, &dataLength, &type); 742 if (encoderStatus == AVCENC_WRONG_STATE) { 743 mSpsPpsHeaderReceived = true; 744 CHECK_EQ(0, mNumInputFrames); // 1st video frame is 0 745 outHeader->nFlags = OMX_BUFFERFLAG_CODECCONFIG; 746 outQueue.erase(outQueue.begin()); 747 outInfo->mOwnedByUs = false; 748 notifyFillBufferDone(outHeader); 749 return; 750 } else { 751 switch (type) { 752 case AVC_NALTYPE_SPS: 753 ++mNumInputFrames; 754 memcpy((uint8_t *)outHeader->pBuffer, "\x00\x00\x00\x01", 4); 755 outHeader->nFilledLen = 4 + dataLength; 756 outPtr += (dataLength + 4); // 4 bytes for next start code 757 dataLength = outHeader->nAllocLen - outHeader->nFilledLen; 758 break; 759 default: 760 CHECK_EQ(AVC_NALTYPE_PPS, type); 761 ++mNumInputFrames; 762 memcpy((uint8_t *) outHeader->pBuffer + outHeader->nFilledLen, 763 "\x00\x00\x00\x01", 4); 764 outHeader->nFilledLen += (dataLength + 4); 765 outPtr += (dataLength + 4); 766 break; 767 } 768 } 769 } 770 771 // Get next input video frame 772 if (mReadyForNextFrame) { 773 // Save the input buffer info so that it can be 774 // passed to an output buffer 775 InputBufferInfo info; 776 info.mTimeUs = inHeader->nTimeStamp; 777 info.mFlags = inHeader->nFlags; 778 mInputBufferInfoVec.push(info); 779 mPrevTimestampUs = inHeader->nTimeStamp; 780 781 if (inHeader->nFlags & OMX_BUFFERFLAG_EOS) { 782 mSawInputEOS = true; 783 } 784 785 if (inHeader->nFilledLen > 0) { 786 AVCFrameIO videoInput; 787 memset(&videoInput, 0, sizeof(videoInput)); 788 videoInput.height = ((mVideoHeight + 15) >> 4) << 4; 789 videoInput.pitch = ((mVideoWidth + 15) >> 4) << 4; 790 videoInput.coding_timestamp = (inHeader->nTimeStamp + 500) / 1000; // in ms 791 const uint8_t *inputData = NULL; 792 if (mStoreMetaDataInBuffers) { 793 if (inHeader->nFilledLen != 8) { 794 ALOGE("MetaData buffer is wrong size! " 795 "(got %u bytes, expected 8)", inHeader->nFilledLen); 796 mSignalledError = true; 797 notify(OMX_EventError, OMX_ErrorUndefined, 0, 0); 798 return; 799 } 800 inputData = 801 extractGraphicBuffer( 802 mInputFrameData, (mVideoWidth * mVideoHeight * 3) >> 1, 803 inHeader->pBuffer + inHeader->nOffset, inHeader->nFilledLen, 804 mVideoWidth, mVideoHeight); 805 if (inputData == NULL) { 806 ALOGE("Unable to extract gralloc buffer in metadata mode"); 807 mSignalledError = true; 808 notify(OMX_EventError, OMX_ErrorUndefined, 0, 0); 809 return; 810 } 811 // TODO: Verify/convert pixel format enum 812 } else { 813 inputData = (const uint8_t *)inHeader->pBuffer + inHeader->nOffset; 814 if (mVideoColorFormat != OMX_COLOR_FormatYUV420Planar) { 815 ConvertYUV420SemiPlanarToYUV420Planar( 816 inputData, mInputFrameData, mVideoWidth, mVideoHeight); 817 inputData = mInputFrameData; 818 } 819 } 820 821 CHECK(inputData != NULL); 822 videoInput.YCbCr[0] = (uint8_t *)inputData; 823 videoInput.YCbCr[1] = videoInput.YCbCr[0] + videoInput.height * videoInput.pitch; 824 videoInput.YCbCr[2] = videoInput.YCbCr[1] + 825 ((videoInput.height * videoInput.pitch) >> 2); 826 videoInput.disp_order = mNumInputFrames; 827 828 encoderStatus = PVAVCEncSetInput(mHandle, &videoInput); 829 if (encoderStatus == AVCENC_SUCCESS || encoderStatus == AVCENC_NEW_IDR) { 830 mReadyForNextFrame = false; 831 ++mNumInputFrames; 832 if (encoderStatus == AVCENC_NEW_IDR) { 833 mIsIDRFrame = 1; 834 } 835 } else { 836 if (encoderStatus < AVCENC_SUCCESS) { 837 ALOGE("encoderStatus = %d at line %d", encoderStatus, __LINE__); 838 mSignalledError = true; 839 notify(OMX_EventError, OMX_ErrorUndefined, 0, 0); 840 return; 841 } else { 842 ALOGV("encoderStatus = %d at line %d", encoderStatus, __LINE__); 843 inQueue.erase(inQueue.begin()); 844 inInfo->mOwnedByUs = false; 845 notifyEmptyBufferDone(inHeader); 846 return; 847 } 848 } 849 } 850 } 851 852 // Encode an input video frame 853 CHECK(encoderStatus == AVCENC_SUCCESS || encoderStatus == AVCENC_NEW_IDR); 854 dataLength = outHeader->nAllocLen; // Reset the output buffer length 855 if (inHeader->nFilledLen > 0) { 856 if (outHeader->nAllocLen >= 4) { 857 memcpy(outPtr, "\x00\x00\x00\x01", 4); 858 outPtr += 4; 859 dataLength -= 4; 860 } 861 encoderStatus = PVAVCEncodeNAL(mHandle, outPtr, &dataLength, &type); 862 dataLength = outPtr + dataLength - outHeader->pBuffer; 863 if (encoderStatus == AVCENC_SUCCESS) { 864 CHECK(NULL == PVAVCEncGetOverrunBuffer(mHandle)); 865 } else if (encoderStatus == AVCENC_PICTURE_READY) { 866 CHECK(NULL == PVAVCEncGetOverrunBuffer(mHandle)); 867 if (mIsIDRFrame) { 868 outHeader->nFlags |= OMX_BUFFERFLAG_SYNCFRAME; 869 mIsIDRFrame = false; 870 } 871 mReadyForNextFrame = true; 872 AVCFrameIO recon; 873 if (PVAVCEncGetRecon(mHandle, &recon) == AVCENC_SUCCESS) { 874 PVAVCEncReleaseRecon(mHandle, &recon); 875 } 876 } else { 877 dataLength = 0; 878 mReadyForNextFrame = true; 879 } 880 881 if (encoderStatus < AVCENC_SUCCESS) { 882 ALOGE("encoderStatus = %d at line %d", encoderStatus, __LINE__); 883 mSignalledError = true; 884 notify(OMX_EventError, OMX_ErrorUndefined, 0, 0); 885 return; 886 } 887 } else { 888 dataLength = 0; 889 } 890 891 inQueue.erase(inQueue.begin()); 892 inInfo->mOwnedByUs = false; 893 notifyEmptyBufferDone(inHeader); 894 895 outQueue.erase(outQueue.begin()); 896 CHECK(!mInputBufferInfoVec.empty()); 897 InputBufferInfo *inputBufInfo = mInputBufferInfoVec.begin(); 898 outHeader->nTimeStamp = inputBufInfo->mTimeUs; 899 outHeader->nFlags |= (inputBufInfo->mFlags | OMX_BUFFERFLAG_ENDOFFRAME); 900 if (mSawInputEOS) { 901 outHeader->nFlags |= OMX_BUFFERFLAG_EOS; 902 } 903 outHeader->nFilledLen = dataLength; 904 outInfo->mOwnedByUs = false; 905 notifyFillBufferDone(outHeader); 906 mInputBufferInfoVec.erase(mInputBufferInfoVec.begin()); 907 } 908} 909 910int32_t SoftAVCEncoder::allocOutputBuffers( 911 unsigned int sizeInMbs, unsigned int numBuffers) { 912 CHECK(mOutputBuffers.isEmpty()); 913 size_t frameSize = (sizeInMbs << 7) * 3; 914 for (unsigned int i = 0; i < numBuffers; ++i) { 915 MediaBuffer *buffer = new MediaBuffer(frameSize); 916 buffer->setObserver(this); 917 mOutputBuffers.push(buffer); 918 } 919 920 return 1; 921} 922 923void SoftAVCEncoder::unbindOutputBuffer(int32_t index) { 924 CHECK(index >= 0); 925} 926 927int32_t SoftAVCEncoder::bindOutputBuffer(int32_t index, uint8_t **yuv) { 928 CHECK(index >= 0); 929 CHECK(index < (int32_t) mOutputBuffers.size()); 930 *yuv = (uint8_t *) mOutputBuffers[index]->data(); 931 932 return 1; 933} 934 935void SoftAVCEncoder::signalBufferReturned(MediaBuffer *buffer) { 936 UNUSED_UNLESS_VERBOSE(buffer); 937 ALOGV("signalBufferReturned: %p", buffer); 938} 939 940} // namespace android 941 942android::SoftOMXComponent *createSoftOMXComponent( 943 const char *name, const OMX_CALLBACKTYPE *callbacks, 944 OMX_PTR appData, OMX_COMPONENTTYPE **component) { 945 return new android::SoftAVCEncoder(name, callbacks, appData, component); 946} 947