OMXNodeInstance.cpp revision 2be091cebb9462b63d7160d0fa2cfa8703973a69
145f1e08c348ccb129bcc25e438c05421f7123f41Adam Powell/* 245f1e08c348ccb129bcc25e438c05421f7123f41Adam Powell * Copyright (C) 2009 The Android Open Source Project 345f1e08c348ccb129bcc25e438c05421f7123f41Adam Powell * 445f1e08c348ccb129bcc25e438c05421f7123f41Adam Powell * Licensed under the Apache License, Version 2.0 (the "License"); 545f1e08c348ccb129bcc25e438c05421f7123f41Adam Powell * you may not use this file except in compliance with the License. 645f1e08c348ccb129bcc25e438c05421f7123f41Adam Powell * You may obtain a copy of the License at 745f1e08c348ccb129bcc25e438c05421f7123f41Adam Powell * 845f1e08c348ccb129bcc25e438c05421f7123f41Adam Powell * http://www.apache.org/licenses/LICENSE-2.0 945f1e08c348ccb129bcc25e438c05421f7123f41Adam Powell * 1045f1e08c348ccb129bcc25e438c05421f7123f41Adam Powell * Unless required by applicable law or agreed to in writing, software 1145f1e08c348ccb129bcc25e438c05421f7123f41Adam Powell * distributed under the License is distributed on an "AS IS" BASIS, 1245f1e08c348ccb129bcc25e438c05421f7123f41Adam Powell * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 1345f1e08c348ccb129bcc25e438c05421f7123f41Adam Powell * See the License for the specific language governing permissions and 1445f1e08c348ccb129bcc25e438c05421f7123f41Adam Powell * limitations under the License. 1545f1e08c348ccb129bcc25e438c05421f7123f41Adam Powell */ 1645f1e08c348ccb129bcc25e438c05421f7123f41Adam Powell 1745f1e08c348ccb129bcc25e438c05421f7123f41Adam Powell//#define LOG_NDEBUG 0 1845f1e08c348ccb129bcc25e438c05421f7123f41Adam Powell#define LOG_TAG "OMXNodeInstance" 1945f1e08c348ccb129bcc25e438c05421f7123f41Adam Powell#include <utils/Log.h> 2045f1e08c348ccb129bcc25e438c05421f7123f41Adam Powell 2145f1e08c348ccb129bcc25e438c05421f7123f41Adam Powell#include <inttypes.h> 22640a66eac612b850b5dabd3b93bd94f83ed2d567Adam Powell 236ecf3d1690789ace1a667093ad6bbdd6cd35bda7Adam Powell#include "../include/OMXNodeInstance.h" 24dae7824c4b78d02159c6ad0896f246942d7b3d8cAdam Powell#include "OMXMaster.h" 2545f1e08c348ccb129bcc25e438c05421f7123f41Adam Powell#include "OMXUtils.h" 2645f1e08c348ccb129bcc25e438c05421f7123f41Adam Powell#include <android/IOMXBufferSource.h> 2745f1e08c348ccb129bcc25e438c05421f7123f41Adam Powell 2845f1e08c348ccb129bcc25e438c05421f7123f41Adam Powell#include <OMX_Component.h> 2945f1e08c348ccb129bcc25e438c05421f7123f41Adam Powell#include <OMX_IndexExt.h> 3045f1e08c348ccb129bcc25e438c05421f7123f41Adam Powell#include <OMX_VideoExt.h> 3145f1e08c348ccb129bcc25e438c05421f7123f41Adam Powell#include <OMX_AsString.h> 3245f1e08c348ccb129bcc25e438c05421f7123f41Adam Powell 3301feaee3d9767ef1185783877e92244f14d7d4baAdam Powell#include <binder/IMemory.h> 34dae7824c4b78d02159c6ad0896f246942d7b3d8cAdam Powell#include <cutils/properties.h> 3501feaee3d9767ef1185783877e92244f14d7d4baAdam Powell#include <gui/BufferQueue.h> 3645f1e08c348ccb129bcc25e438c05421f7123f41Adam Powell#include <HardwareAPI.h> 3745f1e08c348ccb129bcc25e438c05421f7123f41Adam Powell#include <media/stagefright/foundation/ADebug.h> 3845f1e08c348ccb129bcc25e438c05421f7123f41Adam Powell#include <media/stagefright/foundation/ABuffer.h> 3945f1e08c348ccb129bcc25e438c05421f7123f41Adam Powell#include <media/stagefright/foundation/ColorUtils.h> 4045f1e08c348ccb129bcc25e438c05421f7123f41Adam Powell#include <media/stagefright/MediaErrors.h> 4145f1e08c348ccb129bcc25e438c05421f7123f41Adam Powell#include <utils/misc.h> 4245f1e08c348ccb129bcc25e438c05421f7123f41Adam Powell#include <utils/NativeHandle.h> 4345f1e08c348ccb129bcc25e438c05421f7123f41Adam Powell#include <media/OMXBuffer.h> 4445f1e08c348ccb129bcc25e438c05421f7123f41Adam Powell#include <media/stagefright/xmlparser/MediaCodecsXmlParser.h> 4545f1e08c348ccb129bcc25e438c05421f7123f41Adam Powell 4645f1e08c348ccb129bcc25e438c05421f7123f41Adam Powell#include <hidlmemory/mapping.h> 4745f1e08c348ccb129bcc25e438c05421f7123f41Adam Powell 486ecf3d1690789ace1a667093ad6bbdd6cd35bda7Adam Powellstatic const OMX_U32 kPortIndexInput = 0; 4901feaee3d9767ef1185783877e92244f14d7d4baAdam Powellstatic const OMX_U32 kPortIndexOutput = 1; 5001feaee3d9767ef1185783877e92244f14d7d4baAdam Powell 5101feaee3d9767ef1185783877e92244f14d7d4baAdam Powell#define CLOGW(fmt, ...) ALOGW("[%p:%s] " fmt, mHandle, mName, ##__VA_ARGS__) 5201feaee3d9767ef1185783877e92244f14d7d4baAdam Powell 5301feaee3d9767ef1185783877e92244f14d7d4baAdam Powell#define CLOG_ERROR_IF(cond, fn, err, fmt, ...) \ 5401feaee3d9767ef1185783877e92244f14d7d4baAdam Powell ALOGE_IF(cond, #fn "(%p:%s, " fmt ") ERROR: %s(%#x)", \ 5501feaee3d9767ef1185783877e92244f14d7d4baAdam Powell mHandle, mName, ##__VA_ARGS__, asString(err), err) 5601feaee3d9767ef1185783877e92244f14d7d4baAdam Powell#define CLOG_ERROR(fn, err, fmt, ...) CLOG_ERROR_IF(true, fn, err, fmt, ##__VA_ARGS__) 5701feaee3d9767ef1185783877e92244f14d7d4baAdam Powell#define CLOG_IF_ERROR(fn, err, fmt, ...) \ 5801feaee3d9767ef1185783877e92244f14d7d4baAdam Powell CLOG_ERROR_IF((err) != OMX_ErrorNone, fn, err, fmt, ##__VA_ARGS__) 5901feaee3d9767ef1185783877e92244f14d7d4baAdam Powell 6001feaee3d9767ef1185783877e92244f14d7d4baAdam Powell#define CLOGI_(level, fn, fmt, ...) \ 6101feaee3d9767ef1185783877e92244f14d7d4baAdam Powell ALOGI_IF(DEBUG >= (level), #fn "(%p:%s, " fmt ")", mHandle, mName, ##__VA_ARGS__) 6201feaee3d9767ef1185783877e92244f14d7d4baAdam Powell#define CLOGD_(level, fn, fmt, ...) \ 6301feaee3d9767ef1185783877e92244f14d7d4baAdam Powell ALOGD_IF(DEBUG >= (level), #fn "(%p:%s, " fmt ")", mHandle, mName, ##__VA_ARGS__) 6401feaee3d9767ef1185783877e92244f14d7d4baAdam Powell 6501feaee3d9767ef1185783877e92244f14d7d4baAdam Powell#define CLOG_LIFE(fn, fmt, ...) CLOGI_(ADebug::kDebugLifeCycle, fn, fmt, ##__VA_ARGS__) 6601feaee3d9767ef1185783877e92244f14d7d4baAdam Powell#define CLOG_STATE(fn, fmt, ...) CLOGI_(ADebug::kDebugState, fn, fmt, ##__VA_ARGS__) 6701feaee3d9767ef1185783877e92244f14d7d4baAdam Powell#define CLOG_CONFIG(fn, fmt, ...) CLOGI_(ADebug::kDebugConfig, fn, fmt, ##__VA_ARGS__) 686ecf3d1690789ace1a667093ad6bbdd6cd35bda7Adam Powell#define CLOG_INTERNAL(fn, fmt, ...) CLOGD_(ADebug::kDebugInternalState, fn, fmt, ##__VA_ARGS__) 696ecf3d1690789ace1a667093ad6bbdd6cd35bda7Adam Powell 706ecf3d1690789ace1a667093ad6bbdd6cd35bda7Adam Powell#define CLOG_DEBUG_IF(cond, fn, fmt, ...) \ 71dae7824c4b78d02159c6ad0896f246942d7b3d8cAdam Powell ALOGD_IF(cond, #fn "(%p, " fmt ")", mHandle, ##__VA_ARGS__) 72dae7824c4b78d02159c6ad0896f246942d7b3d8cAdam Powell 736ecf3d1690789ace1a667093ad6bbdd6cd35bda7Adam Powell#define CLOG_BUFFER(fn, fmt, ...) \ 746ecf3d1690789ace1a667093ad6bbdd6cd35bda7Adam Powell CLOG_DEBUG_IF(DEBUG >= ADebug::kDebugAll, fn, fmt, ##__VA_ARGS__) 75dae7824c4b78d02159c6ad0896f246942d7b3d8cAdam Powell#define CLOG_BUMPED_BUFFER(fn, fmt, ...) \ 76dae7824c4b78d02159c6ad0896f246942d7b3d8cAdam Powell CLOG_DEBUG_IF(DEBUG_BUMP >= ADebug::kDebugAll, fn, fmt, ##__VA_ARGS__) 77dae7824c4b78d02159c6ad0896f246942d7b3d8cAdam Powell 78dae7824c4b78d02159c6ad0896f246942d7b3d8cAdam Powell/* buffer formatting */ 79dae7824c4b78d02159c6ad0896f246942d7b3d8cAdam Powell#define BUFFER_FMT(port, fmt, ...) "%s:%u " fmt, portString(port), (port), ##__VA_ARGS__ 80dae7824c4b78d02159c6ad0896f246942d7b3d8cAdam Powell#define NEW_BUFFER_FMT(buffer_id, port, fmt, ...) \ 8125151e4792e9be8dbb892b7eba7349773b8127afAdam Powell BUFFER_FMT(port, fmt ") (#%zu => %#x", ##__VA_ARGS__, mActiveBuffers.size(), (buffer_id)) 8225151e4792e9be8dbb892b7eba7349773b8127afAdam Powell 8325151e4792e9be8dbb892b7eba7349773b8127afAdam Powell#define SIMPLE_BUFFER(port, size, data) BUFFER_FMT(port, "%zu@%p", (size), (data)) 84dae7824c4b78d02159c6ad0896f246942d7b3d8cAdam Powell#define SIMPLE_NEW_BUFFER(buffer_id, port, size, data) \ 85dae7824c4b78d02159c6ad0896f246942d7b3d8cAdam Powell NEW_BUFFER_FMT(buffer_id, port, "%zu@%p", (size), (data)) 86dae7824c4b78d02159c6ad0896f246942d7b3d8cAdam Powell 87dae7824c4b78d02159c6ad0896f246942d7b3d8cAdam Powell#define EMPTY_BUFFER(addr, header, fenceFd) "%#x [%u@%p fc=%d]", \ 88dae7824c4b78d02159c6ad0896f246942d7b3d8cAdam Powell (addr), (header)->nAllocLen, (header)->pBuffer, (fenceFd) 89dae7824c4b78d02159c6ad0896f246942d7b3d8cAdam Powell#define FULL_BUFFER(addr, header, fenceFd) "%#" PRIxPTR " [%u@%p (%u..+%u) f=%x ts=%lld fc=%d]", \ 90dae7824c4b78d02159c6ad0896f246942d7b3d8cAdam Powell (intptr_t)(addr), (header)->nAllocLen, (header)->pBuffer, \ 91640a66eac612b850b5dabd3b93bd94f83ed2d567Adam Powell (header)->nOffset, (header)->nFilledLen, (header)->nFlags, (header)->nTimeStamp, (fenceFd) 92640a66eac612b850b5dabd3b93bd94f83ed2d567Adam Powell 93640a66eac612b850b5dabd3b93bd94f83ed2d567Adam Powell#define WITH_STATS_WRAPPER(fmt, ...) fmt " { IN=%zu/%zu OUT=%zu/%zu }", ##__VA_ARGS__, \ 94640a66eac612b850b5dabd3b93bd94f83ed2d567Adam Powell mInputBuffersWithCodec.size(), mNumPortBuffers[kPortIndexInput], \ 95640a66eac612b850b5dabd3b93bd94f83ed2d567Adam Powell mOutputBuffersWithCodec.size(), mNumPortBuffers[kPortIndexOutput] 96640a66eac612b850b5dabd3b93bd94f83ed2d567Adam Powell// TRICKY: this is needed so formatting macros expand before substitution 97dae7824c4b78d02159c6ad0896f246942d7b3d8cAdam Powell#define WITH_STATS(fmt, ...) WITH_STATS_WRAPPER(fmt, ##__VA_ARGS__) 98dae7824c4b78d02159c6ad0896f246942d7b3d8cAdam Powell 99d21aa12e8eb9d46ee92bf408b4b48386c6bf062dAdam Powellnamespace android { 100d21aa12e8eb9d46ee92bf408b4b48386c6bf062dAdam Powell 101d21aa12e8eb9d46ee92bf408b4b48386c6bf062dAdam Powellstruct BufferMeta { 102d21aa12e8eb9d46ee92bf408b4b48386c6bf062dAdam Powell explicit BufferMeta( 103d21aa12e8eb9d46ee92bf408b4b48386c6bf062dAdam Powell const sp<IMemory> &mem, const sp<IHidlMemory> &hidlMemory, 104d21aa12e8eb9d46ee92bf408b4b48386c6bf062dAdam Powell OMX_U32 portIndex, bool copy, OMX_U8 *backup) 105d21aa12e8eb9d46ee92bf408b4b48386c6bf062dAdam Powell : mMem(mem), 106d21aa12e8eb9d46ee92bf408b4b48386c6bf062dAdam Powell mHidlMemory(hidlMemory), 107d21aa12e8eb9d46ee92bf408b4b48386c6bf062dAdam Powell mCopyFromOmx(portIndex == kPortIndexOutput && copy), 108d21aa12e8eb9d46ee92bf408b4b48386c6bf062dAdam Powell mCopyToOmx(portIndex == kPortIndexInput && copy), 109d21aa12e8eb9d46ee92bf408b4b48386c6bf062dAdam Powell mPortIndex(portIndex), 110d21aa12e8eb9d46ee92bf408b4b48386c6bf062dAdam Powell mBackup(backup) { 111d21aa12e8eb9d46ee92bf408b4b48386c6bf062dAdam Powell } 112d21aa12e8eb9d46ee92bf408b4b48386c6bf062dAdam Powell 113dae7824c4b78d02159c6ad0896f246942d7b3d8cAdam Powell explicit BufferMeta(OMX_U32 portIndex) 114dae7824c4b78d02159c6ad0896f246942d7b3d8cAdam Powell : mCopyFromOmx(false), 115dae7824c4b78d02159c6ad0896f246942d7b3d8cAdam Powell mCopyToOmx(false), 116dae7824c4b78d02159c6ad0896f246942d7b3d8cAdam Powell mPortIndex(portIndex), 117dae7824c4b78d02159c6ad0896f246942d7b3d8cAdam Powell mBackup(NULL) { 118d21aa12e8eb9d46ee92bf408b4b48386c6bf062dAdam Powell } 119dae7824c4b78d02159c6ad0896f246942d7b3d8cAdam Powell 120dae7824c4b78d02159c6ad0896f246942d7b3d8cAdam Powell explicit BufferMeta(const sp<GraphicBuffer> &graphicBuffer, OMX_U32 portIndex) 121dae7824c4b78d02159c6ad0896f246942d7b3d8cAdam Powell : mGraphicBuffer(graphicBuffer), 122dae7824c4b78d02159c6ad0896f246942d7b3d8cAdam Powell mCopyFromOmx(false), 123dae7824c4b78d02159c6ad0896f246942d7b3d8cAdam Powell mCopyToOmx(false), 124dae7824c4b78d02159c6ad0896f246942d7b3d8cAdam Powell mPortIndex(portIndex), 125dae7824c4b78d02159c6ad0896f246942d7b3d8cAdam Powell mBackup(NULL) { 126dae7824c4b78d02159c6ad0896f246942d7b3d8cAdam Powell } 127dae7824c4b78d02159c6ad0896f246942d7b3d8cAdam Powell 128dae7824c4b78d02159c6ad0896f246942d7b3d8cAdam Powell OMX_U8 *getPointer() { 129dae7824c4b78d02159c6ad0896f246942d7b3d8cAdam Powell return mMem.get() ? static_cast<OMX_U8*>(mMem->pointer()) : 130dae7824c4b78d02159c6ad0896f246942d7b3d8cAdam Powell mHidlMemory.get() ? static_cast<OMX_U8*>( 131dae7824c4b78d02159c6ad0896f246942d7b3d8cAdam Powell static_cast<void*>(mHidlMemory->getPointer())) : nullptr; 13245f1e08c348ccb129bcc25e438c05421f7123f41Adam Powell } 133 134 void CopyFromOMX(const OMX_BUFFERHEADERTYPE *header) { 135 if (!mCopyFromOmx) { 136 return; 137 } 138 139 // check component returns proper range 140 sp<ABuffer> codec = getBuffer(header, true /* limit */); 141 142 memcpy(getPointer() + header->nOffset, codec->data(), codec->size()); 143 } 144 145 void CopyToOMX(const OMX_BUFFERHEADERTYPE *header) { 146 if (!mCopyToOmx) { 147 return; 148 } 149 150 memcpy(header->pBuffer + header->nOffset, 151 getPointer() + header->nOffset, 152 header->nFilledLen); 153 } 154 155 // return the codec buffer 156 sp<ABuffer> getBuffer(const OMX_BUFFERHEADERTYPE *header, bool limit) { 157 sp<ABuffer> buf = new ABuffer(header->pBuffer, header->nAllocLen); 158 if (limit) { 159 if (header->nOffset + header->nFilledLen > header->nOffset 160 && header->nOffset + header->nFilledLen <= header->nAllocLen) { 161 buf->setRange(header->nOffset, header->nFilledLen); 162 } else { 163 buf->setRange(0, 0); 164 } 165 } 166 return buf; 167 } 168 169 void setGraphicBuffer(const sp<GraphicBuffer> &graphicBuffer) { 170 mGraphicBuffer = graphicBuffer; 171 } 172 173 void setNativeHandle(const sp<NativeHandle> &nativeHandle) { 174 mNativeHandle = nativeHandle; 175 } 176 177 OMX_U32 getPortIndex() { 178 return mPortIndex; 179 } 180 181 ~BufferMeta() { 182 delete[] mBackup; 183 } 184 185private: 186 sp<GraphicBuffer> mGraphicBuffer; 187 sp<NativeHandle> mNativeHandle; 188 sp<IMemory> mMem; 189 sp<IHidlMemory> mHidlMemory; 190 bool mCopyFromOmx; 191 bool mCopyToOmx; 192 OMX_U32 mPortIndex; 193 OMX_U8 *mBackup; 194 195 BufferMeta(const BufferMeta &); 196 BufferMeta &operator=(const BufferMeta &); 197}; 198 199// static 200OMX_CALLBACKTYPE OMXNodeInstance::kCallbacks = { 201 &OnEvent, &OnEmptyBufferDone, &OnFillBufferDone 202}; 203 204static inline const char *portString(OMX_U32 portIndex) { 205 switch (portIndex) { 206 case kPortIndexInput: return "Input"; 207 case kPortIndexOutput: return "Output"; 208 case ~0U: return "All"; 209 default: return "port"; 210 } 211} 212 213//////////////////////////////////////////////////////////////////////////////// 214 215// This provides the underlying Thread used by CallbackDispatcher. 216// Note that deriving CallbackDispatcher from Thread does not work. 217 218struct OMXNodeInstance::CallbackDispatcherThread : public Thread { 219 explicit CallbackDispatcherThread(CallbackDispatcher *dispatcher) 220 : mDispatcher(dispatcher) { 221 } 222 223private: 224 CallbackDispatcher *mDispatcher; 225 226 bool threadLoop(); 227 228 CallbackDispatcherThread(const CallbackDispatcherThread &); 229 CallbackDispatcherThread &operator=(const CallbackDispatcherThread &); 230}; 231 232//////////////////////////////////////////////////////////////////////////////// 233 234struct OMXNodeInstance::CallbackDispatcher : public RefBase { 235 explicit CallbackDispatcher(const sp<OMXNodeInstance> &owner); 236 237 // Posts |msg| to the listener's queue. If |realTime| is true, the listener thread is notified 238 // that a new message is available on the queue. Otherwise, the message stays on the queue, but 239 // the listener is not notified of it. It will process this message when a subsequent message 240 // is posted with |realTime| set to true. 241 void post(const omx_message &msg, bool realTime = true); 242 243 bool loop(); 244 245protected: 246 virtual ~CallbackDispatcher(); 247 248private: 249 enum { 250 // This is used for frame_rendered message batching, which will eventually end up in a 251 // single AMessage in MediaCodec when it is signaled to the app. AMessage can contain 252 // up-to 64 key-value pairs, and each frame_rendered message uses 2 keys, so the max 253 // value for this would be 32. Nonetheless, limit this to 12 to which gives at least 10 254 // mseconds of batching at 120Hz. 255 kMaxQueueSize = 12, 256 }; 257 258 Mutex mLock; 259 260 sp<OMXNodeInstance> const mOwner; 261 bool mDone; 262 Condition mQueueChanged; 263 std::list<omx_message> mQueue; 264 265 sp<CallbackDispatcherThread> mThread; 266 267 void dispatch(std::list<omx_message> &messages); 268 269 CallbackDispatcher(const CallbackDispatcher &); 270 CallbackDispatcher &operator=(const CallbackDispatcher &); 271}; 272 273OMXNodeInstance::CallbackDispatcher::CallbackDispatcher(const sp<OMXNodeInstance> &owner) 274 : mOwner(owner), 275 mDone(false) { 276 mThread = new CallbackDispatcherThread(this); 277 mThread->run("OMXCallbackDisp", ANDROID_PRIORITY_FOREGROUND); 278} 279 280OMXNodeInstance::CallbackDispatcher::~CallbackDispatcher() { 281 { 282 Mutex::Autolock autoLock(mLock); 283 284 mDone = true; 285 mQueueChanged.signal(); 286 } 287 288 // A join on self can happen if the last ref to CallbackDispatcher 289 // is released within the CallbackDispatcherThread loop 290 status_t status = mThread->join(); 291 if (status != WOULD_BLOCK) { 292 // Other than join to self, the only other error return codes are 293 // whatever readyToRun() returns, and we don't override that 294 CHECK_EQ(status, (status_t)NO_ERROR); 295 } 296} 297 298void OMXNodeInstance::CallbackDispatcher::post(const omx_message &msg, bool realTime) { 299 Mutex::Autolock autoLock(mLock); 300 301 mQueue.push_back(msg); 302 if (realTime || mQueue.size() >= kMaxQueueSize) { 303 mQueueChanged.signal(); 304 } 305} 306 307void OMXNodeInstance::CallbackDispatcher::dispatch(std::list<omx_message> &messages) { 308 if (mOwner == NULL) { 309 ALOGV("Would have dispatched a message to a node that's already gone."); 310 return; 311 } 312 mOwner->onMessages(messages); 313} 314 315bool OMXNodeInstance::CallbackDispatcher::loop() { 316 for (;;) { 317 std::list<omx_message> messages; 318 319 { 320 Mutex::Autolock autoLock(mLock); 321 while (!mDone && mQueue.empty()) { 322 mQueueChanged.wait(mLock); 323 } 324 325 if (mDone) { 326 break; 327 } 328 329 messages.swap(mQueue); 330 } 331 332 dispatch(messages); 333 } 334 335 return false; 336} 337 338//////////////////////////////////////////////////////////////////////////////// 339 340bool OMXNodeInstance::CallbackDispatcherThread::threadLoop() { 341 return mDispatcher->loop(); 342} 343 344//////////////////////////////////////////////////////////////////////////////// 345 346OMXNodeInstance::OMXNodeInstance( 347 OmxNodeOwner *owner, const sp<IOMXObserver> &observer, const char *name) 348 : mOwner(owner), 349 mHandle(NULL), 350 mObserver(observer), 351 mDying(false), 352 mSailed(false), 353 mQueriedProhibitedExtensions(false), 354 mQuirks(0), 355 mBufferIDCount(0), 356 mRestorePtsFailed(false), 357 mMaxTimestampGapUs(-1ll), 358 mPrevOriginalTimeUs(-1ll), 359 mPrevModifiedTimeUs(-1ll) 360{ 361 mName = ADebug::GetDebugName(name); 362 DEBUG = ADebug::GetDebugLevelFromProperty(name, "debug.stagefright.omx-debug"); 363 ALOGV("debug level for %s is %d", name, DEBUG); 364 DEBUG_BUMP = DEBUG; 365 mNumPortBuffers[0] = 0; 366 mNumPortBuffers[1] = 0; 367 mDebugLevelBumpPendingBuffers[0] = 0; 368 mDebugLevelBumpPendingBuffers[1] = 0; 369 mMetadataType[0] = kMetadataBufferTypeInvalid; 370 mMetadataType[1] = kMetadataBufferTypeInvalid; 371 mPortMode[0] = IOMX::kPortModePresetByteBuffer; 372 mPortMode[1] = IOMX::kPortModePresetByteBuffer; 373 mSecureBufferType[0] = kSecureBufferTypeUnknown; 374 mSecureBufferType[1] = kSecureBufferTypeUnknown; 375 mIsSecure = AString(name).endsWith(".secure"); 376 mLegacyAdaptiveExperiment = ADebug::isExperimentEnabled("legacy-adaptive"); 377} 378 379OMXNodeInstance::~OMXNodeInstance() { 380 free(mName); 381 CHECK(mHandle == NULL); 382} 383 384void OMXNodeInstance::setHandle(OMX_HANDLETYPE handle) { 385 CLOG_LIFE(allocateNode, "handle=%p", handle); 386 CHECK(mHandle == NULL); 387 mHandle = handle; 388 if (handle != NULL) { 389 mDispatcher = new CallbackDispatcher(this); 390 } 391} 392 393sp<IOMXBufferSource> OMXNodeInstance::getBufferSource() { 394 Mutex::Autolock autoLock(mOMXBufferSourceLock); 395 return mOMXBufferSource; 396} 397 398void OMXNodeInstance::setBufferSource(const sp<IOMXBufferSource>& bufferSource) { 399 Mutex::Autolock autoLock(mOMXBufferSourceLock); 400 CLOG_INTERNAL(setBufferSource, "%p", bufferSource.get()); 401 mOMXBufferSource = bufferSource; 402} 403 404OMX_HANDLETYPE OMXNodeInstance::handle() { 405 return mHandle; 406} 407 408sp<IOMXObserver> OMXNodeInstance::observer() { 409 return mObserver; 410} 411 412status_t OMXNodeInstance::freeNode() { 413 CLOG_LIFE(freeNode, "handle=%p", mHandle); 414 static int32_t kMaxNumIterations = 10; 415 416 // Transition the node from its current state all the way down 417 // to "Loaded". 418 // This ensures that all active buffers are properly freed even 419 // for components that don't do this themselves on a call to 420 // "FreeHandle". 421 422 // The code below may trigger some more events to be dispatched 423 // by the OMX component - we want to ignore them as our client 424 // does not expect them. 425 bool expected = false; 426 if (!mDying.compare_exchange_strong(expected, true)) { 427 // exit if we have already freed the node or doing so right now. 428 // NOTE: this ensures that the block below executes at most once. 429 ALOGV("Already dying"); 430 return OK; 431 } 432 433 OMX_STATETYPE state; 434 CHECK_EQ(OMX_GetState(mHandle, &state), OMX_ErrorNone); 435 switch (state) { 436 case OMX_StateExecuting: 437 { 438 ALOGV("forcing Executing->Idle"); 439 sendCommand(OMX_CommandStateSet, OMX_StateIdle); 440 OMX_ERRORTYPE err; 441 int32_t iteration = 0; 442 while ((err = OMX_GetState(mHandle, &state)) == OMX_ErrorNone 443 && state != OMX_StateIdle 444 && state != OMX_StateInvalid) { 445 if (++iteration > kMaxNumIterations) { 446 CLOGW("failed to enter Idle state (now %s(%d), aborting.", 447 asString(state), state); 448 state = OMX_StateInvalid; 449 break; 450 } 451 452 usleep(100000); 453 } 454 CHECK_EQ(err, OMX_ErrorNone); 455 456 if (state == OMX_StateInvalid) { 457 break; 458 } 459 460 // fall through 461 } 462 463 case OMX_StateIdle: 464 { 465 ALOGV("forcing Idle->Loaded"); 466 sendCommand(OMX_CommandStateSet, OMX_StateLoaded); 467 468 freeActiveBuffers(); 469 470 OMX_ERRORTYPE err; 471 int32_t iteration = 0; 472 while ((err = OMX_GetState(mHandle, &state)) == OMX_ErrorNone 473 && state != OMX_StateLoaded 474 && state != OMX_StateInvalid) { 475 if (++iteration > kMaxNumIterations) { 476 CLOGW("failed to enter Loaded state (now %s(%d), aborting.", 477 asString(state), state); 478 state = OMX_StateInvalid; 479 break; 480 } 481 482 ALOGV("waiting for Loaded state..."); 483 usleep(100000); 484 } 485 CHECK_EQ(err, OMX_ErrorNone); 486 487 // fall through 488 } 489 490 case OMX_StateLoaded: 491 case OMX_StateInvalid: 492 break; 493 494 default: 495 LOG_ALWAYS_FATAL("unknown state %s(%#x).", asString(state), state); 496 break; 497 } 498 status_t err = mOwner->freeNode(this); 499 500 mDispatcher.clear(); 501 mOMXBufferSource.clear(); 502 503 mHandle = NULL; 504 CLOG_IF_ERROR(freeNode, err, ""); 505 free(mName); 506 mName = NULL; 507 508 ALOGV("OMXNodeInstance going away."); 509 510 return err; 511} 512 513status_t OMXNodeInstance::sendCommand( 514 OMX_COMMANDTYPE cmd, OMX_S32 param) { 515 const sp<IOMXBufferSource> bufferSource(getBufferSource()); 516 if (bufferSource != NULL && cmd == OMX_CommandStateSet) { 517 if (param == OMX_StateIdle) { 518 // Initiating transition from Executing -> Idle 519 // ACodec is waiting for all buffers to be returned, do NOT 520 // submit any more buffers to the codec. 521 bufferSource->onOmxIdle(); 522 } else if (param == OMX_StateLoaded) { 523 // Initiating transition from Idle/Executing -> Loaded 524 // Buffers are about to be freed. 525 bufferSource->onOmxLoaded(); 526 setBufferSource(NULL); 527 } 528 529 // fall through 530 } 531 532 Mutex::Autolock autoLock(mLock); 533 534 if (cmd == OMX_CommandStateSet) { 535 // There are no configurations past first StateSet command. 536 mSailed = true; 537 } 538 539 // bump internal-state debug level for 2 input and output frames past a command 540 { 541 Mutex::Autolock _l(mDebugLock); 542 bumpDebugLevel_l(2 /* numInputBuffers */, 2 /* numOutputBuffers */); 543 } 544 545 const char *paramString = 546 cmd == OMX_CommandStateSet ? asString((OMX_STATETYPE)param) : portString(param); 547 CLOG_STATE(sendCommand, "%s(%d), %s(%d)", asString(cmd), cmd, paramString, param); 548 OMX_ERRORTYPE err = OMX_SendCommand(mHandle, cmd, param, NULL); 549 CLOG_IF_ERROR(sendCommand, err, "%s(%d), %s(%d)", asString(cmd), cmd, paramString, param); 550 return StatusFromOMXError(err); 551} 552 553bool OMXNodeInstance::isProhibitedIndex_l(OMX_INDEXTYPE index) { 554 // these extensions can only be used from OMXNodeInstance, not by clients directly. 555 static const char *restricted_extensions[] = { 556 "OMX.google.android.index.storeMetaDataInBuffers", 557 "OMX.google.android.index.storeANWBufferInMetadata", 558 "OMX.google.android.index.prepareForAdaptivePlayback", 559 "OMX.google.android.index.configureVideoTunnelMode", 560 "OMX.google.android.index.useAndroidNativeBuffer2", 561 "OMX.google.android.index.useAndroidNativeBuffer", 562 "OMX.google.android.index.enableAndroidNativeBuffers", 563 "OMX.google.android.index.allocateNativeHandle", 564 "OMX.google.android.index.getAndroidNativeBufferUsage", 565 }; 566 567 if ((index > OMX_IndexComponentStartUnused && index < OMX_IndexComponentEndUnused) 568 || (index > OMX_IndexPortStartUnused && index < OMX_IndexPortEndUnused) 569 || (index > OMX_IndexAudioStartUnused && index < OMX_IndexAudioEndUnused) 570 || (index > OMX_IndexVideoStartUnused && index < OMX_IndexVideoEndUnused) 571 || (index > OMX_IndexCommonStartUnused && index < OMX_IndexCommonEndUnused) 572 || (index > (OMX_INDEXTYPE)OMX_IndexExtAudioStartUnused 573 && index < (OMX_INDEXTYPE)OMX_IndexExtAudioEndUnused) 574 || (index > (OMX_INDEXTYPE)OMX_IndexExtVideoStartUnused 575 && index < (OMX_INDEXTYPE)OMX_IndexExtVideoEndUnused) 576 || (index > (OMX_INDEXTYPE)OMX_IndexExtOtherStartUnused 577 && index < (OMX_INDEXTYPE)OMX_IndexExtOtherEndUnused)) { 578 return false; 579 } 580 581 if (!mQueriedProhibitedExtensions) { 582 for (size_t i = 0; i < NELEM(restricted_extensions); ++i) { 583 OMX_INDEXTYPE ext; 584 if (OMX_GetExtensionIndex(mHandle, (OMX_STRING)restricted_extensions[i], &ext) == OMX_ErrorNone) { 585 mProhibitedExtensions.add(ext); 586 } 587 } 588 mQueriedProhibitedExtensions = true; 589 } 590 591 return mProhibitedExtensions.indexOf(index) >= 0; 592} 593 594status_t OMXNodeInstance::getParameter( 595 OMX_INDEXTYPE index, void *params, size_t /* size */) { 596 Mutex::Autolock autoLock(mLock); 597 598 if (isProhibitedIndex_l(index)) { 599 android_errorWriteLog(0x534e4554, "29422020"); 600 return BAD_INDEX; 601 } 602 603 OMX_ERRORTYPE err = OMX_GetParameter(mHandle, index, params); 604 OMX_INDEXEXTTYPE extIndex = (OMX_INDEXEXTTYPE)index; 605 // some errors are expected for getParameter 606 if (err != OMX_ErrorNoMore) { 607 CLOG_IF_ERROR(getParameter, err, "%s(%#x)", asString(extIndex), index); 608 } 609 return StatusFromOMXError(err); 610} 611 612status_t OMXNodeInstance::setParameter( 613 OMX_INDEXTYPE index, const void *params, size_t size) { 614 Mutex::Autolock autoLock(mLock); 615 OMX_INDEXEXTTYPE extIndex = (OMX_INDEXEXTTYPE)index; 616 CLOG_CONFIG(setParameter, "%s(%#x), %zu@%p)", asString(extIndex), index, size, params); 617 618 if (extIndex == OMX_IndexParamMaxFrameDurationForBitrateControl) { 619 return setMaxPtsGapUs(params, size); 620 } 621 622 if (isProhibitedIndex_l(index)) { 623 android_errorWriteLog(0x534e4554, "29422020"); 624 return BAD_INDEX; 625 } 626 627 OMX_ERRORTYPE err = OMX_SetParameter( 628 mHandle, index, const_cast<void *>(params)); 629 CLOG_IF_ERROR(setParameter, err, "%s(%#x)", asString(extIndex), index); 630 return StatusFromOMXError(err); 631} 632 633status_t OMXNodeInstance::getConfig( 634 OMX_INDEXTYPE index, void *params, size_t /* size */) { 635 Mutex::Autolock autoLock(mLock); 636 637 if (isProhibitedIndex_l(index)) { 638 android_errorWriteLog(0x534e4554, "29422020"); 639 return BAD_INDEX; 640 } 641 642 OMX_ERRORTYPE err = OMX_GetConfig(mHandle, index, params); 643 OMX_INDEXEXTTYPE extIndex = (OMX_INDEXEXTTYPE)index; 644 // some errors are expected for getConfig 645 if (err != OMX_ErrorNoMore) { 646 CLOG_IF_ERROR(getConfig, err, "%s(%#x)", asString(extIndex), index); 647 } 648 return StatusFromOMXError(err); 649} 650 651status_t OMXNodeInstance::setConfig( 652 OMX_INDEXTYPE index, const void *params, size_t size) { 653 Mutex::Autolock autoLock(mLock); 654 OMX_INDEXEXTTYPE extIndex = (OMX_INDEXEXTTYPE)index; 655 CLOG_CONFIG(setConfig, "%s(%#x), %zu@%p)", asString(extIndex), index, size, params); 656 657 if (isProhibitedIndex_l(index)) { 658 android_errorWriteLog(0x534e4554, "29422020"); 659 return BAD_INDEX; 660 } 661 662 OMX_ERRORTYPE err = OMX_SetConfig( 663 mHandle, index, const_cast<void *>(params)); 664 CLOG_IF_ERROR(setConfig, err, "%s(%#x)", asString(extIndex), index); 665 return StatusFromOMXError(err); 666} 667 668status_t OMXNodeInstance::setPortMode(OMX_U32 portIndex, IOMX::PortMode mode) { 669 Mutex::Autolock autoLock(mLock); 670 671 if (portIndex >= NELEM(mPortMode)) { 672 ALOGE("b/31385713, portIndex(%u)", portIndex); 673 android_errorWriteLog(0x534e4554, "31385713"); 674 return BAD_VALUE; 675 } 676 677 CLOG_CONFIG(setPortMode, "%s(%d), port %d", asString(mode), mode, portIndex); 678 679 switch (mode) { 680 case IOMX::kPortModeDynamicANWBuffer: 681 { 682 if (portIndex == kPortIndexOutput) { 683 if (mLegacyAdaptiveExperiment) { 684 CLOG_INTERNAL(setPortMode, "Legacy adaptive experiment: " 685 "not setting port mode to %s(%d) on output", 686 asString(mode), mode); 687 return StatusFromOMXError(OMX_ErrorUnsupportedIndex); 688 } 689 690 status_t err = enableNativeBuffers_l( 691 portIndex, OMX_TRUE /*graphic*/, OMX_TRUE); 692 if (err != OK) { 693 return err; 694 } 695 } 696 (void)enableNativeBuffers_l(portIndex, OMX_FALSE /*graphic*/, OMX_FALSE); 697 return storeMetaDataInBuffers_l(portIndex, OMX_TRUE, NULL); 698 } 699 700 case IOMX::kPortModeDynamicNativeHandle: 701 { 702 if (portIndex != kPortIndexInput) { 703 CLOG_ERROR(setPortMode, BAD_VALUE, 704 "%s(%d) mode is only supported on input port", asString(mode), mode); 705 return BAD_VALUE; 706 } 707 (void)enableNativeBuffers_l(portIndex, OMX_TRUE /*graphic*/, OMX_FALSE); 708 (void)enableNativeBuffers_l(portIndex, OMX_FALSE /*graphic*/, OMX_FALSE); 709 710 MetadataBufferType metaType = kMetadataBufferTypeNativeHandleSource; 711 return storeMetaDataInBuffers_l(portIndex, OMX_TRUE, &metaType); 712 } 713 714 case IOMX::kPortModePresetSecureBuffer: 715 { 716 // Allow on both input and output. 717 (void)storeMetaDataInBuffers_l(portIndex, OMX_FALSE, NULL); 718 (void)enableNativeBuffers_l(portIndex, OMX_TRUE /*graphic*/, OMX_FALSE); 719 return enableNativeBuffers_l(portIndex, OMX_FALSE /*graphic*/, OMX_TRUE); 720 } 721 722 case IOMX::kPortModePresetANWBuffer: 723 { 724 if (portIndex != kPortIndexOutput) { 725 CLOG_ERROR(setPortMode, BAD_VALUE, 726 "%s(%d) mode is only supported on output port", asString(mode), mode); 727 return BAD_VALUE; 728 } 729 730 // Check if we're simulating legacy mode with metadata mode, 731 // if so, enable metadata mode. 732 if (mLegacyAdaptiveExperiment) { 733 if (storeMetaDataInBuffers_l(portIndex, OMX_TRUE, NULL) == OK) { 734 CLOG_INTERNAL(setPortMode, "Legacy adaptive experiment: " 735 "metdata mode enabled successfully"); 736 return OK; 737 } 738 739 CLOG_INTERNAL(setPortMode, "Legacy adaptive experiment: " 740 "unable to enable metadata mode on output"); 741 742 mLegacyAdaptiveExperiment = false; 743 } 744 745 // Disable secure buffer and enable graphic buffer 746 (void)enableNativeBuffers_l(portIndex, OMX_FALSE /*graphic*/, OMX_FALSE); 747 status_t err = enableNativeBuffers_l(portIndex, OMX_TRUE /*graphic*/, OMX_TRUE); 748 if (err != OK) { 749 return err; 750 } 751 752 // Not running experiment, or metadata is not supported. 753 // Disable metadata mode and use legacy mode. 754 (void)storeMetaDataInBuffers_l(portIndex, OMX_FALSE, NULL); 755 return OK; 756 } 757 758 case IOMX::kPortModePresetByteBuffer: 759 { 760 // Disable secure buffer, native buffer and metadata. 761 (void)enableNativeBuffers_l(portIndex, OMX_TRUE /*graphic*/, OMX_FALSE); 762 (void)enableNativeBuffers_l(portIndex, OMX_FALSE /*graphic*/, OMX_FALSE); 763 (void)storeMetaDataInBuffers_l(portIndex, OMX_FALSE, NULL); 764 return OK; 765 } 766 767 default: 768 break; 769 } 770 771 CLOG_ERROR(setPortMode, BAD_VALUE, "invalid port mode %d", mode); 772 return BAD_VALUE; 773} 774 775status_t OMXNodeInstance::enableNativeBuffers_l( 776 OMX_U32 portIndex, OMX_BOOL graphic, OMX_BOOL enable) { 777 if (portIndex >= NELEM(mSecureBufferType)) { 778 ALOGE("b/31385713, portIndex(%u)", portIndex); 779 android_errorWriteLog(0x534e4554, "31385713"); 780 return BAD_VALUE; 781 } 782 783 CLOG_CONFIG(enableNativeBuffers, "%s:%u%s, %d", portString(portIndex), portIndex, 784 graphic ? ", graphic" : "", enable); 785 OMX_STRING name = const_cast<OMX_STRING>( 786 graphic ? "OMX.google.android.index.enableAndroidNativeBuffers" 787 : "OMX.google.android.index.allocateNativeHandle"); 788 789 OMX_INDEXTYPE index; 790 OMX_ERRORTYPE err = OMX_GetExtensionIndex(mHandle, name, &index); 791 792 if (err == OMX_ErrorNone) { 793 EnableAndroidNativeBuffersParams params; 794 InitOMXParams(¶ms); 795 params.nPortIndex = portIndex; 796 params.enable = enable; 797 798 err = OMX_SetParameter(mHandle, index, ¶ms); 799 CLOG_IF_ERROR(setParameter, err, "%s(%#x): %s:%u en=%d", name, index, 800 portString(portIndex), portIndex, enable); 801 if (!graphic) { 802 if (err == OMX_ErrorNone) { 803 mSecureBufferType[portIndex] = 804 enable ? kSecureBufferTypeNativeHandle : kSecureBufferTypeOpaque; 805 } else if (mSecureBufferType[portIndex] == kSecureBufferTypeUnknown) { 806 mSecureBufferType[portIndex] = kSecureBufferTypeOpaque; 807 } 808 } 809 } else { 810 CLOG_ERROR_IF(enable, getExtensionIndex, err, "%s", name); 811 if (!graphic) { 812 // Extension not supported, check for manual override with system property 813 // This is a temporary workaround until partners support the OMX extension 814 if (property_get_bool("media.mediadrmservice.enable", false)) { 815 CLOG_CONFIG(enableNativeBuffers, "system property override: using native-handles"); 816 mSecureBufferType[portIndex] = kSecureBufferTypeNativeHandle; 817 } else if (mSecureBufferType[portIndex] == kSecureBufferTypeUnknown) { 818 mSecureBufferType[portIndex] = kSecureBufferTypeOpaque; 819 } 820 err = OMX_ErrorNone; 821 } 822 } 823 824 return StatusFromOMXError(err); 825} 826 827status_t OMXNodeInstance::getGraphicBufferUsage( 828 OMX_U32 portIndex, OMX_U32* usage) { 829 Mutex::Autolock autoLock(mLock); 830 831 OMX_INDEXTYPE index; 832 OMX_STRING name = const_cast<OMX_STRING>( 833 "OMX.google.android.index.getAndroidNativeBufferUsage"); 834 OMX_ERRORTYPE err = OMX_GetExtensionIndex(mHandle, name, &index); 835 836 if (err != OMX_ErrorNone) { 837 CLOG_ERROR(getExtensionIndex, err, "%s", name); 838 return StatusFromOMXError(err); 839 } 840 841 GetAndroidNativeBufferUsageParams params; 842 InitOMXParams(¶ms); 843 params.nPortIndex = portIndex; 844 845 err = OMX_GetParameter(mHandle, index, ¶ms); 846 if (err != OMX_ErrorNone) { 847 CLOG_ERROR(getParameter, err, "%s(%#x): %s:%u", name, index, 848 portString(portIndex), portIndex); 849 return StatusFromOMXError(err); 850 } 851 852 *usage = params.nUsage; 853 854 return OK; 855} 856 857status_t OMXNodeInstance::storeMetaDataInBuffers_l( 858 OMX_U32 portIndex, OMX_BOOL enable, MetadataBufferType *type) { 859 if (mSailed) { 860 android_errorWriteLog(0x534e4554, "29422020"); 861 return INVALID_OPERATION; 862 } 863 if (portIndex != kPortIndexInput && portIndex != kPortIndexOutput) { 864 android_errorWriteLog(0x534e4554, "26324358"); 865 if (type != NULL) { 866 *type = kMetadataBufferTypeInvalid; 867 } 868 return BAD_VALUE; 869 } 870 871 OMX_INDEXTYPE index; 872 OMX_STRING name = const_cast<OMX_STRING>( 873 "OMX.google.android.index.storeMetaDataInBuffers"); 874 875 OMX_STRING nativeBufferName = const_cast<OMX_STRING>( 876 "OMX.google.android.index.storeANWBufferInMetadata"); 877 MetadataBufferType negotiatedType; 878 MetadataBufferType requestedType = type != NULL ? *type : kMetadataBufferTypeANWBuffer; 879 880 StoreMetaDataInBuffersParams params; 881 InitOMXParams(¶ms); 882 params.nPortIndex = portIndex; 883 params.bStoreMetaData = enable; 884 885 OMX_ERRORTYPE err = 886 requestedType == kMetadataBufferTypeANWBuffer 887 ? OMX_GetExtensionIndex(mHandle, nativeBufferName, &index) 888 : OMX_ErrorUnsupportedIndex; 889 OMX_ERRORTYPE xerr = err; 890 if (err == OMX_ErrorNone) { 891 err = OMX_SetParameter(mHandle, index, ¶ms); 892 if (err == OMX_ErrorNone) { 893 name = nativeBufferName; // set name for debugging 894 negotiatedType = requestedType; 895 } 896 } 897 if (err != OMX_ErrorNone) { 898 err = OMX_GetExtensionIndex(mHandle, name, &index); 899 xerr = err; 900 if (err == OMX_ErrorNone) { 901 negotiatedType = 902 requestedType == kMetadataBufferTypeANWBuffer 903 ? kMetadataBufferTypeGrallocSource : requestedType; 904 err = OMX_SetParameter(mHandle, index, ¶ms); 905 } 906 if (err == OMX_ErrorBadParameter) { 907 err = OMX_ErrorUnsupportedIndex; 908 } 909 } 910 911 // don't log loud error if component does not support metadata mode on the output 912 if (err != OMX_ErrorNone) { 913 if (err == OMX_ErrorUnsupportedIndex && portIndex == kPortIndexOutput) { 914 CLOGW("component does not support metadata mode; using fallback"); 915 } else if (xerr != OMX_ErrorNone) { 916 CLOG_ERROR(getExtensionIndex, xerr, "%s", name); 917 } else { 918 CLOG_ERROR(setParameter, err, "%s(%#x): %s:%u en=%d type=%d", name, index, 919 portString(portIndex), portIndex, enable, negotiatedType); 920 } 921 negotiatedType = mMetadataType[portIndex]; 922 } else { 923 if (!enable) { 924 negotiatedType = kMetadataBufferTypeInvalid; 925 } 926 mMetadataType[portIndex] = negotiatedType; 927 } 928 CLOG_CONFIG(storeMetaDataInBuffers, "%s:%u %srequested %s:%d negotiated %s:%d", 929 portString(portIndex), portIndex, enable ? "" : "UN", 930 asString(requestedType), requestedType, asString(negotiatedType), negotiatedType); 931 932 if (type != NULL) { 933 *type = negotiatedType; 934 } 935 936 return StatusFromOMXError(err); 937} 938 939status_t OMXNodeInstance::prepareForAdaptivePlayback( 940 OMX_U32 portIndex, OMX_BOOL enable, OMX_U32 maxFrameWidth, 941 OMX_U32 maxFrameHeight) { 942 Mutex::Autolock autolock(mLock); 943 if (mSailed) { 944 android_errorWriteLog(0x534e4554, "29422020"); 945 return INVALID_OPERATION; 946 } 947 CLOG_CONFIG(prepareForAdaptivePlayback, "%s:%u en=%d max=%ux%u", 948 portString(portIndex), portIndex, enable, maxFrameWidth, maxFrameHeight); 949 950 if (mLegacyAdaptiveExperiment) { 951 CLOG_INTERNAL(prepareForAdaptivePlayback, 952 "Legacy adaptive experiment: reporting success"); 953 return OK; 954 } 955 956 OMX_INDEXTYPE index; 957 OMX_STRING name = const_cast<OMX_STRING>( 958 "OMX.google.android.index.prepareForAdaptivePlayback"); 959 960 OMX_ERRORTYPE err = OMX_GetExtensionIndex(mHandle, name, &index); 961 if (err != OMX_ErrorNone) { 962 CLOG_ERROR_IF(enable, getExtensionIndex, err, "%s", name); 963 return StatusFromOMXError(err); 964 } 965 966 PrepareForAdaptivePlaybackParams params; 967 InitOMXParams(¶ms); 968 params.nPortIndex = portIndex; 969 params.bEnable = enable; 970 params.nMaxFrameWidth = maxFrameWidth; 971 params.nMaxFrameHeight = maxFrameHeight; 972 973 err = OMX_SetParameter(mHandle, index, ¶ms); 974 CLOG_IF_ERROR(setParameter, err, "%s(%#x): %s:%u en=%d max=%ux%u", name, index, 975 portString(portIndex), portIndex, enable, maxFrameWidth, maxFrameHeight); 976 return StatusFromOMXError(err); 977} 978 979status_t OMXNodeInstance::configureVideoTunnelMode( 980 OMX_U32 portIndex, OMX_BOOL tunneled, OMX_U32 audioHwSync, 981 native_handle_t **sidebandHandle) { 982 Mutex::Autolock autolock(mLock); 983 if (mSailed) { 984 android_errorWriteLog(0x534e4554, "29422020"); 985 return INVALID_OPERATION; 986 } 987 CLOG_CONFIG(configureVideoTunnelMode, "%s:%u tun=%d sync=%u", 988 portString(portIndex), portIndex, tunneled, audioHwSync); 989 990 OMX_INDEXTYPE index; 991 OMX_STRING name = const_cast<OMX_STRING>( 992 "OMX.google.android.index.configureVideoTunnelMode"); 993 994 OMX_ERRORTYPE err = OMX_GetExtensionIndex(mHandle, name, &index); 995 if (err != OMX_ErrorNone) { 996 CLOG_ERROR_IF(tunneled, getExtensionIndex, err, "%s", name); 997 return StatusFromOMXError(err); 998 } 999 1000 ConfigureVideoTunnelModeParams tunnelParams; 1001 InitOMXParams(&tunnelParams); 1002 tunnelParams.nPortIndex = portIndex; 1003 tunnelParams.bTunneled = tunneled; 1004 tunnelParams.nAudioHwSync = audioHwSync; 1005 err = OMX_SetParameter(mHandle, index, &tunnelParams); 1006 if (err != OMX_ErrorNone) { 1007 CLOG_ERROR(setParameter, err, "%s(%#x): %s:%u tun=%d sync=%u", name, index, 1008 portString(portIndex), portIndex, tunneled, audioHwSync); 1009 return StatusFromOMXError(err); 1010 } 1011 1012 err = OMX_GetParameter(mHandle, index, &tunnelParams); 1013 if (err != OMX_ErrorNone) { 1014 CLOG_ERROR(getParameter, err, "%s(%#x): %s:%u tun=%d sync=%u", name, index, 1015 portString(portIndex), portIndex, tunneled, audioHwSync); 1016 return StatusFromOMXError(err); 1017 } 1018 if (sidebandHandle) { 1019 *sidebandHandle = (native_handle_t*)tunnelParams.pSidebandWindow; 1020 } 1021 1022 return OK; 1023} 1024 1025status_t OMXNodeInstance::useBuffer( 1026 OMX_U32 portIndex, const OMXBuffer &omxBuffer, IOMX::buffer_id *buffer) { 1027 if (buffer == NULL) { 1028 ALOGE("b/25884056"); 1029 return BAD_VALUE; 1030 } 1031 1032 if (portIndex >= NELEM(mNumPortBuffers)) { 1033 return BAD_VALUE; 1034 } 1035 1036 Mutex::Autolock autoLock(mLock); 1037 if (!mSailed) { 1038 ALOGE("b/35467458"); 1039 android_errorWriteLog(0x534e4554, "35467458"); 1040 return BAD_VALUE; 1041 } 1042 1043 switch (omxBuffer.mBufferType) { 1044 case OMXBuffer::kBufferTypePreset: 1045 return useBuffer_l(portIndex, NULL, NULL, buffer); 1046 1047 case OMXBuffer::kBufferTypeSharedMem: 1048 return useBuffer_l(portIndex, omxBuffer.mMem, NULL, buffer); 1049 1050 case OMXBuffer::kBufferTypeANWBuffer: 1051 return useGraphicBuffer_l(portIndex, omxBuffer.mGraphicBuffer, buffer); 1052 1053 case OMXBuffer::kBufferTypeHidlMemory: { 1054 sp<IHidlMemory> hidlMemory = mapMemory(omxBuffer.mHidlMemory); 1055 if (hidlMemory == nullptr) { 1056 ALOGE("OMXNodeInstance useBuffer() failed to map memory"); 1057 return NO_MEMORY; 1058 } 1059 return useBuffer_l(portIndex, NULL, hidlMemory, buffer); 1060 } 1061 default: 1062 break; 1063 } 1064 1065 return BAD_VALUE; 1066} 1067 1068status_t OMXNodeInstance::useBuffer_l( 1069 OMX_U32 portIndex, const sp<IMemory> ¶ms, 1070 const sp<IHidlMemory> &hParams, IOMX::buffer_id *buffer) { 1071 BufferMeta *buffer_meta; 1072 OMX_BUFFERHEADERTYPE *header; 1073 OMX_ERRORTYPE err = OMX_ErrorNone; 1074 bool isMetadata = mMetadataType[portIndex] != kMetadataBufferTypeInvalid; 1075 1076 size_t paramsSize; 1077 void* paramsPointer; 1078 if (params != NULL && hParams != NULL) { 1079 return BAD_VALUE; 1080 } 1081 if (params != NULL) { 1082 paramsPointer = params->pointer(); 1083 paramsSize = params->size(); 1084 } else if (hParams != NULL) { 1085 paramsPointer = hParams->getPointer(); 1086 paramsSize = hParams->getSize(); 1087 } else { 1088 paramsPointer = nullptr; 1089 } 1090 1091 OMX_U32 allottedSize; 1092 if (isMetadata) { 1093 if (mMetadataType[portIndex] == kMetadataBufferTypeGrallocSource) { 1094 allottedSize = sizeof(VideoGrallocMetadata); 1095 } else if (mMetadataType[portIndex] == kMetadataBufferTypeANWBuffer) { 1096 allottedSize = sizeof(VideoNativeMetadata); 1097 } else if (mMetadataType[portIndex] == kMetadataBufferTypeNativeHandleSource) { 1098 allottedSize = sizeof(VideoNativeHandleMetadata); 1099 } else { 1100 return BAD_VALUE; 1101 } 1102 } else { 1103 // NULL params is allowed only in metadata mode. 1104 if (paramsPointer == nullptr) { 1105 ALOGE("b/25884056"); 1106 return BAD_VALUE; 1107 } 1108 allottedSize = paramsSize; 1109 } 1110 1111 bool isOutputGraphicMetadata = (portIndex == kPortIndexOutput) && 1112 (mMetadataType[portIndex] == kMetadataBufferTypeGrallocSource || 1113 mMetadataType[portIndex] == kMetadataBufferTypeANWBuffer); 1114 1115 uint32_t requiresAllocateBufferBit = 1116 (portIndex == kPortIndexInput) 1117 ? kRequiresAllocateBufferOnInputPorts 1118 : kRequiresAllocateBufferOnOutputPorts; 1119 1120 // we use useBuffer for output metadata regardless of quirks 1121 if (!isOutputGraphicMetadata && (mQuirks & requiresAllocateBufferBit)) { 1122 // metadata buffers are not connected cross process; only copy if not meta. 1123 buffer_meta = new BufferMeta( 1124 params, hParams, portIndex, !isMetadata /* copy */, NULL /* data */); 1125 1126 err = OMX_AllocateBuffer( 1127 mHandle, &header, portIndex, buffer_meta, allottedSize); 1128 1129 if (err != OMX_ErrorNone) { 1130 CLOG_ERROR(allocateBuffer, err, 1131 SIMPLE_BUFFER(portIndex, (size_t)allottedSize, 1132 paramsPointer)); 1133 } 1134 } else { 1135 OMX_U8 *data = NULL; 1136 1137 // metadata buffers are not connected cross process 1138 // use a backup buffer instead of the actual buffer 1139 if (isMetadata) { 1140 data = new (std::nothrow) OMX_U8[allottedSize]; 1141 if (data == NULL) { 1142 return NO_MEMORY; 1143 } 1144 memset(data, 0, allottedSize); 1145 1146 buffer_meta = new BufferMeta( 1147 params, hParams, portIndex, false /* copy */, data); 1148 } else { 1149 data = static_cast<OMX_U8 *>(paramsPointer); 1150 1151 buffer_meta = new BufferMeta( 1152 params, hParams, portIndex, false /* copy */, NULL); 1153 } 1154 1155 err = OMX_UseBuffer( 1156 mHandle, &header, portIndex, buffer_meta, 1157 allottedSize, data); 1158 1159 if (err != OMX_ErrorNone) { 1160 CLOG_ERROR(useBuffer, err, SIMPLE_BUFFER( 1161 portIndex, (size_t)allottedSize, data)); 1162 } 1163 } 1164 1165 if (err != OMX_ErrorNone) { 1166 delete buffer_meta; 1167 buffer_meta = NULL; 1168 1169 *buffer = 0; 1170 1171 return StatusFromOMXError(err); 1172 } 1173 1174 CHECK_EQ(header->pAppPrivate, buffer_meta); 1175 1176 *buffer = makeBufferID(header); 1177 1178 addActiveBuffer(portIndex, *buffer); 1179 1180 sp<IOMXBufferSource> bufferSource(getBufferSource()); 1181 if (bufferSource != NULL && portIndex == kPortIndexInput) { 1182 bufferSource->onInputBufferAdded(*buffer); 1183 } 1184 1185 CLOG_BUFFER(useBuffer, NEW_BUFFER_FMT( 1186 *buffer, portIndex, "%u(%zu)@%p", allottedSize, paramsSize, paramsPointer)); 1187 return OK; 1188} 1189 1190status_t OMXNodeInstance::useGraphicBuffer2_l( 1191 OMX_U32 portIndex, const sp<GraphicBuffer>& graphicBuffer, 1192 IOMX::buffer_id *buffer) { 1193 if (graphicBuffer == NULL || buffer == NULL) { 1194 ALOGE("b/25884056"); 1195 return BAD_VALUE; 1196 } 1197 1198 // port definition 1199 OMX_PARAM_PORTDEFINITIONTYPE def; 1200 InitOMXParams(&def); 1201 def.nPortIndex = portIndex; 1202 OMX_ERRORTYPE err = OMX_GetParameter(mHandle, OMX_IndexParamPortDefinition, &def); 1203 if (err != OMX_ErrorNone) { 1204 OMX_INDEXTYPE index = OMX_IndexParamPortDefinition; 1205 CLOG_ERROR(getParameter, err, "%s(%#x): %s:%u", 1206 asString(index), index, portString(portIndex), portIndex); 1207 return UNKNOWN_ERROR; 1208 } 1209 1210 BufferMeta *bufferMeta = new BufferMeta(graphicBuffer, portIndex); 1211 1212 OMX_BUFFERHEADERTYPE *header = NULL; 1213 OMX_U8* bufferHandle = const_cast<OMX_U8*>( 1214 reinterpret_cast<const OMX_U8*>(graphicBuffer->handle)); 1215 1216 err = OMX_UseBuffer( 1217 mHandle, 1218 &header, 1219 portIndex, 1220 bufferMeta, 1221 def.nBufferSize, 1222 bufferHandle); 1223 1224 if (err != OMX_ErrorNone) { 1225 CLOG_ERROR(useBuffer, err, BUFFER_FMT(portIndex, "%u@%p", def.nBufferSize, bufferHandle)); 1226 delete bufferMeta; 1227 bufferMeta = NULL; 1228 *buffer = 0; 1229 return StatusFromOMXError(err); 1230 } 1231 1232 CHECK_EQ(header->pBuffer, bufferHandle); 1233 CHECK_EQ(header->pAppPrivate, bufferMeta); 1234 1235 *buffer = makeBufferID(header); 1236 1237 addActiveBuffer(portIndex, *buffer); 1238 CLOG_BUFFER(useGraphicBuffer2, NEW_BUFFER_FMT( 1239 *buffer, portIndex, "%u@%p", def.nBufferSize, bufferHandle)); 1240 return OK; 1241} 1242 1243// XXX: This function is here for backwards compatibility. Once the OMX 1244// implementations have been updated this can be removed and useGraphicBuffer2 1245// can be renamed to useGraphicBuffer. 1246status_t OMXNodeInstance::useGraphicBuffer_l( 1247 OMX_U32 portIndex, const sp<GraphicBuffer>& graphicBuffer, 1248 IOMX::buffer_id *buffer) { 1249 if (graphicBuffer == NULL || buffer == NULL) { 1250 ALOGE("b/25884056"); 1251 return BAD_VALUE; 1252 } 1253 1254 // First, see if we're in metadata mode. We could be running an experiment to simulate 1255 // legacy behavior (preallocated buffers) on devices that supports meta. 1256 if (mMetadataType[portIndex] != kMetadataBufferTypeInvalid) { 1257 return useGraphicBufferWithMetadata_l( 1258 portIndex, graphicBuffer, buffer); 1259 } 1260 1261 // See if the newer version of the extension is present. 1262 OMX_INDEXTYPE index; 1263 if (OMX_GetExtensionIndex( 1264 mHandle, 1265 const_cast<OMX_STRING>("OMX.google.android.index.useAndroidNativeBuffer2"), 1266 &index) == OMX_ErrorNone) { 1267 return useGraphicBuffer2_l(portIndex, graphicBuffer, buffer); 1268 } 1269 1270 OMX_STRING name = const_cast<OMX_STRING>( 1271 "OMX.google.android.index.useAndroidNativeBuffer"); 1272 OMX_ERRORTYPE err = OMX_GetExtensionIndex(mHandle, name, &index); 1273 if (err != OMX_ErrorNone) { 1274 CLOG_ERROR(getExtensionIndex, err, "%s", name); 1275 return StatusFromOMXError(err); 1276 } 1277 1278 BufferMeta *bufferMeta = new BufferMeta(graphicBuffer, portIndex); 1279 1280 OMX_BUFFERHEADERTYPE *header; 1281 1282 OMX_VERSIONTYPE ver; 1283 ver.s.nVersionMajor = 1; 1284 ver.s.nVersionMinor = 0; 1285 ver.s.nRevision = 0; 1286 ver.s.nStep = 0; 1287 UseAndroidNativeBufferParams params = { 1288 sizeof(UseAndroidNativeBufferParams), ver, portIndex, bufferMeta, 1289 &header, graphicBuffer, 1290 }; 1291 1292 err = OMX_SetParameter(mHandle, index, ¶ms); 1293 1294 if (err != OMX_ErrorNone) { 1295 CLOG_ERROR(setParameter, err, "%s(%#x): %s:%u meta=%p GB=%p", name, index, 1296 portString(portIndex), portIndex, bufferMeta, graphicBuffer->handle); 1297 1298 delete bufferMeta; 1299 bufferMeta = NULL; 1300 1301 *buffer = 0; 1302 1303 return StatusFromOMXError(err); 1304 } 1305 1306 CHECK_EQ(header->pAppPrivate, bufferMeta); 1307 1308 *buffer = makeBufferID(header); 1309 1310 addActiveBuffer(portIndex, *buffer); 1311 CLOG_BUFFER(useGraphicBuffer, NEW_BUFFER_FMT( 1312 *buffer, portIndex, "GB=%p", graphicBuffer->handle)); 1313 return OK; 1314} 1315 1316status_t OMXNodeInstance::useGraphicBufferWithMetadata_l( 1317 OMX_U32 portIndex, const sp<GraphicBuffer> &graphicBuffer, 1318 IOMX::buffer_id *buffer) { 1319 if (portIndex != kPortIndexOutput) { 1320 return BAD_VALUE; 1321 } 1322 1323 if (mMetadataType[portIndex] != kMetadataBufferTypeGrallocSource && 1324 mMetadataType[portIndex] != kMetadataBufferTypeANWBuffer) { 1325 return BAD_VALUE; 1326 } 1327 1328 status_t err = useBuffer_l(portIndex, NULL, NULL, buffer); 1329 if (err != OK) { 1330 return err; 1331 } 1332 1333 OMX_BUFFERHEADERTYPE *header = findBufferHeader(*buffer, portIndex); 1334 1335 return updateGraphicBufferInMeta_l(portIndex, graphicBuffer, *buffer, header); 1336 1337} 1338 1339status_t OMXNodeInstance::updateGraphicBufferInMeta_l( 1340 OMX_U32 portIndex, const sp<GraphicBuffer>& graphicBuffer, 1341 IOMX::buffer_id buffer, OMX_BUFFERHEADERTYPE *header) { 1342 // No need to check |graphicBuffer| since NULL is valid for it as below. 1343 if (header == NULL) { 1344 ALOGE("b/25884056"); 1345 return BAD_VALUE; 1346 } 1347 1348 if (portIndex != kPortIndexInput && portIndex != kPortIndexOutput) { 1349 return BAD_VALUE; 1350 } 1351 1352 BufferMeta *bufferMeta = (BufferMeta *)(header->pAppPrivate); 1353 sp<ABuffer> data = bufferMeta->getBuffer(header, false /* limit */); 1354 bufferMeta->setGraphicBuffer(graphicBuffer); 1355 MetadataBufferType metaType = mMetadataType[portIndex]; 1356 if (metaType == kMetadataBufferTypeGrallocSource 1357 && data->capacity() >= sizeof(VideoGrallocMetadata)) { 1358 VideoGrallocMetadata &metadata = *(VideoGrallocMetadata *)(data->data()); 1359 metadata.eType = kMetadataBufferTypeGrallocSource; 1360 metadata.pHandle = graphicBuffer == NULL ? NULL : graphicBuffer->handle; 1361 } else if (metaType == kMetadataBufferTypeANWBuffer 1362 && data->capacity() >= sizeof(VideoNativeMetadata)) { 1363 VideoNativeMetadata &metadata = *(VideoNativeMetadata *)(data->data()); 1364 metadata.eType = kMetadataBufferTypeANWBuffer; 1365 metadata.pBuffer = graphicBuffer == NULL ? NULL : graphicBuffer->getNativeBuffer(); 1366 metadata.nFenceFd = -1; 1367 } else { 1368 CLOG_ERROR(updateGraphicBufferInMeta, BAD_VALUE, "%s:%u, %#x bad type (%d) or size (%u)", 1369 portString(portIndex), portIndex, buffer, mMetadataType[portIndex], header->nAllocLen); 1370 return BAD_VALUE; 1371 } 1372 1373 CLOG_BUFFER(updateGraphicBufferInMeta, "%s:%u, %#x := %p", 1374 portString(portIndex), portIndex, buffer, 1375 graphicBuffer == NULL ? NULL : graphicBuffer->handle); 1376 return OK; 1377} 1378 1379status_t OMXNodeInstance::updateNativeHandleInMeta_l( 1380 OMX_U32 portIndex, const sp<NativeHandle>& nativeHandle, 1381 IOMX::buffer_id buffer, OMX_BUFFERHEADERTYPE *header) { 1382 // No need to check |nativeHandle| since NULL is valid for it as below. 1383 if (header == NULL) { 1384 ALOGE("b/25884056"); 1385 return BAD_VALUE; 1386 } 1387 1388 if (portIndex != kPortIndexInput && portIndex != kPortIndexOutput) { 1389 return BAD_VALUE; 1390 } 1391 1392 BufferMeta *bufferMeta = (BufferMeta *)(header->pAppPrivate); 1393 sp<ABuffer> data = bufferMeta->getBuffer(header, false /* limit */); 1394 bufferMeta->setNativeHandle(nativeHandle); 1395 if (mMetadataType[portIndex] == kMetadataBufferTypeNativeHandleSource 1396 && data->capacity() >= sizeof(VideoNativeHandleMetadata)) { 1397 VideoNativeHandleMetadata &metadata = *(VideoNativeHandleMetadata *)(data->data()); 1398 metadata.eType = mMetadataType[portIndex]; 1399 metadata.pHandle = 1400 nativeHandle == NULL ? NULL : const_cast<native_handle*>(nativeHandle->handle()); 1401 } else { 1402 CLOG_ERROR(updateNativeHandleInMeta, BAD_VALUE, "%s:%u, %#x bad type (%d) or size (%zu)", 1403 portString(portIndex), portIndex, buffer, mMetadataType[portIndex], data->capacity()); 1404 return BAD_VALUE; 1405 } 1406 1407 CLOG_BUFFER(updateNativeHandleInMeta, "%s:%u, %#x := %p", 1408 portString(portIndex), portIndex, buffer, 1409 nativeHandle == NULL ? NULL : nativeHandle->handle()); 1410 return OK; 1411} 1412 1413status_t OMXNodeInstance::setInputSurface( 1414 const sp<IOMXBufferSource> &bufferSource) { 1415 Mutex::Autolock autolock(mLock); 1416 1417 status_t err; 1418 1419 // only allow graphic source on input port, when there are no allocated buffers yet 1420 if (mNumPortBuffers[kPortIndexInput] > 0) { 1421 android_errorWriteLog(0x534e4554, "29422020"); 1422 return INVALID_OPERATION; 1423 } 1424 1425 if (getBufferSource() != NULL) { 1426 return ALREADY_EXISTS; 1427 } 1428 1429 err = storeMetaDataInBuffers_l(kPortIndexInput, OMX_TRUE, NULL); 1430 if (err != OK) { 1431 return err; 1432 } 1433 1434 // Retrieve the width and height of the graphic buffer, set when the 1435 // codec was configured. 1436 OMX_PARAM_PORTDEFINITIONTYPE def; 1437 InitOMXParams(&def); 1438 def.nPortIndex = kPortIndexInput; 1439 OMX_ERRORTYPE oerr = OMX_GetParameter( 1440 mHandle, OMX_IndexParamPortDefinition, &def); 1441 if (oerr != OMX_ErrorNone) { 1442 OMX_INDEXTYPE index = OMX_IndexParamPortDefinition; 1443 CLOG_ERROR(getParameter, oerr, "%s(%#x): %s:%u", asString(index), 1444 index, portString(kPortIndexInput), kPortIndexInput); 1445 return UNKNOWN_ERROR; 1446 } 1447 1448 if (def.format.video.eColorFormat != OMX_COLOR_FormatAndroidOpaque) { 1449 CLOGW("createInputSurface requires COLOR_FormatSurface " 1450 "(AndroidOpaque) color format instead of %s(%#x)", 1451 asString(def.format.video.eColorFormat), def.format.video.eColorFormat); 1452 return INVALID_OPERATION; 1453 } 1454 1455 if (def.format.video.nFrameWidth == 0 1456 || def.format.video.nFrameHeight == 0) { 1457 ALOGE("Invalid video dimension %ux%u", 1458 def.format.video.nFrameWidth, 1459 def.format.video.nFrameHeight); 1460 return BAD_VALUE; 1461 } 1462 1463 setBufferSource(bufferSource); 1464 return OK; 1465} 1466 1467status_t OMXNodeInstance::allocateSecureBuffer( 1468 OMX_U32 portIndex, size_t size, IOMX::buffer_id *buffer, 1469 void **buffer_data, sp<NativeHandle> *native_handle) { 1470 if (buffer == NULL || buffer_data == NULL || native_handle == NULL) { 1471 ALOGE("b/25884056"); 1472 return BAD_VALUE; 1473 } 1474 1475 if (portIndex >= NELEM(mSecureBufferType)) { 1476 ALOGE("b/31385713, portIndex(%u)", portIndex); 1477 android_errorWriteLog(0x534e4554, "31385713"); 1478 return BAD_VALUE; 1479 } 1480 1481 Mutex::Autolock autoLock(mLock); 1482 1483 if (!mSailed) { 1484 ALOGE("b/35467458"); 1485 android_errorWriteLog(0x534e4554, "35467458"); 1486 return BAD_VALUE; 1487 } 1488 BufferMeta *buffer_meta = new BufferMeta(portIndex); 1489 1490 OMX_BUFFERHEADERTYPE *header; 1491 1492 OMX_ERRORTYPE err = OMX_AllocateBuffer( 1493 mHandle, &header, portIndex, buffer_meta, size); 1494 1495 if (err != OMX_ErrorNone) { 1496 CLOG_ERROR(allocateBuffer, err, BUFFER_FMT(portIndex, "%zu@", size)); 1497 delete buffer_meta; 1498 buffer_meta = NULL; 1499 1500 *buffer = 0; 1501 1502 return StatusFromOMXError(err); 1503 } 1504 1505 CHECK_EQ(header->pAppPrivate, buffer_meta); 1506 1507 *buffer = makeBufferID(header); 1508 if (mSecureBufferType[portIndex] == kSecureBufferTypeNativeHandle) { 1509 *buffer_data = NULL; 1510 *native_handle = NativeHandle::create( 1511 (native_handle_t *)header->pBuffer, false /* ownsHandle */); 1512 } else { 1513 *buffer_data = header->pBuffer; 1514 *native_handle = NULL; 1515 } 1516 1517 addActiveBuffer(portIndex, *buffer); 1518 1519 sp<IOMXBufferSource> bufferSource(getBufferSource()); 1520 if (bufferSource != NULL && portIndex == kPortIndexInput) { 1521 bufferSource->onInputBufferAdded(*buffer); 1522 } 1523 CLOG_BUFFER(allocateSecureBuffer, NEW_BUFFER_FMT( 1524 *buffer, portIndex, "%zu@%p:%p", size, *buffer_data, 1525 *native_handle == NULL ? NULL : (*native_handle)->handle())); 1526 1527 return OK; 1528} 1529 1530status_t OMXNodeInstance::freeBuffer( 1531 OMX_U32 portIndex, IOMX::buffer_id buffer) { 1532 Mutex::Autolock autoLock(mLock); 1533 CLOG_BUFFER(freeBuffer, "%s:%u %#x", portString(portIndex), portIndex, buffer); 1534 1535 removeActiveBuffer(portIndex, buffer); 1536 1537 OMX_BUFFERHEADERTYPE *header = findBufferHeader(buffer, portIndex); 1538 if (header == NULL) { 1539 ALOGE("b/25884056"); 1540 return BAD_VALUE; 1541 } 1542 BufferMeta *buffer_meta = static_cast<BufferMeta *>(header->pAppPrivate); 1543 1544 OMX_ERRORTYPE err = OMX_FreeBuffer(mHandle, portIndex, header); 1545 CLOG_IF_ERROR(freeBuffer, err, "%s:%u %#x", portString(portIndex), portIndex, buffer); 1546 1547 delete buffer_meta; 1548 buffer_meta = NULL; 1549 invalidateBufferID(buffer); 1550 1551 return StatusFromOMXError(err); 1552} 1553 1554status_t OMXNodeInstance::fillBuffer( 1555 IOMX::buffer_id buffer, const OMXBuffer &omxBuffer, int fenceFd) { 1556 Mutex::Autolock autoLock(mLock); 1557 1558 OMX_BUFFERHEADERTYPE *header = findBufferHeader(buffer, kPortIndexOutput); 1559 if (header == NULL) { 1560 ALOGE("b/25884056"); 1561 return BAD_VALUE; 1562 } 1563 1564 if (omxBuffer.mBufferType == OMXBuffer::kBufferTypeANWBuffer) { 1565 status_t err = updateGraphicBufferInMeta_l( 1566 kPortIndexOutput, omxBuffer.mGraphicBuffer, buffer, header); 1567 1568 if (err != OK) { 1569 CLOG_ERROR(fillBuffer, err, FULL_BUFFER( 1570 (intptr_t)header->pBuffer, header, fenceFd)); 1571 return err; 1572 } 1573 } else if (omxBuffer.mBufferType != OMXBuffer::kBufferTypePreset) { 1574 return BAD_VALUE; 1575 } 1576 1577 header->nFilledLen = 0; 1578 header->nOffset = 0; 1579 header->nFlags = 0; 1580 1581 // meta now owns fenceFd 1582 status_t res = storeFenceInMeta_l(header, fenceFd, kPortIndexOutput); 1583 if (res != OK) { 1584 CLOG_ERROR(fillBuffer::storeFenceInMeta, res, EMPTY_BUFFER(buffer, header, fenceFd)); 1585 return res; 1586 } 1587 1588 { 1589 Mutex::Autolock _l(mDebugLock); 1590 mOutputBuffersWithCodec.add(header); 1591 CLOG_BUMPED_BUFFER(fillBuffer, WITH_STATS(EMPTY_BUFFER(buffer, header, fenceFd))); 1592 } 1593 1594 OMX_ERRORTYPE err = OMX_FillThisBuffer(mHandle, header); 1595 if (err != OMX_ErrorNone) { 1596 CLOG_ERROR(fillBuffer, err, EMPTY_BUFFER(buffer, header, fenceFd)); 1597 Mutex::Autolock _l(mDebugLock); 1598 mOutputBuffersWithCodec.remove(header); 1599 } 1600 return StatusFromOMXError(err); 1601} 1602 1603status_t OMXNodeInstance::emptyBuffer( 1604 buffer_id buffer, const OMXBuffer &omxBuffer, 1605 OMX_U32 flags, OMX_TICKS timestamp, int fenceFd) { 1606 Mutex::Autolock autoLock(mLock); 1607 1608 switch (omxBuffer.mBufferType) { 1609 case OMXBuffer::kBufferTypePreset: 1610 return emptyBuffer_l( 1611 buffer, omxBuffer.mRangeOffset, omxBuffer.mRangeLength, 1612 flags, timestamp, fenceFd); 1613 1614 case OMXBuffer::kBufferTypeANWBuffer: 1615 return emptyGraphicBuffer_l( 1616 buffer, omxBuffer.mGraphicBuffer, flags, timestamp, fenceFd); 1617 1618 case OMXBuffer::kBufferTypeNativeHandle: 1619 return emptyNativeHandleBuffer_l( 1620 buffer, omxBuffer.mNativeHandle, flags, timestamp, fenceFd); 1621 1622 default: 1623 break; 1624 } 1625 1626 return BAD_VALUE; 1627} 1628 1629status_t OMXNodeInstance::emptyBuffer_l( 1630 IOMX::buffer_id buffer, 1631 OMX_U32 rangeOffset, OMX_U32 rangeLength, 1632 OMX_U32 flags, OMX_TICKS timestamp, int fenceFd) { 1633 1634 // no emptybuffer if using input surface 1635 if (getBufferSource() != NULL) { 1636 android_errorWriteLog(0x534e4554, "29422020"); 1637 return INVALID_OPERATION; 1638 } 1639 1640 OMX_BUFFERHEADERTYPE *header = findBufferHeader(buffer, kPortIndexInput); 1641 if (header == NULL) { 1642 ALOGE("b/25884056"); 1643 return BAD_VALUE; 1644 } 1645 BufferMeta *buffer_meta = 1646 static_cast<BufferMeta *>(header->pAppPrivate); 1647 1648 // set up proper filled length if component is configured for gralloc metadata mode 1649 // ignore rangeOffset in this case (as client may be assuming ANW meta buffers). 1650 if (mMetadataType[kPortIndexInput] == kMetadataBufferTypeGrallocSource) { 1651 header->nFilledLen = rangeLength ? sizeof(VideoGrallocMetadata) : 0; 1652 header->nOffset = 0; 1653 } else { 1654 // rangeLength and rangeOffset must be a subset of the allocated data in the buffer. 1655 // corner case: we permit rangeOffset == end-of-buffer with rangeLength == 0. 1656 if (rangeOffset > header->nAllocLen 1657 || rangeLength > header->nAllocLen - rangeOffset) { 1658 CLOG_ERROR(emptyBuffer, OMX_ErrorBadParameter, FULL_BUFFER(NULL, header, fenceFd)); 1659 if (fenceFd >= 0) { 1660 ::close(fenceFd); 1661 } 1662 return BAD_VALUE; 1663 } 1664 header->nFilledLen = rangeLength; 1665 header->nOffset = rangeOffset; 1666 1667 buffer_meta->CopyToOMX(header); 1668 } 1669 1670 return emptyBuffer_l(header, flags, timestamp, (intptr_t)buffer, fenceFd); 1671} 1672 1673// log queued buffer activity for the next few input and/or output frames 1674// if logging at internal state level 1675void OMXNodeInstance::bumpDebugLevel_l(size_t numInputBuffers, size_t numOutputBuffers) { 1676 if (DEBUG == ADebug::kDebugInternalState) { 1677 DEBUG_BUMP = ADebug::kDebugAll; 1678 if (numInputBuffers > 0) { 1679 mDebugLevelBumpPendingBuffers[kPortIndexInput] = numInputBuffers; 1680 } 1681 if (numOutputBuffers > 0) { 1682 mDebugLevelBumpPendingBuffers[kPortIndexOutput] = numOutputBuffers; 1683 } 1684 } 1685} 1686 1687void OMXNodeInstance::unbumpDebugLevel_l(size_t portIndex) { 1688 if (mDebugLevelBumpPendingBuffers[portIndex]) { 1689 --mDebugLevelBumpPendingBuffers[portIndex]; 1690 } 1691 if (!mDebugLevelBumpPendingBuffers[0] 1692 && !mDebugLevelBumpPendingBuffers[1]) { 1693 DEBUG_BUMP = DEBUG; 1694 } 1695} 1696 1697status_t OMXNodeInstance::storeFenceInMeta_l( 1698 OMX_BUFFERHEADERTYPE *header, int fenceFd, OMX_U32 portIndex) { 1699 // propagate fence if component supports it; wait for it otherwise 1700 OMX_U32 metaSize = portIndex == kPortIndexInput ? header->nFilledLen : header->nAllocLen; 1701 if (mMetadataType[portIndex] == kMetadataBufferTypeANWBuffer 1702 && metaSize >= sizeof(VideoNativeMetadata)) { 1703 VideoNativeMetadata &nativeMeta = *(VideoNativeMetadata *)(header->pBuffer); 1704 if (nativeMeta.nFenceFd >= 0) { 1705 ALOGE("fence (%d) already exists in meta", nativeMeta.nFenceFd); 1706 if (fenceFd >= 0) { 1707 ::close(fenceFd); 1708 } 1709 return ALREADY_EXISTS; 1710 } 1711 nativeMeta.nFenceFd = fenceFd; 1712 } else if (fenceFd >= 0) { 1713 CLOG_BUFFER(storeFenceInMeta, "waiting for fence %d", fenceFd); 1714 sp<Fence> fence = new Fence(fenceFd); 1715 return fence->wait(IOMX::kFenceTimeoutMs); 1716 } 1717 return OK; 1718} 1719 1720int OMXNodeInstance::retrieveFenceFromMeta_l( 1721 OMX_BUFFERHEADERTYPE *header, OMX_U32 portIndex) { 1722 OMX_U32 metaSize = portIndex == kPortIndexInput ? header->nAllocLen : header->nFilledLen; 1723 int fenceFd = -1; 1724 if (mMetadataType[portIndex] == kMetadataBufferTypeANWBuffer 1725 && header->nAllocLen >= sizeof(VideoNativeMetadata)) { 1726 VideoNativeMetadata &nativeMeta = *(VideoNativeMetadata *)(header->pBuffer); 1727 if (nativeMeta.eType == kMetadataBufferTypeANWBuffer) { 1728 fenceFd = nativeMeta.nFenceFd; 1729 nativeMeta.nFenceFd = -1; 1730 } 1731 if (metaSize < sizeof(nativeMeta) && fenceFd >= 0) { 1732 CLOG_ERROR(foundFenceInEmptyMeta, BAD_VALUE, FULL_BUFFER( 1733 NULL, header, nativeMeta.nFenceFd)); 1734 fenceFd = -1; 1735 } 1736 } 1737 return fenceFd; 1738} 1739 1740status_t OMXNodeInstance::emptyBuffer_l( 1741 OMX_BUFFERHEADERTYPE *header, OMX_U32 flags, OMX_TICKS timestamp, 1742 intptr_t debugAddr, int fenceFd) { 1743 header->nFlags = flags; 1744 header->nTimeStamp = timestamp; 1745 1746 status_t res = storeFenceInMeta_l(header, fenceFd, kPortIndexInput); 1747 if (res != OK) { 1748 CLOG_ERROR(emptyBuffer::storeFenceInMeta, res, WITH_STATS( 1749 FULL_BUFFER(debugAddr, header, fenceFd))); 1750 return res; 1751 } 1752 1753 { 1754 Mutex::Autolock _l(mDebugLock); 1755 mInputBuffersWithCodec.add(header); 1756 1757 // bump internal-state debug level for 2 input frames past a buffer with CSD 1758 if ((flags & OMX_BUFFERFLAG_CODECCONFIG) != 0) { 1759 bumpDebugLevel_l(2 /* numInputBuffers */, 0 /* numOutputBuffers */); 1760 } 1761 1762 CLOG_BUMPED_BUFFER(emptyBuffer, WITH_STATS(FULL_BUFFER(debugAddr, header, fenceFd))); 1763 } 1764 1765 OMX_ERRORTYPE err = OMX_EmptyThisBuffer(mHandle, header); 1766 CLOG_IF_ERROR(emptyBuffer, err, FULL_BUFFER(debugAddr, header, fenceFd)); 1767 1768 { 1769 Mutex::Autolock _l(mDebugLock); 1770 if (err != OMX_ErrorNone) { 1771 mInputBuffersWithCodec.remove(header); 1772 } else if (!(flags & OMX_BUFFERFLAG_CODECCONFIG)) { 1773 unbumpDebugLevel_l(kPortIndexInput); 1774 } 1775 } 1776 1777 return StatusFromOMXError(err); 1778} 1779 1780// like emptyBuffer, but the data is already in header->pBuffer 1781status_t OMXNodeInstance::emptyGraphicBuffer_l( 1782 IOMX::buffer_id buffer, const sp<GraphicBuffer> &graphicBuffer, 1783 OMX_U32 flags, OMX_TICKS timestamp, int fenceFd) { 1784 OMX_BUFFERHEADERTYPE *header = findBufferHeader(buffer, kPortIndexInput); 1785 if (header == NULL) { 1786 ALOGE("b/25884056"); 1787 return BAD_VALUE; 1788 } 1789 1790 status_t err = updateGraphicBufferInMeta_l( 1791 kPortIndexInput, graphicBuffer, buffer, header); 1792 if (err != OK) { 1793 CLOG_ERROR(emptyGraphicBuffer, err, FULL_BUFFER( 1794 (intptr_t)header->pBuffer, header, fenceFd)); 1795 return err; 1796 } 1797 1798 int64_t codecTimeUs = getCodecTimestamp(timestamp); 1799 1800 header->nOffset = 0; 1801 if (graphicBuffer == NULL) { 1802 header->nFilledLen = 0; 1803 } else if (mMetadataType[kPortIndexInput] == kMetadataBufferTypeGrallocSource) { 1804 header->nFilledLen = sizeof(VideoGrallocMetadata); 1805 } else { 1806 header->nFilledLen = sizeof(VideoNativeMetadata); 1807 } 1808 return emptyBuffer_l(header, flags, codecTimeUs, (intptr_t)header->pBuffer, fenceFd); 1809} 1810 1811status_t OMXNodeInstance::setMaxPtsGapUs(const void *params, size_t size) { 1812 if (params == NULL || size != sizeof(OMX_PARAM_U32TYPE)) { 1813 CLOG_ERROR(setMaxPtsGapUs, BAD_VALUE, "invalid params (%p,%zu)", params, size); 1814 return BAD_VALUE; 1815 } 1816 1817 mMaxTimestampGapUs = (int64_t)((OMX_PARAM_U32TYPE*)params)->nU32; 1818 1819 return OK; 1820} 1821 1822int64_t OMXNodeInstance::getCodecTimestamp(OMX_TICKS timestamp) { 1823 int64_t originalTimeUs = timestamp; 1824 1825 if (mMaxTimestampGapUs > 0ll) { 1826 /* Cap timestamp gap between adjacent frames to specified max 1827 * 1828 * In the scenario of cast mirroring, encoding could be suspended for 1829 * prolonged periods. Limiting the pts gap to workaround the problem 1830 * where encoder's rate control logic produces huge frames after a 1831 * long period of suspension. 1832 */ 1833 if (mPrevOriginalTimeUs >= 0ll) { 1834 int64_t timestampGapUs = originalTimeUs - mPrevOriginalTimeUs; 1835 timestamp = (timestampGapUs < mMaxTimestampGapUs ? 1836 timestampGapUs : mMaxTimestampGapUs) + mPrevModifiedTimeUs; 1837 } 1838 ALOGV("IN timestamp: %lld -> %lld", 1839 static_cast<long long>(originalTimeUs), 1840 static_cast<long long>(timestamp)); 1841 } 1842 1843 mPrevOriginalTimeUs = originalTimeUs; 1844 mPrevModifiedTimeUs = timestamp; 1845 1846 if (mMaxTimestampGapUs > 0ll && !mRestorePtsFailed) { 1847 mOriginalTimeUs.add(timestamp, originalTimeUs); 1848 } 1849 1850 return timestamp; 1851} 1852 1853status_t OMXNodeInstance::emptyNativeHandleBuffer_l( 1854 IOMX::buffer_id buffer, const sp<NativeHandle> &nativeHandle, 1855 OMX_U32 flags, OMX_TICKS timestamp, int fenceFd) { 1856 OMX_BUFFERHEADERTYPE *header = findBufferHeader(buffer, kPortIndexInput); 1857 if (header == NULL) { 1858 ALOGE("b/25884056"); 1859 return BAD_VALUE; 1860 } 1861 1862 status_t err = updateNativeHandleInMeta_l( 1863 kPortIndexInput, nativeHandle, buffer, header); 1864 if (err != OK) { 1865 CLOG_ERROR(emptyNativeHandleBuffer_l, err, FULL_BUFFER( 1866 (intptr_t)header->pBuffer, header, fenceFd)); 1867 return err; 1868 } 1869 1870 header->nOffset = 0; 1871 header->nFilledLen = (nativeHandle == NULL) ? 0 : sizeof(VideoNativeMetadata); 1872 1873 return emptyBuffer_l(header, flags, timestamp, (intptr_t)header->pBuffer, fenceFd); 1874} 1875 1876void OMXNodeInstance::codecBufferFilled(omx_message &msg) { 1877 Mutex::Autolock autoLock(mLock); 1878 1879 if (mMaxTimestampGapUs <= 0ll || mRestorePtsFailed) { 1880 return; 1881 } 1882 1883 OMX_U32 &flags = msg.u.extended_buffer_data.flags; 1884 OMX_TICKS ×tamp = msg.u.extended_buffer_data.timestamp; 1885 1886 if (!(flags & OMX_BUFFERFLAG_CODECCONFIG)) { 1887 ssize_t index = mOriginalTimeUs.indexOfKey(timestamp); 1888 if (index >= 0) { 1889 ALOGV("OUT timestamp: %lld -> %lld", 1890 static_cast<long long>(timestamp), 1891 static_cast<long long>(mOriginalTimeUs[index])); 1892 timestamp = mOriginalTimeUs[index]; 1893 mOriginalTimeUs.removeItemsAt(index); 1894 } else { 1895 // giving up the effort as encoder doesn't appear to preserve pts 1896 ALOGW("giving up limiting timestamp gap (pts = %lld)", timestamp); 1897 mRestorePtsFailed = true; 1898 } 1899 } 1900} 1901 1902status_t OMXNodeInstance::getExtensionIndex( 1903 const char *parameterName, OMX_INDEXTYPE *index) { 1904 Mutex::Autolock autoLock(mLock); 1905 1906 OMX_ERRORTYPE err = OMX_GetExtensionIndex( 1907 mHandle, const_cast<char *>(parameterName), index); 1908 1909 return StatusFromOMXError(err); 1910} 1911 1912status_t OMXNodeInstance::dispatchMessage(const omx_message &msg) { 1913 mDispatcher->post(msg, true /*realTime*/); 1914 return OK; 1915} 1916 1917status_t OMXNodeInstance::setQuirks(OMX_U32 quirks) { 1918 if (quirks & ~kQuirksMask) { 1919 return BAD_VALUE; 1920 } 1921 1922 mQuirks = quirks; 1923 1924 return OK; 1925} 1926 1927bool OMXNodeInstance::handleMessage(omx_message &msg) { 1928 if (msg.type == omx_message::FILL_BUFFER_DONE) { 1929 OMX_BUFFERHEADERTYPE *buffer = 1930 findBufferHeader(msg.u.extended_buffer_data.buffer, kPortIndexOutput); 1931 if (buffer == NULL) { 1932 ALOGE("b/25884056"); 1933 return false; 1934 } 1935 1936 { 1937 Mutex::Autolock _l(mDebugLock); 1938 mOutputBuffersWithCodec.remove(buffer); 1939 1940 CLOG_BUMPED_BUFFER( 1941 FBD, WITH_STATS(FULL_BUFFER( 1942 msg.u.extended_buffer_data.buffer, buffer, msg.fenceFd))); 1943 1944 unbumpDebugLevel_l(kPortIndexOutput); 1945 } 1946 1947 BufferMeta *buffer_meta = 1948 static_cast<BufferMeta *>(buffer->pAppPrivate); 1949 1950 if (buffer->nOffset + buffer->nFilledLen < buffer->nOffset 1951 || buffer->nOffset + buffer->nFilledLen > buffer->nAllocLen) { 1952 CLOG_ERROR(onFillBufferDone, OMX_ErrorBadParameter, 1953 FULL_BUFFER(NULL, buffer, msg.fenceFd)); 1954 } 1955 buffer_meta->CopyFromOMX(buffer); 1956 1957 // fix up the buffer info (especially timestamp) if needed 1958 codecBufferFilled(msg); 1959 } else if (msg.type == omx_message::EMPTY_BUFFER_DONE) { 1960 OMX_BUFFERHEADERTYPE *buffer = 1961 findBufferHeader(msg.u.buffer_data.buffer, kPortIndexInput); 1962 if (buffer == NULL) { 1963 return false; 1964 } 1965 1966 { 1967 Mutex::Autolock _l(mDebugLock); 1968 mInputBuffersWithCodec.remove(buffer); 1969 1970 CLOG_BUMPED_BUFFER( 1971 EBD, WITH_STATS(EMPTY_BUFFER(msg.u.buffer_data.buffer, buffer, msg.fenceFd))); 1972 } 1973 1974 const sp<IOMXBufferSource> bufferSource(getBufferSource()); 1975 1976 if (bufferSource != NULL) { 1977 // This is one of the buffers used exclusively by IOMXBufferSource. 1978 // Don't dispatch a message back to ACodec, since it doesn't 1979 // know that anyone asked to have the buffer emptied and will 1980 // be very confused. 1981 bufferSource->onInputBufferEmptied( 1982 msg.u.buffer_data.buffer, OMXFenceParcelable(msg.fenceFd)); 1983 return true; 1984 } 1985 } else if (msg.type == omx_message::EVENT && 1986 msg.u.event_data.event == OMX_EventDataSpaceChanged) { 1987 handleDataSpaceChanged(msg); 1988 } 1989 1990 return false; 1991} 1992 1993bool OMXNodeInstance::handleDataSpaceChanged(omx_message &msg) { 1994 android_dataspace dataSpace = (android_dataspace) msg.u.event_data.data1; 1995 android_dataspace origDataSpace = dataSpace; 1996 1997 if (!ColorUtils::convertDataSpaceToV0(dataSpace)) { 1998 // Do not process the data space change, don't notify client either 1999 return true; 2000 } 2001 2002 android_pixel_format pixelFormat = (android_pixel_format)msg.u.event_data.data3; 2003 2004 ColorAspects requestedAspects = ColorUtils::unpackToColorAspects(msg.u.event_data.data2); 2005 ColorAspects aspects = requestedAspects; // initially requested aspects 2006 2007 // request color aspects to encode 2008 OMX_INDEXTYPE index; 2009 status_t err = getExtensionIndex( 2010 "OMX.google.android.index.describeColorAspects", &index); 2011 if (err == OK) { 2012 // V0 dataspace 2013 DescribeColorAspectsParams params; 2014 InitOMXParams(¶ms); 2015 params.nPortIndex = kPortIndexInput; 2016 params.nDataSpace = origDataSpace; 2017 params.nPixelFormat = pixelFormat; 2018 params.bDataSpaceChanged = OMX_TRUE; 2019 params.sAspects = requestedAspects; 2020 2021 err = getConfig(index, ¶ms, sizeof(params)); 2022 if (err == OK) { 2023 aspects = params.sAspects; 2024 ALOGD("Codec resolved it to (R:%d(%s), P:%d(%s), M:%d(%s), T:%d(%s)) err=%d(%s)", 2025 params.sAspects.mRange, asString(params.sAspects.mRange), 2026 params.sAspects.mPrimaries, asString(params.sAspects.mPrimaries), 2027 params.sAspects.mMatrixCoeffs, asString(params.sAspects.mMatrixCoeffs), 2028 params.sAspects.mTransfer, asString(params.sAspects.mTransfer), 2029 err, asString(err)); 2030 } else { 2031 params.sAspects = aspects; 2032 err = OK; 2033 } 2034 params.bDataSpaceChanged = OMX_FALSE; 2035 for (int triesLeft = 2; --triesLeft >= 0; ) { 2036 status_t err = setConfig(index, ¶ms, sizeof(params)); 2037 if (err == OK) { 2038 err = getConfig(index, ¶ms, sizeof(params)); 2039 } 2040 if (err != OK || !ColorUtils::checkIfAspectsChangedAndUnspecifyThem( 2041 params.sAspects, aspects)) { 2042 // if we can't set or get color aspects, still communicate dataspace to client 2043 break; 2044 } 2045 2046 ALOGW_IF(triesLeft == 0, "Codec repeatedly changed requested ColorAspects."); 2047 } 2048 } 2049 2050 ALOGV("Set color aspects to (R:%d(%s), P:%d(%s), M:%d(%s), T:%d(%s)) err=%d(%s)", 2051 aspects.mRange, asString(aspects.mRange), 2052 aspects.mPrimaries, asString(aspects.mPrimaries), 2053 aspects.mMatrixCoeffs, asString(aspects.mMatrixCoeffs), 2054 aspects.mTransfer, asString(aspects.mTransfer), 2055 err, asString(err)); 2056 2057 // signal client that the dataspace has changed; this will update the output format 2058 // TODO: we should tie this to an output buffer somehow, and signal the change 2059 // just before the output buffer is returned to the client, but there are many 2060 // ways this could fail (e.g. flushing), and we are not yet supporting this scenario. 2061 2062 msg.u.event_data.data1 = (OMX_U32) dataSpace; 2063 msg.u.event_data.data2 = (OMX_U32) ColorUtils::packToU32(aspects); 2064 2065 return false; 2066} 2067 2068void OMXNodeInstance::onMessages(std::list<omx_message> &messages) { 2069 for (std::list<omx_message>::iterator it = messages.begin(); it != messages.end(); ) { 2070 if (handleMessage(*it)) { 2071 messages.erase(it++); 2072 } else { 2073 ++it; 2074 } 2075 } 2076 2077 if (!messages.empty()) { 2078 mObserver->onMessages(messages); 2079 } 2080} 2081 2082void OMXNodeInstance::onObserverDied() { 2083 ALOGE("!!! Observer died. Quickly, do something, ... anything..."); 2084 2085 // Try to force shutdown of the node and hope for the best. 2086 freeNode(); 2087} 2088 2089// OMXNodeInstance::OnEvent calls OMX::OnEvent, which then calls here. 2090// Don't try to acquire mLock here -- in rare circumstances this will hang. 2091void OMXNodeInstance::onEvent( 2092 OMX_EVENTTYPE event, OMX_U32 arg1, OMX_U32 arg2) { 2093 const char *arg1String = "??"; 2094 const char *arg2String = "??"; 2095 ADebug::Level level = ADebug::kDebugInternalState; 2096 2097 switch (event) { 2098 case OMX_EventCmdComplete: 2099 arg1String = asString((OMX_COMMANDTYPE)arg1); 2100 switch (arg1) { 2101 case OMX_CommandStateSet: 2102 arg2String = asString((OMX_STATETYPE)arg2); 2103 level = ADebug::kDebugState; 2104 break; 2105 case OMX_CommandFlush: 2106 case OMX_CommandPortEnable: 2107 { 2108 // bump internal-state debug level for 2 input and output frames 2109 Mutex::Autolock _l(mDebugLock); 2110 bumpDebugLevel_l(2 /* numInputBuffers */, 2 /* numOutputBuffers */); 2111 } 2112 // fall through 2113 default: 2114 arg2String = portString(arg2); 2115 } 2116 break; 2117 case OMX_EventError: 2118 arg1String = asString((OMX_ERRORTYPE)arg1); 2119 level = ADebug::kDebugLifeCycle; 2120 break; 2121 case OMX_EventPortSettingsChanged: 2122 arg2String = asString((OMX_INDEXEXTTYPE)arg2); 2123 // fall through 2124 default: 2125 arg1String = portString(arg1); 2126 } 2127 2128 CLOGI_(level, onEvent, "%s(%x), %s(%x), %s(%x)", 2129 asString(event), event, arg1String, arg1, arg2String, arg2); 2130 const sp<IOMXBufferSource> bufferSource(getBufferSource()); 2131 2132 if (bufferSource != NULL 2133 && event == OMX_EventCmdComplete 2134 && arg1 == OMX_CommandStateSet 2135 && arg2 == OMX_StateExecuting) { 2136 bufferSource->onOmxExecuting(); 2137 } 2138 2139 // allow configuration if we return to the loaded state 2140 if (event == OMX_EventCmdComplete 2141 && arg1 == OMX_CommandStateSet 2142 && arg2 == OMX_StateLoaded) { 2143 mSailed = false; 2144 } 2145} 2146 2147// static 2148OMX_ERRORTYPE OMXNodeInstance::OnEvent( 2149 OMX_IN OMX_HANDLETYPE /* hComponent */, 2150 OMX_IN OMX_PTR pAppData, 2151 OMX_IN OMX_EVENTTYPE eEvent, 2152 OMX_IN OMX_U32 nData1, 2153 OMX_IN OMX_U32 nData2, 2154 OMX_IN OMX_PTR pEventData) { 2155 if (pAppData == NULL) { 2156 ALOGE("b/25884056"); 2157 return OMX_ErrorBadParameter; 2158 } 2159 OMXNodeInstance *instance = static_cast<OMXNodeInstance *>(pAppData); 2160 if (instance->mDying) { 2161 return OMX_ErrorNone; 2162 } 2163 2164 instance->onEvent(eEvent, nData1, nData2); 2165 2166 // output rendered events are not processed as regular events until they hit the observer 2167 if (eEvent == OMX_EventOutputRendered) { 2168 if (pEventData == NULL) { 2169 return OMX_ErrorBadParameter; 2170 } 2171 2172 // process data from array 2173 OMX_VIDEO_RENDEREVENTTYPE *renderData = (OMX_VIDEO_RENDEREVENTTYPE *)pEventData; 2174 for (size_t i = 0; i < nData1; ++i) { 2175 omx_message msg; 2176 msg.type = omx_message::FRAME_RENDERED; 2177 msg.fenceFd = -1; 2178 msg.u.render_data.timestamp = renderData[i].nMediaTimeUs; 2179 msg.u.render_data.nanoTime = renderData[i].nSystemTimeNs; 2180 bool realTime = msg.u.render_data.timestamp == INT64_MAX; 2181 instance->mDispatcher->post(msg, realTime); 2182 } 2183 return OMX_ErrorNone; 2184 } 2185 2186 omx_message msg; 2187 msg.type = omx_message::EVENT; 2188 msg.fenceFd = -1; 2189 msg.u.event_data.event = eEvent; 2190 msg.u.event_data.data1 = nData1; 2191 msg.u.event_data.data2 = nData2; 2192 2193 instance->mDispatcher->post(msg, true /* realTime */); 2194 2195 return OMX_ErrorNone; 2196} 2197 2198// static 2199OMX_ERRORTYPE OMXNodeInstance::OnEmptyBufferDone( 2200 OMX_IN OMX_HANDLETYPE /* hComponent */, 2201 OMX_IN OMX_PTR pAppData, 2202 OMX_IN OMX_BUFFERHEADERTYPE* pBuffer) { 2203 if (pAppData == NULL) { 2204 ALOGE("b/25884056"); 2205 return OMX_ErrorBadParameter; 2206 } 2207 OMXNodeInstance *instance = static_cast<OMXNodeInstance *>(pAppData); 2208 if (instance->mDying) { 2209 return OMX_ErrorNone; 2210 } 2211 int fenceFd = instance->retrieveFenceFromMeta_l(pBuffer, kPortIndexOutput); 2212 2213 omx_message msg; 2214 msg.type = omx_message::EMPTY_BUFFER_DONE; 2215 msg.fenceFd = fenceFd; 2216 msg.u.buffer_data.buffer = instance->findBufferID(pBuffer); 2217 instance->mDispatcher->post(msg); 2218 2219 return OMX_ErrorNone; 2220} 2221 2222// static 2223OMX_ERRORTYPE OMXNodeInstance::OnFillBufferDone( 2224 OMX_IN OMX_HANDLETYPE /* hComponent */, 2225 OMX_IN OMX_PTR pAppData, 2226 OMX_IN OMX_BUFFERHEADERTYPE* pBuffer) { 2227 if (pAppData == NULL) { 2228 ALOGE("b/25884056"); 2229 return OMX_ErrorBadParameter; 2230 } 2231 OMXNodeInstance *instance = static_cast<OMXNodeInstance *>(pAppData); 2232 if (instance->mDying) { 2233 return OMX_ErrorNone; 2234 } 2235 int fenceFd = instance->retrieveFenceFromMeta_l(pBuffer, kPortIndexOutput); 2236 2237 omx_message msg; 2238 msg.type = omx_message::FILL_BUFFER_DONE; 2239 msg.fenceFd = fenceFd; 2240 msg.u.extended_buffer_data.buffer = instance->findBufferID(pBuffer); 2241 msg.u.extended_buffer_data.range_offset = pBuffer->nOffset; 2242 msg.u.extended_buffer_data.range_length = pBuffer->nFilledLen; 2243 msg.u.extended_buffer_data.flags = pBuffer->nFlags; 2244 msg.u.extended_buffer_data.timestamp = pBuffer->nTimeStamp; 2245 instance->mDispatcher->post(msg); 2246 2247 return OMX_ErrorNone; 2248} 2249 2250void OMXNodeInstance::addActiveBuffer(OMX_U32 portIndex, IOMX::buffer_id id) { 2251 ActiveBuffer active; 2252 active.mPortIndex = portIndex; 2253 active.mID = id; 2254 mActiveBuffers.push(active); 2255 2256 if (portIndex < NELEM(mNumPortBuffers)) { 2257 ++mNumPortBuffers[portIndex]; 2258 } 2259} 2260 2261void OMXNodeInstance::removeActiveBuffer( 2262 OMX_U32 portIndex, IOMX::buffer_id id) { 2263 for (size_t i = 0; i < mActiveBuffers.size(); ++i) { 2264 if (mActiveBuffers[i].mPortIndex == portIndex 2265 && mActiveBuffers[i].mID == id) { 2266 mActiveBuffers.removeItemsAt(i); 2267 2268 if (portIndex < NELEM(mNumPortBuffers)) { 2269 --mNumPortBuffers[portIndex]; 2270 } 2271 return; 2272 } 2273 } 2274 2275 CLOGW("Attempt to remove an active buffer [%#x] we know nothing about...", id); 2276} 2277 2278void OMXNodeInstance::freeActiveBuffers() { 2279 // Make sure to count down here, as freeBuffer will in turn remove 2280 // the active buffer from the vector... 2281 for (size_t i = mActiveBuffers.size(); i > 0;) { 2282 i--; 2283 freeBuffer(mActiveBuffers[i].mPortIndex, mActiveBuffers[i].mID); 2284 } 2285} 2286 2287IOMX::buffer_id OMXNodeInstance::makeBufferID(OMX_BUFFERHEADERTYPE *bufferHeader) { 2288 if (bufferHeader == NULL) { 2289 return 0; 2290 } 2291 Mutex::Autolock autoLock(mBufferIDLock); 2292 IOMX::buffer_id buffer; 2293 do { // handle the very unlikely case of ID overflow 2294 if (++mBufferIDCount == 0) { 2295 ++mBufferIDCount; 2296 } 2297 buffer = (IOMX::buffer_id)mBufferIDCount; 2298 } while (mBufferIDToBufferHeader.indexOfKey(buffer) >= 0); 2299 mBufferIDToBufferHeader.add(buffer, bufferHeader); 2300 mBufferHeaderToBufferID.add(bufferHeader, buffer); 2301 return buffer; 2302} 2303 2304OMX_BUFFERHEADERTYPE *OMXNodeInstance::findBufferHeader( 2305 IOMX::buffer_id buffer, OMX_U32 portIndex) { 2306 if (buffer == 0) { 2307 return NULL; 2308 } 2309 Mutex::Autolock autoLock(mBufferIDLock); 2310 ssize_t index = mBufferIDToBufferHeader.indexOfKey(buffer); 2311 if (index < 0) { 2312 CLOGW("findBufferHeader: buffer %u not found", buffer); 2313 return NULL; 2314 } 2315 OMX_BUFFERHEADERTYPE *header = mBufferIDToBufferHeader.valueAt(index); 2316 BufferMeta *buffer_meta = 2317 static_cast<BufferMeta *>(header->pAppPrivate); 2318 if (buffer_meta->getPortIndex() != portIndex) { 2319 CLOGW("findBufferHeader: buffer %u found but with incorrect port index.", buffer); 2320 android_errorWriteLog(0x534e4554, "28816827"); 2321 return NULL; 2322 } 2323 return header; 2324} 2325 2326IOMX::buffer_id OMXNodeInstance::findBufferID(OMX_BUFFERHEADERTYPE *bufferHeader) { 2327 if (bufferHeader == NULL) { 2328 return 0; 2329 } 2330 Mutex::Autolock autoLock(mBufferIDLock); 2331 ssize_t index = mBufferHeaderToBufferID.indexOfKey(bufferHeader); 2332 if (index < 0) { 2333 CLOGW("findBufferID: bufferHeader %p not found", bufferHeader); 2334 return 0; 2335 } 2336 return mBufferHeaderToBufferID.valueAt(index); 2337} 2338 2339void OMXNodeInstance::invalidateBufferID(IOMX::buffer_id buffer) { 2340 if (buffer == 0) { 2341 return; 2342 } 2343 Mutex::Autolock autoLock(mBufferIDLock); 2344 ssize_t index = mBufferIDToBufferHeader.indexOfKey(buffer); 2345 if (index < 0) { 2346 CLOGW("invalidateBufferID: buffer %u not found", buffer); 2347 return; 2348 } 2349 mBufferHeaderToBufferID.removeItem(mBufferIDToBufferHeader.valueAt(index)); 2350 mBufferIDToBufferHeader.removeItemsAt(index); 2351} 2352 2353} // namespace android 2354