1/* 2 * Copyright (C) 2009 The Android Open Source Project 3 * 4 * Licensed under the Apache License, Version 2.0 (the "License"); 5 * you may not use this file except in compliance with the License. 6 * You may obtain a copy of the License at 7 * 8 * http://www.apache.org/licenses/LICENSE-2.0 9 * 10 * Unless required by applicable law or agreed to in writing, software 11 * distributed under the License is distributed on an "AS IS" BASIS, 12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13 * See the License for the specific language governing permissions and 14 * limitations under the License. 15 */ 16 17//#define LOG_NDEBUG 0 18#define LOG_TAG "OMXNodeInstance" 19#include <utils/Log.h> 20 21#include <inttypes.h> 22 23#include "../include/OMXNodeInstance.h" 24#include "OMXMaster.h" 25#include "OMXUtils.h" 26#include "GraphicBufferSource.h" 27 28#include <OMX_Component.h> 29#include <OMX_IndexExt.h> 30#include <OMX_AsString.h> 31 32#include <binder/IMemory.h> 33#include <cutils/properties.h> 34#include <gui/BufferQueue.h> 35#include <HardwareAPI.h> 36#include <media/stagefright/foundation/ADebug.h> 37#include <media/stagefright/foundation/ABuffer.h> 38#include <media/stagefright/MediaErrors.h> 39#include <utils/misc.h> 40#include <utils/NativeHandle.h> 41 42static const OMX_U32 kPortIndexInput = 0; 43static const OMX_U32 kPortIndexOutput = 1; 44 45#define CLOGW(fmt, ...) ALOGW("[%x:%s] " fmt, mNodeID, mName, ##__VA_ARGS__) 46 47#define CLOG_ERROR_IF(cond, fn, err, fmt, ...) \ 48 ALOGE_IF(cond, #fn "(%x:%s, " fmt ") ERROR: %s(%#x)", \ 49 mNodeID, mName, ##__VA_ARGS__, asString(err), err) 50#define CLOG_ERROR(fn, err, fmt, ...) CLOG_ERROR_IF(true, fn, err, fmt, ##__VA_ARGS__) 51#define CLOG_IF_ERROR(fn, err, fmt, ...) \ 52 CLOG_ERROR_IF((err) != OMX_ErrorNone, fn, err, fmt, ##__VA_ARGS__) 53 54#define CLOGI_(level, fn, fmt, ...) \ 55 ALOGI_IF(DEBUG >= (level), #fn "(%x:%s, " fmt ")", mNodeID, mName, ##__VA_ARGS__) 56#define CLOGD_(level, fn, fmt, ...) \ 57 ALOGD_IF(DEBUG >= (level), #fn "(%x:%s, " fmt ")", mNodeID, mName, ##__VA_ARGS__) 58 59#define CLOG_LIFE(fn, fmt, ...) CLOGI_(ADebug::kDebugLifeCycle, fn, fmt, ##__VA_ARGS__) 60#define CLOG_STATE(fn, fmt, ...) CLOGI_(ADebug::kDebugState, fn, fmt, ##__VA_ARGS__) 61#define CLOG_CONFIG(fn, fmt, ...) CLOGI_(ADebug::kDebugConfig, fn, fmt, ##__VA_ARGS__) 62#define CLOG_INTERNAL(fn, fmt, ...) CLOGD_(ADebug::kDebugInternalState, fn, fmt, ##__VA_ARGS__) 63 64#define CLOG_DEBUG_IF(cond, fn, fmt, ...) \ 65 ALOGD_IF(cond, #fn "(%x, " fmt ")", mNodeID, ##__VA_ARGS__) 66 67#define CLOG_BUFFER(fn, fmt, ...) \ 68 CLOG_DEBUG_IF(DEBUG >= ADebug::kDebugAll, fn, fmt, ##__VA_ARGS__) 69#define CLOG_BUMPED_BUFFER(fn, fmt, ...) \ 70 CLOG_DEBUG_IF(DEBUG_BUMP >= ADebug::kDebugAll, fn, fmt, ##__VA_ARGS__) 71 72/* buffer formatting */ 73#define BUFFER_FMT(port, fmt, ...) "%s:%u " fmt, portString(port), (port), ##__VA_ARGS__ 74#define NEW_BUFFER_FMT(buffer_id, port, fmt, ...) \ 75 BUFFER_FMT(port, fmt ") (#%zu => %#x", ##__VA_ARGS__, mActiveBuffers.size(), (buffer_id)) 76 77#define SIMPLE_BUFFER(port, size, data) BUFFER_FMT(port, "%zu@%p", (size), (data)) 78#define SIMPLE_NEW_BUFFER(buffer_id, port, size, data) \ 79 NEW_BUFFER_FMT(buffer_id, port, "%zu@%p", (size), (data)) 80 81#define EMPTY_BUFFER(addr, header, fenceFd) "%#x [%u@%p fc=%d]", \ 82 (addr), (header)->nAllocLen, (header)->pBuffer, (fenceFd) 83#define FULL_BUFFER(addr, header, fenceFd) "%#" PRIxPTR " [%u@%p (%u..+%u) f=%x ts=%lld fc=%d]", \ 84 (intptr_t)(addr), (header)->nAllocLen, (header)->pBuffer, \ 85 (header)->nOffset, (header)->nFilledLen, (header)->nFlags, (header)->nTimeStamp, (fenceFd) 86 87#define WITH_STATS_WRAPPER(fmt, ...) fmt " { IN=%zu/%zu OUT=%zu/%zu }", ##__VA_ARGS__, \ 88 mInputBuffersWithCodec.size(), mNumPortBuffers[kPortIndexInput], \ 89 mOutputBuffersWithCodec.size(), mNumPortBuffers[kPortIndexOutput] 90// TRICKY: this is needed so formatting macros expand before substitution 91#define WITH_STATS(fmt, ...) WITH_STATS_WRAPPER(fmt, ##__VA_ARGS__) 92 93namespace android { 94 95struct BufferMeta { 96 BufferMeta( 97 const sp<IMemory> &mem, OMX_U32 portIndex, bool copyToOmx, 98 bool copyFromOmx, OMX_U8 *backup) 99 : mMem(mem), 100 mCopyFromOmx(copyFromOmx), 101 mCopyToOmx(copyToOmx), 102 mPortIndex(portIndex), 103 mBackup(backup) { 104 } 105 106 BufferMeta(size_t size, OMX_U32 portIndex) 107 : mSize(size), 108 mCopyFromOmx(false), 109 mCopyToOmx(false), 110 mPortIndex(portIndex), 111 mBackup(NULL) { 112 } 113 114 BufferMeta(const sp<GraphicBuffer> &graphicBuffer, OMX_U32 portIndex) 115 : mGraphicBuffer(graphicBuffer), 116 mCopyFromOmx(false), 117 mCopyToOmx(false), 118 mPortIndex(portIndex), 119 mBackup(NULL) { 120 } 121 122 void CopyFromOMX(const OMX_BUFFERHEADERTYPE *header) { 123 if (!mCopyFromOmx) { 124 return; 125 } 126 127 // check component returns proper range 128 sp<ABuffer> codec = getBuffer(header, false /* backup */, true /* limit */); 129 130 memcpy((OMX_U8 *)mMem->pointer() + header->nOffset, codec->data(), codec->size()); 131 } 132 133 void CopyToOMX(const OMX_BUFFERHEADERTYPE *header) { 134 if (!mCopyToOmx) { 135 return; 136 } 137 138 memcpy(header->pBuffer + header->nOffset, 139 (const OMX_U8 *)mMem->pointer() + header->nOffset, 140 header->nFilledLen); 141 } 142 143 // return either the codec or the backup buffer 144 sp<ABuffer> getBuffer(const OMX_BUFFERHEADERTYPE *header, bool backup, bool limit) { 145 sp<ABuffer> buf; 146 if (backup && mMem != NULL) { 147 buf = new ABuffer(mMem->pointer(), mMem->size()); 148 } else { 149 buf = new ABuffer(header->pBuffer, header->nAllocLen); 150 } 151 if (limit) { 152 if (header->nOffset + header->nFilledLen > header->nOffset 153 && header->nOffset + header->nFilledLen <= header->nAllocLen) { 154 buf->setRange(header->nOffset, header->nFilledLen); 155 } else { 156 buf->setRange(0, 0); 157 } 158 } 159 return buf; 160 } 161 162 void setGraphicBuffer(const sp<GraphicBuffer> &graphicBuffer) { 163 mGraphicBuffer = graphicBuffer; 164 } 165 166 void setNativeHandle(const sp<NativeHandle> &nativeHandle) { 167 mNativeHandle = nativeHandle; 168 } 169 170 OMX_U32 getPortIndex() { 171 return mPortIndex; 172 } 173 174 ~BufferMeta() { 175 delete[] mBackup; 176 } 177 178private: 179 sp<GraphicBuffer> mGraphicBuffer; 180 sp<NativeHandle> mNativeHandle; 181 sp<IMemory> mMem; 182 size_t mSize; 183 bool mCopyFromOmx; 184 bool mCopyToOmx; 185 OMX_U32 mPortIndex; 186 OMX_U8 *mBackup; 187 188 BufferMeta(const BufferMeta &); 189 BufferMeta &operator=(const BufferMeta &); 190}; 191 192// static 193OMX_CALLBACKTYPE OMXNodeInstance::kCallbacks = { 194 &OnEvent, &OnEmptyBufferDone, &OnFillBufferDone 195}; 196 197static inline const char *portString(OMX_U32 portIndex) { 198 switch (portIndex) { 199 case kPortIndexInput: return "Input"; 200 case kPortIndexOutput: return "Output"; 201 case ~0U: return "All"; 202 default: return "port"; 203 } 204} 205 206OMXNodeInstance::OMXNodeInstance( 207 OMX *owner, const sp<IOMXObserver> &observer, const char *name) 208 : mOwner(owner), 209 mNodeID(0), 210 mHandle(NULL), 211 mObserver(observer), 212 mDying(false), 213 mSailed(false), 214 mQueriedProhibitedExtensions(false), 215 mBufferIDCount(0) 216{ 217 mName = ADebug::GetDebugName(name); 218 DEBUG = ADebug::GetDebugLevelFromProperty(name, "debug.stagefright.omx-debug"); 219 ALOGV("debug level for %s is %d", name, DEBUG); 220 DEBUG_BUMP = DEBUG; 221 mNumPortBuffers[0] = 0; 222 mNumPortBuffers[1] = 0; 223 mDebugLevelBumpPendingBuffers[0] = 0; 224 mDebugLevelBumpPendingBuffers[1] = 0; 225 mMetadataType[0] = kMetadataBufferTypeInvalid; 226 mMetadataType[1] = kMetadataBufferTypeInvalid; 227 mSecureBufferType[0] = kSecureBufferTypeUnknown; 228 mSecureBufferType[1] = kSecureBufferTypeUnknown; 229 mGraphicBufferEnabled[0] = false; 230 mGraphicBufferEnabled[1] = false; 231 mIsSecure = AString(name).endsWith(".secure"); 232} 233 234OMXNodeInstance::~OMXNodeInstance() { 235 free(mName); 236 CHECK(mHandle == NULL); 237} 238 239void OMXNodeInstance::setHandle(OMX::node_id node_id, OMX_HANDLETYPE handle) { 240 mNodeID = node_id; 241 CLOG_LIFE(allocateNode, "handle=%p", handle); 242 CHECK(mHandle == NULL); 243 mHandle = handle; 244} 245 246sp<GraphicBufferSource> OMXNodeInstance::getGraphicBufferSource() { 247 Mutex::Autolock autoLock(mGraphicBufferSourceLock); 248 return mGraphicBufferSource; 249} 250 251void OMXNodeInstance::setGraphicBufferSource( 252 const sp<GraphicBufferSource>& bufferSource) { 253 Mutex::Autolock autoLock(mGraphicBufferSourceLock); 254 CLOG_INTERNAL(setGraphicBufferSource, "%p", bufferSource.get()); 255 mGraphicBufferSource = bufferSource; 256} 257 258OMX *OMXNodeInstance::owner() { 259 return mOwner; 260} 261 262sp<IOMXObserver> OMXNodeInstance::observer() { 263 return mObserver; 264} 265 266OMX::node_id OMXNodeInstance::nodeID() { 267 return mNodeID; 268} 269 270status_t OMXNodeInstance::freeNode(OMXMaster *master) { 271 CLOG_LIFE(freeNode, "handle=%p", mHandle); 272 static int32_t kMaxNumIterations = 10; 273 274 // exit if we have already freed the node 275 if (mHandle == NULL) { 276 return OK; 277 } 278 279 // Transition the node from its current state all the way down 280 // to "Loaded". 281 // This ensures that all active buffers are properly freed even 282 // for components that don't do this themselves on a call to 283 // "FreeHandle". 284 285 // The code below may trigger some more events to be dispatched 286 // by the OMX component - we want to ignore them as our client 287 // does not expect them. 288 mDying = true; 289 290 OMX_STATETYPE state; 291 CHECK_EQ(OMX_GetState(mHandle, &state), OMX_ErrorNone); 292 switch (state) { 293 case OMX_StateExecuting: 294 { 295 ALOGV("forcing Executing->Idle"); 296 sendCommand(OMX_CommandStateSet, OMX_StateIdle); 297 OMX_ERRORTYPE err; 298 int32_t iteration = 0; 299 while ((err = OMX_GetState(mHandle, &state)) == OMX_ErrorNone 300 && state != OMX_StateIdle 301 && state != OMX_StateInvalid) { 302 if (++iteration > kMaxNumIterations) { 303 CLOGW("failed to enter Idle state (now %s(%d), aborting.", 304 asString(state), state); 305 state = OMX_StateInvalid; 306 break; 307 } 308 309 usleep(100000); 310 } 311 CHECK_EQ(err, OMX_ErrorNone); 312 313 if (state == OMX_StateInvalid) { 314 break; 315 } 316 317 // fall through 318 } 319 320 case OMX_StateIdle: 321 { 322 ALOGV("forcing Idle->Loaded"); 323 sendCommand(OMX_CommandStateSet, OMX_StateLoaded); 324 325 freeActiveBuffers(); 326 327 OMX_ERRORTYPE err; 328 int32_t iteration = 0; 329 while ((err = OMX_GetState(mHandle, &state)) == OMX_ErrorNone 330 && state != OMX_StateLoaded 331 && state != OMX_StateInvalid) { 332 if (++iteration > kMaxNumIterations) { 333 CLOGW("failed to enter Loaded state (now %s(%d), aborting.", 334 asString(state), state); 335 state = OMX_StateInvalid; 336 break; 337 } 338 339 ALOGV("waiting for Loaded state..."); 340 usleep(100000); 341 } 342 CHECK_EQ(err, OMX_ErrorNone); 343 344 // fall through 345 } 346 347 case OMX_StateLoaded: 348 case OMX_StateInvalid: 349 break; 350 351 default: 352 LOG_ALWAYS_FATAL("unknown state %s(%#x).", asString(state), state); 353 break; 354 } 355 356 Mutex::Autolock _l(mLock); 357 358 ALOGV("[%x:%s] calling destroyComponentInstance", mNodeID, mName); 359 OMX_ERRORTYPE err = master->destroyComponentInstance( 360 static_cast<OMX_COMPONENTTYPE *>(mHandle)); 361 362 mHandle = NULL; 363 CLOG_IF_ERROR(freeNode, err, ""); 364 free(mName); 365 mName = NULL; 366 367 mOwner->invalidateNodeID(mNodeID); 368 mNodeID = 0; 369 370 ALOGV("OMXNodeInstance going away."); 371 delete this; 372 373 return StatusFromOMXError(err); 374} 375 376status_t OMXNodeInstance::sendCommand( 377 OMX_COMMANDTYPE cmd, OMX_S32 param) { 378 if (cmd == OMX_CommandStateSet) { 379 // There are no configurations past first StateSet command. 380 mSailed = true; 381 } 382 const sp<GraphicBufferSource> bufferSource(getGraphicBufferSource()); 383 if (bufferSource != NULL && cmd == OMX_CommandStateSet) { 384 if (param == OMX_StateIdle) { 385 // Initiating transition from Executing -> Idle 386 // ACodec is waiting for all buffers to be returned, do NOT 387 // submit any more buffers to the codec. 388 bufferSource->omxIdle(); 389 } else if (param == OMX_StateLoaded) { 390 // Initiating transition from Idle/Executing -> Loaded 391 // Buffers are about to be freed. 392 bufferSource->omxLoaded(); 393 setGraphicBufferSource(NULL); 394 } 395 396 // fall through 397 } 398 399 Mutex::Autolock autoLock(mLock); 400 401 // bump internal-state debug level for 2 input and output frames past a command 402 { 403 Mutex::Autolock _l(mDebugLock); 404 bumpDebugLevel_l(2 /* numInputBuffers */, 2 /* numOutputBuffers */); 405 } 406 407 const char *paramString = 408 cmd == OMX_CommandStateSet ? asString((OMX_STATETYPE)param) : portString(param); 409 CLOG_STATE(sendCommand, "%s(%d), %s(%d)", asString(cmd), cmd, paramString, param); 410 OMX_ERRORTYPE err = OMX_SendCommand(mHandle, cmd, param, NULL); 411 CLOG_IF_ERROR(sendCommand, err, "%s(%d), %s(%d)", asString(cmd), cmd, paramString, param); 412 return StatusFromOMXError(err); 413} 414 415bool OMXNodeInstance::isProhibitedIndex_l(OMX_INDEXTYPE index) { 416 // these extensions can only be used from OMXNodeInstance, not by clients directly. 417 static const char *restricted_extensions[] = { 418 "OMX.google.android.index.storeMetaDataInBuffers", 419 "OMX.google.android.index.storeANWBufferInMetadata", 420 "OMX.google.android.index.prepareForAdaptivePlayback", 421 "OMX.google.android.index.configureVideoTunnelMode", 422 "OMX.google.android.index.useAndroidNativeBuffer2", 423 "OMX.google.android.index.useAndroidNativeBuffer", 424 "OMX.google.android.index.enableAndroidNativeBuffers", 425 "OMX.google.android.index.allocateNativeHandle", 426 "OMX.google.android.index.getAndroidNativeBufferUsage", 427 }; 428 429 if ((index > OMX_IndexComponentStartUnused && index <= OMX_IndexParamStandardComponentRole) 430 || (index > OMX_IndexPortStartUnused && index <= OMX_IndexParamCompBufferSupplier) 431 || (index > OMX_IndexAudioStartUnused && index <= OMX_IndexConfigAudioChannelVolume) 432 || (index > OMX_IndexVideoStartUnused && index <= OMX_IndexConfigVideoNalSize) 433 || (index > OMX_IndexCommonStartUnused 434 && index <= OMX_IndexConfigCommonTransitionEffect) 435 || (index > (OMX_INDEXTYPE)OMX_IndexExtAudioStartUnused 436 && index <= (OMX_INDEXTYPE)OMX_IndexParamAudioProfileQuerySupported) 437 || (index > (OMX_INDEXTYPE)OMX_IndexExtVideoStartUnused 438 && index <= (OMX_INDEXTYPE)OMX_IndexConfigAndroidVideoTemporalLayering) 439 || (index > (OMX_INDEXTYPE)OMX_IndexExtOtherStartUnused 440 && index <= (OMX_INDEXTYPE)OMX_IndexParamConsumerUsageBits)) { 441 return false; 442 } 443 444 if (!mQueriedProhibitedExtensions) { 445 for (size_t i = 0; i < NELEM(restricted_extensions); ++i) { 446 OMX_INDEXTYPE ext; 447 if (OMX_GetExtensionIndex(mHandle, (OMX_STRING)restricted_extensions[i], &ext) == OMX_ErrorNone) { 448 mProhibitedExtensions.add(ext); 449 } 450 } 451 mQueriedProhibitedExtensions = true; 452 } 453 454 return mProhibitedExtensions.indexOf(index) >= 0; 455} 456 457status_t OMXNodeInstance::getParameter( 458 OMX_INDEXTYPE index, void *params, size_t /* size */) { 459 Mutex::Autolock autoLock(mLock); 460 461 if (isProhibitedIndex_l(index)) { 462 android_errorWriteLog(0x534e4554, "29422020"); 463 return BAD_INDEX; 464 } 465 466 OMX_ERRORTYPE err = OMX_GetParameter(mHandle, index, params); 467 OMX_INDEXEXTTYPE extIndex = (OMX_INDEXEXTTYPE)index; 468 // some errors are expected for getParameter 469 if (err != OMX_ErrorNoMore) { 470 CLOG_IF_ERROR(getParameter, err, "%s(%#x)", asString(extIndex), index); 471 } 472 return StatusFromOMXError(err); 473} 474 475status_t OMXNodeInstance::setParameter( 476 OMX_INDEXTYPE index, const void *params, size_t size) { 477 Mutex::Autolock autoLock(mLock); 478 OMX_INDEXEXTTYPE extIndex = (OMX_INDEXEXTTYPE)index; 479 CLOG_CONFIG(setParameter, "%s(%#x), %zu@%p)", asString(extIndex), index, size, params); 480 481 if (isProhibitedIndex_l(index)) { 482 android_errorWriteLog(0x534e4554, "29422020"); 483 return BAD_INDEX; 484 } 485 486 OMX_ERRORTYPE err = OMX_SetParameter( 487 mHandle, index, const_cast<void *>(params)); 488 CLOG_IF_ERROR(setParameter, err, "%s(%#x)", asString(extIndex), index); 489 return StatusFromOMXError(err); 490} 491 492status_t OMXNodeInstance::getConfig( 493 OMX_INDEXTYPE index, void *params, size_t /* size */) { 494 Mutex::Autolock autoLock(mLock); 495 496 if (isProhibitedIndex_l(index)) { 497 android_errorWriteLog(0x534e4554, "29422020"); 498 return BAD_INDEX; 499 } 500 501 OMX_ERRORTYPE err = OMX_GetConfig(mHandle, index, params); 502 OMX_INDEXEXTTYPE extIndex = (OMX_INDEXEXTTYPE)index; 503 // some errors are expected for getConfig 504 if (err != OMX_ErrorNoMore) { 505 CLOG_IF_ERROR(getConfig, err, "%s(%#x)", asString(extIndex), index); 506 } 507 return StatusFromOMXError(err); 508} 509 510status_t OMXNodeInstance::setConfig( 511 OMX_INDEXTYPE index, const void *params, size_t size) { 512 Mutex::Autolock autoLock(mLock); 513 OMX_INDEXEXTTYPE extIndex = (OMX_INDEXEXTTYPE)index; 514 CLOG_CONFIG(setConfig, "%s(%#x), %zu@%p)", asString(extIndex), index, size, params); 515 516 if (isProhibitedIndex_l(index)) { 517 android_errorWriteLog(0x534e4554, "29422020"); 518 return BAD_INDEX; 519 } 520 521 OMX_ERRORTYPE err = OMX_SetConfig( 522 mHandle, index, const_cast<void *>(params)); 523 CLOG_IF_ERROR(setConfig, err, "%s(%#x)", asString(extIndex), index); 524 return StatusFromOMXError(err); 525} 526 527status_t OMXNodeInstance::getState(OMX_STATETYPE* state) { 528 Mutex::Autolock autoLock(mLock); 529 530 OMX_ERRORTYPE err = OMX_GetState(mHandle, state); 531 CLOG_IF_ERROR(getState, err, ""); 532 return StatusFromOMXError(err); 533} 534 535status_t OMXNodeInstance::enableNativeBuffers( 536 OMX_U32 portIndex, OMX_BOOL graphic, OMX_BOOL enable) { 537 if (portIndex >= NELEM(mSecureBufferType)) { 538 ALOGE("b/31385713, portIndex(%u)", portIndex); 539 android_errorWriteLog(0x534e4554, "31385713"); 540 return BAD_VALUE; 541 } 542 543 Mutex::Autolock autoLock(mLock); 544 CLOG_CONFIG(enableNativeBuffers, "%s:%u%s, %d", portString(portIndex), portIndex, 545 graphic ? ", graphic" : "", enable); 546 OMX_STRING name = const_cast<OMX_STRING>( 547 graphic ? "OMX.google.android.index.enableAndroidNativeBuffers" 548 : "OMX.google.android.index.allocateNativeHandle"); 549 550 OMX_INDEXTYPE index; 551 OMX_ERRORTYPE err = OMX_GetExtensionIndex(mHandle, name, &index); 552 553 if (err == OMX_ErrorNone) { 554 EnableAndroidNativeBuffersParams params; 555 InitOMXParams(¶ms); 556 params.nPortIndex = portIndex; 557 params.enable = enable; 558 559 err = OMX_SetParameter(mHandle, index, ¶ms); 560 CLOG_IF_ERROR(setParameter, err, "%s(%#x): %s:%u en=%d", name, index, 561 portString(portIndex), portIndex, enable); 562 if (!graphic) { 563 if (err == OMX_ErrorNone) { 564 mSecureBufferType[portIndex] = 565 enable ? kSecureBufferTypeNativeHandle : kSecureBufferTypeOpaque; 566 } else if (mSecureBufferType[portIndex] == kSecureBufferTypeUnknown) { 567 mSecureBufferType[portIndex] = kSecureBufferTypeOpaque; 568 } 569 } else { 570 if (err == OMX_ErrorNone) { 571 mGraphicBufferEnabled[portIndex] = enable; 572 } else if (enable) { 573 mGraphicBufferEnabled[portIndex] = false; 574 } 575 } 576 } else { 577 CLOG_ERROR_IF(enable, getExtensionIndex, err, "%s", name); 578 if (!graphic) { 579 // Extension not supported, check for manual override with system property 580 // This is a temporary workaround until partners support the OMX extension 581 char value[PROPERTY_VALUE_MAX]; 582 if (property_get("media.mediadrmservice.enable", value, NULL) 583 && (!strcmp("1", value) || !strcasecmp("true", value))) { 584 CLOG_CONFIG(enableNativeBuffers, "system property override: using native-handles"); 585 mSecureBufferType[portIndex] = kSecureBufferTypeNativeHandle; 586 } else if (mSecureBufferType[portIndex] == kSecureBufferTypeUnknown) { 587 mSecureBufferType[portIndex] = kSecureBufferTypeOpaque; 588 } 589 err = OMX_ErrorNone; 590 } 591 } 592 593 return StatusFromOMXError(err); 594} 595 596status_t OMXNodeInstance::getGraphicBufferUsage( 597 OMX_U32 portIndex, OMX_U32* usage) { 598 Mutex::Autolock autoLock(mLock); 599 600 OMX_INDEXTYPE index; 601 OMX_STRING name = const_cast<OMX_STRING>( 602 "OMX.google.android.index.getAndroidNativeBufferUsage"); 603 OMX_ERRORTYPE err = OMX_GetExtensionIndex(mHandle, name, &index); 604 605 if (err != OMX_ErrorNone) { 606 CLOG_ERROR(getExtensionIndex, err, "%s", name); 607 return StatusFromOMXError(err); 608 } 609 610 GetAndroidNativeBufferUsageParams params; 611 InitOMXParams(¶ms); 612 params.nPortIndex = portIndex; 613 614 err = OMX_GetParameter(mHandle, index, ¶ms); 615 if (err != OMX_ErrorNone) { 616 CLOG_ERROR(getParameter, err, "%s(%#x): %s:%u", name, index, 617 portString(portIndex), portIndex); 618 return StatusFromOMXError(err); 619 } 620 621 *usage = params.nUsage; 622 623 return OK; 624} 625 626status_t OMXNodeInstance::storeMetaDataInBuffers( 627 OMX_U32 portIndex, OMX_BOOL enable, MetadataBufferType *type) { 628 Mutex::Autolock autolock(mLock); 629 CLOG_CONFIG(storeMetaDataInBuffers, "%s:%u en:%d", portString(portIndex), portIndex, enable); 630 return storeMetaDataInBuffers_l(portIndex, enable, type); 631} 632 633status_t OMXNodeInstance::storeMetaDataInBuffers_l( 634 OMX_U32 portIndex, OMX_BOOL enable, MetadataBufferType *type) { 635 if (mSailed) { 636 android_errorWriteLog(0x534e4554, "29422020"); 637 return INVALID_OPERATION; 638 } 639 if (portIndex != kPortIndexInput && portIndex != kPortIndexOutput) { 640 android_errorWriteLog(0x534e4554, "26324358"); 641 if (type != NULL) { 642 *type = kMetadataBufferTypeInvalid; 643 } 644 return BAD_VALUE; 645 } 646 647 OMX_INDEXTYPE index; 648 OMX_STRING name = const_cast<OMX_STRING>( 649 "OMX.google.android.index.storeMetaDataInBuffers"); 650 651 OMX_STRING nativeBufferName = const_cast<OMX_STRING>( 652 "OMX.google.android.index.storeANWBufferInMetadata"); 653 MetadataBufferType negotiatedType; 654 MetadataBufferType requestedType = type != NULL ? *type : kMetadataBufferTypeANWBuffer; 655 656 StoreMetaDataInBuffersParams params; 657 InitOMXParams(¶ms); 658 params.nPortIndex = portIndex; 659 params.bStoreMetaData = enable; 660 661 OMX_ERRORTYPE err = 662 requestedType == kMetadataBufferTypeANWBuffer 663 ? OMX_GetExtensionIndex(mHandle, nativeBufferName, &index) 664 : OMX_ErrorUnsupportedIndex; 665 OMX_ERRORTYPE xerr = err; 666 if (err == OMX_ErrorNone) { 667 err = OMX_SetParameter(mHandle, index, ¶ms); 668 if (err == OMX_ErrorNone) { 669 name = nativeBufferName; // set name for debugging 670 negotiatedType = requestedType; 671 } 672 } 673 if (err != OMX_ErrorNone) { 674 err = OMX_GetExtensionIndex(mHandle, name, &index); 675 xerr = err; 676 if (err == OMX_ErrorNone) { 677 negotiatedType = 678 requestedType == kMetadataBufferTypeANWBuffer 679 ? kMetadataBufferTypeGrallocSource : requestedType; 680 err = OMX_SetParameter(mHandle, index, ¶ms); 681 } 682 } 683 684 // don't log loud error if component does not support metadata mode on the output 685 if (err != OMX_ErrorNone) { 686 if (err == OMX_ErrorUnsupportedIndex && portIndex == kPortIndexOutput) { 687 CLOGW("component does not support metadata mode; using fallback"); 688 } else if (xerr != OMX_ErrorNone) { 689 CLOG_ERROR(getExtensionIndex, xerr, "%s", name); 690 } else { 691 CLOG_ERROR(setParameter, err, "%s(%#x): %s:%u en=%d type=%d", name, index, 692 portString(portIndex), portIndex, enable, negotiatedType); 693 } 694 negotiatedType = mMetadataType[portIndex]; 695 } else { 696 if (!enable) { 697 negotiatedType = kMetadataBufferTypeInvalid; 698 } 699 mMetadataType[portIndex] = negotiatedType; 700 } 701 CLOG_CONFIG(storeMetaDataInBuffers, "%s:%u %srequested %s:%d negotiated %s:%d", 702 portString(portIndex), portIndex, enable ? "" : "UN", 703 asString(requestedType), requestedType, asString(negotiatedType), negotiatedType); 704 705 if (type != NULL) { 706 *type = negotiatedType; 707 } 708 709 return StatusFromOMXError(err); 710} 711 712status_t OMXNodeInstance::prepareForAdaptivePlayback( 713 OMX_U32 portIndex, OMX_BOOL enable, OMX_U32 maxFrameWidth, 714 OMX_U32 maxFrameHeight) { 715 Mutex::Autolock autolock(mLock); 716 if (mSailed) { 717 android_errorWriteLog(0x534e4554, "29422020"); 718 return INVALID_OPERATION; 719 } 720 CLOG_CONFIG(prepareForAdaptivePlayback, "%s:%u en=%d max=%ux%u", 721 portString(portIndex), portIndex, enable, maxFrameWidth, maxFrameHeight); 722 723 OMX_INDEXTYPE index; 724 OMX_STRING name = const_cast<OMX_STRING>( 725 "OMX.google.android.index.prepareForAdaptivePlayback"); 726 727 OMX_ERRORTYPE err = OMX_GetExtensionIndex(mHandle, name, &index); 728 if (err != OMX_ErrorNone) { 729 CLOG_ERROR_IF(enable, getExtensionIndex, err, "%s", name); 730 return StatusFromOMXError(err); 731 } 732 733 PrepareForAdaptivePlaybackParams params; 734 InitOMXParams(¶ms); 735 params.nPortIndex = portIndex; 736 params.bEnable = enable; 737 params.nMaxFrameWidth = maxFrameWidth; 738 params.nMaxFrameHeight = maxFrameHeight; 739 740 err = OMX_SetParameter(mHandle, index, ¶ms); 741 CLOG_IF_ERROR(setParameter, err, "%s(%#x): %s:%u en=%d max=%ux%u", name, index, 742 portString(portIndex), portIndex, enable, maxFrameWidth, maxFrameHeight); 743 return StatusFromOMXError(err); 744} 745 746status_t OMXNodeInstance::configureVideoTunnelMode( 747 OMX_U32 portIndex, OMX_BOOL tunneled, OMX_U32 audioHwSync, 748 native_handle_t **sidebandHandle) { 749 Mutex::Autolock autolock(mLock); 750 if (mSailed) { 751 android_errorWriteLog(0x534e4554, "29422020"); 752 return INVALID_OPERATION; 753 } 754 CLOG_CONFIG(configureVideoTunnelMode, "%s:%u tun=%d sync=%u", 755 portString(portIndex), portIndex, tunneled, audioHwSync); 756 757 OMX_INDEXTYPE index; 758 OMX_STRING name = const_cast<OMX_STRING>( 759 "OMX.google.android.index.configureVideoTunnelMode"); 760 761 OMX_ERRORTYPE err = OMX_GetExtensionIndex(mHandle, name, &index); 762 if (err != OMX_ErrorNone) { 763 CLOG_ERROR_IF(tunneled, getExtensionIndex, err, "%s", name); 764 return StatusFromOMXError(err); 765 } 766 767 ConfigureVideoTunnelModeParams tunnelParams; 768 InitOMXParams(&tunnelParams); 769 tunnelParams.nPortIndex = portIndex; 770 tunnelParams.bTunneled = tunneled; 771 tunnelParams.nAudioHwSync = audioHwSync; 772 err = OMX_SetParameter(mHandle, index, &tunnelParams); 773 if (err != OMX_ErrorNone) { 774 CLOG_ERROR(setParameter, err, "%s(%#x): %s:%u tun=%d sync=%u", name, index, 775 portString(portIndex), portIndex, tunneled, audioHwSync); 776 return StatusFromOMXError(err); 777 } 778 779 err = OMX_GetParameter(mHandle, index, &tunnelParams); 780 if (err != OMX_ErrorNone) { 781 CLOG_ERROR(getParameter, err, "%s(%#x): %s:%u tun=%d sync=%u", name, index, 782 portString(portIndex), portIndex, tunneled, audioHwSync); 783 return StatusFromOMXError(err); 784 } 785 if (sidebandHandle) { 786 *sidebandHandle = (native_handle_t*)tunnelParams.pSidebandWindow; 787 } 788 789 return OK; 790} 791 792status_t OMXNodeInstance::useBuffer( 793 OMX_U32 portIndex, const sp<IMemory> ¶ms, 794 OMX::buffer_id *buffer, OMX_U32 allottedSize) { 795 if (params == NULL || buffer == NULL) { 796 ALOGE("b/25884056"); 797 return BAD_VALUE; 798 } 799 800 Mutex::Autolock autoLock(mLock); 801 if (allottedSize > params->size() || portIndex >= NELEM(mNumPortBuffers)) { 802 return BAD_VALUE; 803 } 804 805 if (!mSailed) { 806 ALOGE("b/35467458"); 807 android_errorWriteLog(0x534e4554, "35467458"); 808 return BAD_VALUE; 809 } 810 811 if (mMetadataType[portIndex] == kMetadataBufferTypeInvalid 812 && mGraphicBufferEnabled[portIndex]) { 813 ALOGE("b/62948670"); 814 android_errorWriteLog(0x534e4554, "62948670"); 815 return INVALID_OPERATION; 816 } 817 818 // metadata buffers are not connected cross process 819 // use a backup buffer instead of the actual buffer 820 BufferMeta *buffer_meta; 821 bool useBackup = mMetadataType[portIndex] != kMetadataBufferTypeInvalid; 822 OMX_U8 *data = static_cast<OMX_U8 *>(params->pointer()); 823 // allocate backup buffer 824 if (useBackup) { 825 data = new (std::nothrow) OMX_U8[allottedSize]; 826 if (data == NULL) { 827 return NO_MEMORY; 828 } 829 memset(data, 0, allottedSize); 830 831 buffer_meta = new BufferMeta( 832 params, portIndex, false /* copyToOmx */, false /* copyFromOmx */, data); 833 } else { 834 buffer_meta = new BufferMeta( 835 params, portIndex, false /* copyToOmx */, false /* copyFromOmx */, NULL); 836 } 837 838 OMX_BUFFERHEADERTYPE *header; 839 840 OMX_ERRORTYPE err = OMX_UseBuffer( 841 mHandle, &header, portIndex, buffer_meta, 842 allottedSize, data); 843 844 if (err != OMX_ErrorNone) { 845 CLOG_ERROR(useBuffer, err, SIMPLE_BUFFER( 846 portIndex, (size_t)allottedSize, data)); 847 848 delete buffer_meta; 849 buffer_meta = NULL; 850 851 *buffer = 0; 852 853 return StatusFromOMXError(err); 854 } 855 856 CHECK_EQ(header->pAppPrivate, buffer_meta); 857 858 *buffer = makeBufferID(header); 859 860 addActiveBuffer(portIndex, *buffer); 861 862 sp<GraphicBufferSource> bufferSource(getGraphicBufferSource()); 863 if (bufferSource != NULL && portIndex == kPortIndexInput) { 864 bufferSource->addCodecBuffer(header); 865 } 866 867 CLOG_BUFFER(useBuffer, NEW_BUFFER_FMT( 868 *buffer, portIndex, "%u(%zu)@%p", allottedSize, params->size(), params->pointer())); 869 return OK; 870} 871 872status_t OMXNodeInstance::useGraphicBuffer2_l( 873 OMX_U32 portIndex, const sp<GraphicBuffer>& graphicBuffer, 874 OMX::buffer_id *buffer) { 875 if (graphicBuffer == NULL || buffer == NULL) { 876 ALOGE("b/25884056"); 877 return BAD_VALUE; 878 } 879 880 // port definition 881 OMX_PARAM_PORTDEFINITIONTYPE def; 882 InitOMXParams(&def); 883 def.nPortIndex = portIndex; 884 OMX_ERRORTYPE err = OMX_GetParameter(mHandle, OMX_IndexParamPortDefinition, &def); 885 if (err != OMX_ErrorNone) { 886 OMX_INDEXTYPE index = OMX_IndexParamPortDefinition; 887 CLOG_ERROR(getParameter, err, "%s(%#x): %s:%u", 888 asString(index), index, portString(portIndex), portIndex); 889 return UNKNOWN_ERROR; 890 } 891 892 BufferMeta *bufferMeta = new BufferMeta(graphicBuffer, portIndex); 893 894 OMX_BUFFERHEADERTYPE *header = NULL; 895 OMX_U8* bufferHandle = const_cast<OMX_U8*>( 896 reinterpret_cast<const OMX_U8*>(graphicBuffer->handle)); 897 898 err = OMX_UseBuffer( 899 mHandle, 900 &header, 901 portIndex, 902 bufferMeta, 903 def.nBufferSize, 904 bufferHandle); 905 906 if (err != OMX_ErrorNone) { 907 CLOG_ERROR(useBuffer, err, BUFFER_FMT(portIndex, "%u@%p", def.nBufferSize, bufferHandle)); 908 delete bufferMeta; 909 bufferMeta = NULL; 910 *buffer = 0; 911 return StatusFromOMXError(err); 912 } 913 914 CHECK_EQ(header->pBuffer, bufferHandle); 915 CHECK_EQ(header->pAppPrivate, bufferMeta); 916 917 *buffer = makeBufferID(header); 918 919 addActiveBuffer(portIndex, *buffer); 920 CLOG_BUFFER(useGraphicBuffer2, NEW_BUFFER_FMT( 921 *buffer, portIndex, "%u@%p", def.nBufferSize, bufferHandle)); 922 return OK; 923} 924 925// XXX: This function is here for backwards compatibility. Once the OMX 926// implementations have been updated this can be removed and useGraphicBuffer2 927// can be renamed to useGraphicBuffer. 928status_t OMXNodeInstance::useGraphicBuffer( 929 OMX_U32 portIndex, const sp<GraphicBuffer>& graphicBuffer, 930 OMX::buffer_id *buffer) { 931 if (graphicBuffer == NULL || buffer == NULL) { 932 ALOGE("b/25884056"); 933 return BAD_VALUE; 934 } 935 Mutex::Autolock autoLock(mLock); 936 if (!mGraphicBufferEnabled[portIndex] 937 || mMetadataType[portIndex] != kMetadataBufferTypeInvalid) { 938 // Report error if this is not in graphic buffer mode. 939 ALOGE("b/62948670"); 940 android_errorWriteLog(0x534e4554, "62948670"); 941 return INVALID_OPERATION; 942 } 943 944 // See if the newer version of the extension is present. 945 OMX_INDEXTYPE index; 946 if (OMX_GetExtensionIndex( 947 mHandle, 948 const_cast<OMX_STRING>("OMX.google.android.index.useAndroidNativeBuffer2"), 949 &index) == OMX_ErrorNone) { 950 return useGraphicBuffer2_l(portIndex, graphicBuffer, buffer); 951 } 952 953 OMX_STRING name = const_cast<OMX_STRING>( 954 "OMX.google.android.index.useAndroidNativeBuffer"); 955 OMX_ERRORTYPE err = OMX_GetExtensionIndex(mHandle, name, &index); 956 if (err != OMX_ErrorNone) { 957 CLOG_ERROR(getExtensionIndex, err, "%s", name); 958 return StatusFromOMXError(err); 959 } 960 961 BufferMeta *bufferMeta = new BufferMeta(graphicBuffer, portIndex); 962 963 OMX_BUFFERHEADERTYPE *header; 964 965 OMX_VERSIONTYPE ver; 966 ver.s.nVersionMajor = 1; 967 ver.s.nVersionMinor = 0; 968 ver.s.nRevision = 0; 969 ver.s.nStep = 0; 970 UseAndroidNativeBufferParams params = { 971 sizeof(UseAndroidNativeBufferParams), ver, portIndex, bufferMeta, 972 &header, graphicBuffer, 973 }; 974 975 err = OMX_SetParameter(mHandle, index, ¶ms); 976 977 if (err != OMX_ErrorNone) { 978 CLOG_ERROR(setParameter, err, "%s(%#x): %s:%u meta=%p GB=%p", name, index, 979 portString(portIndex), portIndex, bufferMeta, graphicBuffer->handle); 980 981 delete bufferMeta; 982 bufferMeta = NULL; 983 984 *buffer = 0; 985 986 return StatusFromOMXError(err); 987 } 988 989 CHECK_EQ(header->pAppPrivate, bufferMeta); 990 991 *buffer = makeBufferID(header); 992 993 addActiveBuffer(portIndex, *buffer); 994 CLOG_BUFFER(useGraphicBuffer, NEW_BUFFER_FMT( 995 *buffer, portIndex, "GB=%p", graphicBuffer->handle)); 996 return OK; 997} 998 999status_t OMXNodeInstance::updateGraphicBufferInMeta_l( 1000 OMX_U32 portIndex, const sp<GraphicBuffer>& graphicBuffer, 1001 OMX::buffer_id buffer, OMX_BUFFERHEADERTYPE *header, bool updateCodecBuffer) { 1002 // No need to check |graphicBuffer| since NULL is valid for it as below. 1003 if (header == NULL) { 1004 ALOGE("b/25884056"); 1005 return BAD_VALUE; 1006 } 1007 1008 if (portIndex != kPortIndexInput && portIndex != kPortIndexOutput) { 1009 return BAD_VALUE; 1010 } 1011 1012 BufferMeta *bufferMeta = (BufferMeta *)(header->pAppPrivate); 1013 sp<ABuffer> data = bufferMeta->getBuffer( 1014 header, !updateCodecBuffer /* backup */, false /* limit */); 1015 bufferMeta->setGraphicBuffer(graphicBuffer); 1016 MetadataBufferType metaType = mMetadataType[portIndex]; 1017 // we use gralloc source only in the codec buffers 1018 if (metaType == kMetadataBufferTypeGrallocSource && !updateCodecBuffer) { 1019 metaType = kMetadataBufferTypeANWBuffer; 1020 } 1021 if (metaType == kMetadataBufferTypeGrallocSource 1022 && data->capacity() >= sizeof(VideoGrallocMetadata)) { 1023 VideoGrallocMetadata &metadata = *(VideoGrallocMetadata *)(data->data()); 1024 metadata.eType = kMetadataBufferTypeGrallocSource; 1025 metadata.pHandle = graphicBuffer == NULL ? NULL : graphicBuffer->handle; 1026 } else if (metaType == kMetadataBufferTypeANWBuffer 1027 && data->capacity() >= sizeof(VideoNativeMetadata)) { 1028 VideoNativeMetadata &metadata = *(VideoNativeMetadata *)(data->data()); 1029 metadata.eType = kMetadataBufferTypeANWBuffer; 1030 metadata.pBuffer = graphicBuffer == NULL ? NULL : graphicBuffer->getNativeBuffer(); 1031 metadata.nFenceFd = -1; 1032 } else { 1033 CLOG_ERROR(updateGraphicBufferInMeta, BAD_VALUE, "%s:%u, %#x bad type (%d) or size (%u)", 1034 portString(portIndex), portIndex, buffer, mMetadataType[portIndex], header->nAllocLen); 1035 return BAD_VALUE; 1036 } 1037 1038 CLOG_BUFFER(updateGraphicBufferInMeta, "%s:%u, %#x := %p", 1039 portString(portIndex), portIndex, buffer, 1040 graphicBuffer == NULL ? NULL : graphicBuffer->handle); 1041 return OK; 1042} 1043 1044status_t OMXNodeInstance::updateGraphicBufferInMeta( 1045 OMX_U32 portIndex, const sp<GraphicBuffer>& graphicBuffer, 1046 OMX::buffer_id buffer) { 1047 Mutex::Autolock autoLock(mLock); 1048 OMX_BUFFERHEADERTYPE *header = findBufferHeader(buffer, portIndex); 1049 // update backup buffer for input, codec buffer for output 1050 return updateGraphicBufferInMeta_l( 1051 portIndex, graphicBuffer, buffer, header, 1052 true /* updateCodecBuffer */); 1053} 1054 1055status_t OMXNodeInstance::updateNativeHandleInMeta( 1056 OMX_U32 portIndex, const sp<NativeHandle>& nativeHandle, OMX::buffer_id buffer) { 1057 Mutex::Autolock autoLock(mLock); 1058 OMX_BUFFERHEADERTYPE *header = findBufferHeader(buffer, portIndex); 1059 // No need to check |nativeHandle| since NULL is valid for it as below. 1060 if (header == NULL) { 1061 ALOGE("b/25884056"); 1062 return BAD_VALUE; 1063 } 1064 1065 if (portIndex != kPortIndexInput && portIndex != kPortIndexOutput) { 1066 return BAD_VALUE; 1067 } 1068 1069 BufferMeta *bufferMeta = (BufferMeta *)(header->pAppPrivate); 1070 // update backup buffer 1071 sp<ABuffer> data = bufferMeta->getBuffer( 1072 header, false /* backup */, false /* limit */); 1073 bufferMeta->setNativeHandle(nativeHandle); 1074 if (mMetadataType[portIndex] == kMetadataBufferTypeNativeHandleSource 1075 && data->capacity() >= sizeof(VideoNativeHandleMetadata)) { 1076 VideoNativeHandleMetadata &metadata = *(VideoNativeHandleMetadata *)(data->data()); 1077 metadata.eType = mMetadataType[portIndex]; 1078 metadata.pHandle = 1079 nativeHandle == NULL ? NULL : const_cast<native_handle*>(nativeHandle->handle()); 1080 } else { 1081 CLOG_ERROR(updateNativeHandleInMeta, BAD_VALUE, "%s:%u, %#x bad type (%d) or size (%zu)", 1082 portString(portIndex), portIndex, buffer, mMetadataType[portIndex], data->capacity()); 1083 return BAD_VALUE; 1084 } 1085 1086 CLOG_BUFFER(updateNativeHandleInMeta, "%s:%u, %#x := %p", 1087 portString(portIndex), portIndex, buffer, 1088 nativeHandle == NULL ? NULL : nativeHandle->handle()); 1089 return OK; 1090} 1091 1092status_t OMXNodeInstance::createGraphicBufferSource( 1093 OMX_U32 portIndex, sp<IGraphicBufferConsumer> bufferConsumer, MetadataBufferType *type) { 1094 status_t err; 1095 1096 // only allow graphic source on input port, when there are no allocated buffers yet 1097 if (portIndex != kPortIndexInput) { 1098 android_errorWriteLog(0x534e4554, "29422020"); 1099 return BAD_VALUE; 1100 } else if (mNumPortBuffers[portIndex] > 0) { 1101 android_errorWriteLog(0x534e4554, "29422020"); 1102 return INVALID_OPERATION; 1103 } 1104 1105 const sp<GraphicBufferSource> surfaceCheck = getGraphicBufferSource(); 1106 if (surfaceCheck != NULL) { 1107 if (portIndex < NELEM(mMetadataType) && type != NULL) { 1108 *type = mMetadataType[portIndex]; 1109 } 1110 return ALREADY_EXISTS; 1111 } 1112 1113 // Input buffers will hold meta-data (ANativeWindowBuffer references). 1114 if (type != NULL) { 1115 *type = kMetadataBufferTypeANWBuffer; 1116 } 1117 err = storeMetaDataInBuffers_l(portIndex, OMX_TRUE, type); 1118 if (err != OK) { 1119 return err; 1120 } 1121 1122 // Retrieve the width and height of the graphic buffer, set when the 1123 // codec was configured. 1124 OMX_PARAM_PORTDEFINITIONTYPE def; 1125 InitOMXParams(&def); 1126 def.nPortIndex = portIndex; 1127 OMX_ERRORTYPE oerr = OMX_GetParameter( 1128 mHandle, OMX_IndexParamPortDefinition, &def); 1129 if (oerr != OMX_ErrorNone) { 1130 OMX_INDEXTYPE index = OMX_IndexParamPortDefinition; 1131 CLOG_ERROR(getParameter, oerr, "%s(%#x): %s:%u", 1132 asString(index), index, portString(portIndex), portIndex); 1133 return UNKNOWN_ERROR; 1134 } 1135 1136 if (def.format.video.eColorFormat != OMX_COLOR_FormatAndroidOpaque) { 1137 CLOGW("createInputSurface requires COLOR_FormatSurface " 1138 "(AndroidOpaque) color format instead of %s(%#x)", 1139 asString(def.format.video.eColorFormat), def.format.video.eColorFormat); 1140 return INVALID_OPERATION; 1141 } 1142 1143 uint32_t usageBits; 1144 oerr = OMX_GetParameter( 1145 mHandle, (OMX_INDEXTYPE)OMX_IndexParamConsumerUsageBits, &usageBits); 1146 if (oerr != OMX_ErrorNone) { 1147 usageBits = 0; 1148 } 1149 1150 sp<GraphicBufferSource> bufferSource = new GraphicBufferSource(this, 1151 def.format.video.nFrameWidth, 1152 def.format.video.nFrameHeight, 1153 def.nBufferCountActual, 1154 usageBits, 1155 bufferConsumer); 1156 1157 if ((err = bufferSource->init()) != OK) { 1158 return err; 1159 } 1160 setGraphicBufferSource(bufferSource); 1161 1162 return OK; 1163} 1164 1165status_t OMXNodeInstance::createInputSurface( 1166 OMX_U32 portIndex, android_dataspace dataSpace, 1167 sp<IGraphicBufferProducer> *bufferProducer, MetadataBufferType *type) { 1168 if (bufferProducer == NULL) { 1169 ALOGE("b/25884056"); 1170 return BAD_VALUE; 1171 } 1172 1173 Mutex::Autolock autolock(mLock); 1174 status_t err = createGraphicBufferSource(portIndex, NULL /* bufferConsumer */, type); 1175 1176 if (err != OK) { 1177 return err; 1178 } 1179 1180 mGraphicBufferSource->setDefaultDataSpace(dataSpace); 1181 1182 *bufferProducer = mGraphicBufferSource->getIGraphicBufferProducer(); 1183 return OK; 1184} 1185 1186//static 1187status_t OMXNodeInstance::createPersistentInputSurface( 1188 sp<IGraphicBufferProducer> *bufferProducer, 1189 sp<IGraphicBufferConsumer> *bufferConsumer) { 1190 if (bufferProducer == NULL || bufferConsumer == NULL) { 1191 ALOGE("b/25884056"); 1192 return BAD_VALUE; 1193 } 1194 String8 name("GraphicBufferSource"); 1195 1196 sp<IGraphicBufferProducer> producer; 1197 sp<IGraphicBufferConsumer> consumer; 1198 BufferQueue::createBufferQueue(&producer, &consumer); 1199 consumer->setConsumerName(name); 1200 consumer->setConsumerUsageBits(GRALLOC_USAGE_HW_VIDEO_ENCODER); 1201 1202 sp<BufferQueue::ProxyConsumerListener> proxy = 1203 new BufferQueue::ProxyConsumerListener(NULL); 1204 status_t err = consumer->consumerConnect(proxy, false); 1205 if (err != NO_ERROR) { 1206 ALOGE("Error connecting to BufferQueue: %s (%d)", 1207 strerror(-err), err); 1208 return err; 1209 } 1210 1211 *bufferProducer = producer; 1212 *bufferConsumer = consumer; 1213 1214 return OK; 1215} 1216 1217status_t OMXNodeInstance::setInputSurface( 1218 OMX_U32 portIndex, const sp<IGraphicBufferConsumer> &bufferConsumer, 1219 MetadataBufferType *type) { 1220 Mutex::Autolock autolock(mLock); 1221 return createGraphicBufferSource(portIndex, bufferConsumer, type); 1222} 1223 1224void OMXNodeInstance::signalEvent(OMX_EVENTTYPE event, OMX_U32 arg1, OMX_U32 arg2) { 1225 mOwner->OnEvent(mNodeID, event, arg1, arg2, NULL); 1226} 1227 1228status_t OMXNodeInstance::signalEndOfInputStream() { 1229 // For non-Surface input, the MediaCodec should convert the call to a 1230 // pair of requests (dequeue input buffer, queue input buffer with EOS 1231 // flag set). Seems easier than doing the equivalent from here. 1232 sp<GraphicBufferSource> bufferSource(getGraphicBufferSource()); 1233 if (bufferSource == NULL) { 1234 CLOGW("signalEndOfInputStream can only be used with Surface input"); 1235 return INVALID_OPERATION; 1236 } 1237 return bufferSource->signalEndOfInputStream(); 1238} 1239 1240status_t OMXNodeInstance::allocateSecureBuffer( 1241 OMX_U32 portIndex, size_t size, OMX::buffer_id *buffer, 1242 void **buffer_data, sp<NativeHandle> *native_handle) { 1243 if (buffer == NULL || buffer_data == NULL || native_handle == NULL) { 1244 ALOGE("b/25884056"); 1245 return BAD_VALUE; 1246 } 1247 1248 if (portIndex >= NELEM(mSecureBufferType)) { 1249 ALOGE("b/31385713, portIndex(%u)", portIndex); 1250 android_errorWriteLog(0x534e4554, "31385713"); 1251 return BAD_VALUE; 1252 } 1253 1254 Mutex::Autolock autoLock(mLock); 1255 1256 if (!mSailed) { 1257 ALOGE("b/35467458"); 1258 android_errorWriteLog(0x534e4554, "35467458"); 1259 return BAD_VALUE; 1260 } 1261 1262 if (mSecureBufferType[portIndex] == kSecureBufferTypeUnknown) { 1263 ALOGE("b/63522818"); 1264 android_errorWriteLog(0x534e4554, "63522818"); 1265 return ERROR_UNSUPPORTED; 1266 } 1267 1268 BufferMeta *buffer_meta = new BufferMeta(size, portIndex); 1269 1270 OMX_BUFFERHEADERTYPE *header; 1271 1272 OMX_ERRORTYPE err = OMX_AllocateBuffer( 1273 mHandle, &header, portIndex, buffer_meta, size); 1274 1275 if (err != OMX_ErrorNone) { 1276 CLOG_ERROR(allocateBuffer, err, BUFFER_FMT(portIndex, "%zu@", size)); 1277 delete buffer_meta; 1278 buffer_meta = NULL; 1279 1280 *buffer = 0; 1281 1282 return StatusFromOMXError(err); 1283 } 1284 1285 CHECK_EQ(header->pAppPrivate, buffer_meta); 1286 1287 *buffer = makeBufferID(header); 1288 if (mSecureBufferType[portIndex] == kSecureBufferTypeNativeHandle) { 1289 *buffer_data = NULL; 1290 *native_handle = NativeHandle::create( 1291 (native_handle_t *)header->pBuffer, false /* ownsHandle */); 1292 } else { 1293 *buffer_data = header->pBuffer; 1294 *native_handle = NULL; 1295 } 1296 1297 addActiveBuffer(portIndex, *buffer); 1298 1299 sp<GraphicBufferSource> bufferSource(getGraphicBufferSource()); 1300 if (bufferSource != NULL && portIndex == kPortIndexInput) { 1301 bufferSource->addCodecBuffer(header); 1302 } 1303 CLOG_BUFFER(allocateSecureBuffer, NEW_BUFFER_FMT( 1304 *buffer, portIndex, "%zu@%p:%p", size, *buffer_data, 1305 *native_handle == NULL ? NULL : (*native_handle)->handle())); 1306 1307 return OK; 1308} 1309 1310status_t OMXNodeInstance::allocateBufferWithBackup( 1311 OMX_U32 portIndex, const sp<IMemory> ¶ms, 1312 OMX::buffer_id *buffer, OMX_U32 allottedSize) { 1313 if (params == NULL || buffer == NULL) { 1314 ALOGE("b/25884056"); 1315 return BAD_VALUE; 1316 } 1317 1318 Mutex::Autolock autoLock(mLock); 1319 if (allottedSize > params->size() || portIndex >= NELEM(mNumPortBuffers)) { 1320 return BAD_VALUE; 1321 } 1322 1323 if (!mSailed) { 1324 ALOGE("b/35467458"); 1325 android_errorWriteLog(0x534e4554, "35467458"); 1326 return BAD_VALUE; 1327 } 1328 1329 if (mSecureBufferType[portIndex] != kSecureBufferTypeUnknown) { 1330 ALOGE("b/63522818"); 1331 android_errorWriteLog(0x534e4554, "63522818"); 1332 return ERROR_UNSUPPORTED; 1333 } 1334 1335 // metadata buffers are not connected cross process; only copy if not meta 1336 bool copy = mMetadataType[portIndex] == kMetadataBufferTypeInvalid; 1337 1338 BufferMeta *buffer_meta = new BufferMeta( 1339 params, portIndex, 1340 (portIndex == kPortIndexInput) && copy /* copyToOmx */, 1341 (portIndex == kPortIndexOutput) && copy /* copyFromOmx */, 1342 NULL /* data */); 1343 1344 OMX_BUFFERHEADERTYPE *header; 1345 1346 OMX_ERRORTYPE err = OMX_AllocateBuffer( 1347 mHandle, &header, portIndex, buffer_meta, allottedSize); 1348 if (err != OMX_ErrorNone) { 1349 CLOG_ERROR(allocateBufferWithBackup, err, 1350 SIMPLE_BUFFER(portIndex, (size_t)allottedSize, params->pointer())); 1351 delete buffer_meta; 1352 buffer_meta = NULL; 1353 1354 *buffer = 0; 1355 1356 return StatusFromOMXError(err); 1357 } 1358 1359 CHECK_EQ(header->pAppPrivate, buffer_meta); 1360 1361 *buffer = makeBufferID(header); 1362 1363 addActiveBuffer(portIndex, *buffer); 1364 1365 sp<GraphicBufferSource> bufferSource(getGraphicBufferSource()); 1366 if (bufferSource != NULL && portIndex == kPortIndexInput) { 1367 bufferSource->addCodecBuffer(header); 1368 } 1369 1370 CLOG_BUFFER(allocateBufferWithBackup, NEW_BUFFER_FMT(*buffer, portIndex, "%zu@%p :> %u@%p", 1371 params->size(), params->pointer(), allottedSize, header->pBuffer)); 1372 1373 return OK; 1374} 1375 1376status_t OMXNodeInstance::freeBuffer( 1377 OMX_U32 portIndex, OMX::buffer_id buffer) { 1378 Mutex::Autolock autoLock(mLock); 1379 CLOG_BUFFER(freeBuffer, "%s:%u %#x", portString(portIndex), portIndex, buffer); 1380 1381 removeActiveBuffer(portIndex, buffer); 1382 1383 OMX_BUFFERHEADERTYPE *header = findBufferHeader(buffer, portIndex); 1384 if (header == NULL) { 1385 ALOGE("b/25884056"); 1386 return BAD_VALUE; 1387 } 1388 BufferMeta *buffer_meta = static_cast<BufferMeta *>(header->pAppPrivate); 1389 1390 OMX_ERRORTYPE err = OMX_FreeBuffer(mHandle, portIndex, header); 1391 CLOG_IF_ERROR(freeBuffer, err, "%s:%u %#x", portString(portIndex), portIndex, buffer); 1392 1393 delete buffer_meta; 1394 buffer_meta = NULL; 1395 invalidateBufferID(buffer); 1396 1397 return StatusFromOMXError(err); 1398} 1399 1400status_t OMXNodeInstance::fillBuffer(OMX::buffer_id buffer, int fenceFd) { 1401 Mutex::Autolock autoLock(mLock); 1402 1403 OMX_BUFFERHEADERTYPE *header = findBufferHeader(buffer, kPortIndexOutput); 1404 if (header == NULL) { 1405 ALOGE("b/25884056"); 1406 return BAD_VALUE; 1407 } 1408 header->nFilledLen = 0; 1409 header->nOffset = 0; 1410 header->nFlags = 0; 1411 1412 // meta now owns fenceFd 1413 status_t res = storeFenceInMeta_l(header, fenceFd, kPortIndexOutput); 1414 if (res != OK) { 1415 CLOG_ERROR(fillBuffer::storeFenceInMeta, res, EMPTY_BUFFER(buffer, header, fenceFd)); 1416 return res; 1417 } 1418 1419 { 1420 Mutex::Autolock _l(mDebugLock); 1421 mOutputBuffersWithCodec.add(header); 1422 CLOG_BUMPED_BUFFER(fillBuffer, WITH_STATS(EMPTY_BUFFER(buffer, header, fenceFd))); 1423 } 1424 1425 OMX_ERRORTYPE err = OMX_FillThisBuffer(mHandle, header); 1426 if (err != OMX_ErrorNone) { 1427 CLOG_ERROR(fillBuffer, err, EMPTY_BUFFER(buffer, header, fenceFd)); 1428 Mutex::Autolock _l(mDebugLock); 1429 mOutputBuffersWithCodec.remove(header); 1430 } 1431 return StatusFromOMXError(err); 1432} 1433 1434status_t OMXNodeInstance::emptyBuffer( 1435 OMX::buffer_id buffer, 1436 OMX_U32 rangeOffset, OMX_U32 rangeLength, 1437 OMX_U32 flags, OMX_TICKS timestamp, int fenceFd) { 1438 Mutex::Autolock autoLock(mLock); 1439 1440 // no emptybuffer if using input surface 1441 if (getGraphicBufferSource() != NULL) { 1442 android_errorWriteLog(0x534e4554, "29422020"); 1443 return INVALID_OPERATION; 1444 } 1445 1446 OMX_BUFFERHEADERTYPE *header = findBufferHeader(buffer, kPortIndexInput); 1447 if (header == NULL) { 1448 ALOGE("b/25884056"); 1449 return BAD_VALUE; 1450 } 1451 BufferMeta *buffer_meta = 1452 static_cast<BufferMeta *>(header->pAppPrivate); 1453 1454 // set up proper filled length if component is configured for gralloc metadata mode 1455 // ignore rangeOffset in this case (as client may be assuming ANW meta buffers). 1456 if (mMetadataType[kPortIndexInput] == kMetadataBufferTypeGrallocSource) { 1457 header->nFilledLen = rangeLength ? sizeof(VideoGrallocMetadata) : 0; 1458 header->nOffset = 0; 1459 } else { 1460 // rangeLength and rangeOffset must be a subset of the allocated data in the buffer. 1461 // corner case: we permit rangeOffset == end-of-buffer with rangeLength == 0. 1462 if (rangeOffset > header->nAllocLen 1463 || rangeLength > header->nAllocLen - rangeOffset) { 1464 CLOG_ERROR(emptyBuffer, OMX_ErrorBadParameter, FULL_BUFFER(NULL, header, fenceFd)); 1465 if (fenceFd >= 0) { 1466 ::close(fenceFd); 1467 } 1468 return BAD_VALUE; 1469 } 1470 header->nFilledLen = rangeLength; 1471 header->nOffset = rangeOffset; 1472 1473 buffer_meta->CopyToOMX(header); 1474 } 1475 1476 return emptyBuffer_l(header, flags, timestamp, (intptr_t)buffer, fenceFd); 1477} 1478 1479// log queued buffer activity for the next few input and/or output frames 1480// if logging at internal state level 1481void OMXNodeInstance::bumpDebugLevel_l(size_t numInputBuffers, size_t numOutputBuffers) { 1482 if (DEBUG == ADebug::kDebugInternalState) { 1483 DEBUG_BUMP = ADebug::kDebugAll; 1484 if (numInputBuffers > 0) { 1485 mDebugLevelBumpPendingBuffers[kPortIndexInput] = numInputBuffers; 1486 } 1487 if (numOutputBuffers > 0) { 1488 mDebugLevelBumpPendingBuffers[kPortIndexOutput] = numOutputBuffers; 1489 } 1490 } 1491} 1492 1493void OMXNodeInstance::unbumpDebugLevel_l(size_t portIndex) { 1494 if (mDebugLevelBumpPendingBuffers[portIndex]) { 1495 --mDebugLevelBumpPendingBuffers[portIndex]; 1496 } 1497 if (!mDebugLevelBumpPendingBuffers[0] 1498 && !mDebugLevelBumpPendingBuffers[1]) { 1499 DEBUG_BUMP = DEBUG; 1500 } 1501} 1502 1503status_t OMXNodeInstance::storeFenceInMeta_l( 1504 OMX_BUFFERHEADERTYPE *header, int fenceFd, OMX_U32 portIndex) { 1505 // propagate fence if component supports it; wait for it otherwise 1506 OMX_U32 metaSize = portIndex == kPortIndexInput ? header->nFilledLen : header->nAllocLen; 1507 if (mMetadataType[portIndex] == kMetadataBufferTypeANWBuffer 1508 && metaSize >= sizeof(VideoNativeMetadata)) { 1509 VideoNativeMetadata &nativeMeta = *(VideoNativeMetadata *)(header->pBuffer); 1510 if (nativeMeta.nFenceFd >= 0) { 1511 ALOGE("fence (%d) already exists in meta", nativeMeta.nFenceFd); 1512 if (fenceFd >= 0) { 1513 ::close(fenceFd); 1514 } 1515 return ALREADY_EXISTS; 1516 } 1517 nativeMeta.nFenceFd = fenceFd; 1518 } else if (fenceFd >= 0) { 1519 CLOG_BUFFER(storeFenceInMeta, "waiting for fence %d", fenceFd); 1520 sp<Fence> fence = new Fence(fenceFd); 1521 return fence->wait(IOMX::kFenceTimeoutMs); 1522 } 1523 return OK; 1524} 1525 1526int OMXNodeInstance::retrieveFenceFromMeta_l( 1527 OMX_BUFFERHEADERTYPE *header, OMX_U32 portIndex) { 1528 OMX_U32 metaSize = portIndex == kPortIndexInput ? header->nAllocLen : header->nFilledLen; 1529 int fenceFd = -1; 1530 if (mMetadataType[portIndex] == kMetadataBufferTypeANWBuffer 1531 && header->nAllocLen >= sizeof(VideoNativeMetadata)) { 1532 VideoNativeMetadata &nativeMeta = *(VideoNativeMetadata *)(header->pBuffer); 1533 if (nativeMeta.eType == kMetadataBufferTypeANWBuffer) { 1534 fenceFd = nativeMeta.nFenceFd; 1535 nativeMeta.nFenceFd = -1; 1536 } 1537 if (metaSize < sizeof(nativeMeta) && fenceFd >= 0) { 1538 CLOG_ERROR(foundFenceInEmptyMeta, BAD_VALUE, FULL_BUFFER( 1539 NULL, header, nativeMeta.nFenceFd)); 1540 fenceFd = -1; 1541 } 1542 } 1543 return fenceFd; 1544} 1545 1546status_t OMXNodeInstance::emptyBuffer_l( 1547 OMX_BUFFERHEADERTYPE *header, OMX_U32 flags, OMX_TICKS timestamp, 1548 intptr_t debugAddr, int fenceFd) { 1549 header->nFlags = flags; 1550 header->nTimeStamp = timestamp; 1551 1552 status_t res = storeFenceInMeta_l(header, fenceFd, kPortIndexInput); 1553 if (res != OK) { 1554 CLOG_ERROR(emptyBuffer::storeFenceInMeta, res, WITH_STATS( 1555 FULL_BUFFER(debugAddr, header, fenceFd))); 1556 return res; 1557 } 1558 1559 { 1560 Mutex::Autolock _l(mDebugLock); 1561 mInputBuffersWithCodec.add(header); 1562 1563 // bump internal-state debug level for 2 input frames past a buffer with CSD 1564 if ((flags & OMX_BUFFERFLAG_CODECCONFIG) != 0) { 1565 bumpDebugLevel_l(2 /* numInputBuffers */, 0 /* numOutputBuffers */); 1566 } 1567 1568 CLOG_BUMPED_BUFFER(emptyBuffer, WITH_STATS(FULL_BUFFER(debugAddr, header, fenceFd))); 1569 } 1570 1571 OMX_ERRORTYPE err = OMX_EmptyThisBuffer(mHandle, header); 1572 CLOG_IF_ERROR(emptyBuffer, err, FULL_BUFFER(debugAddr, header, fenceFd)); 1573 1574 { 1575 Mutex::Autolock _l(mDebugLock); 1576 if (err != OMX_ErrorNone) { 1577 mInputBuffersWithCodec.remove(header); 1578 } else if (!(flags & OMX_BUFFERFLAG_CODECCONFIG)) { 1579 unbumpDebugLevel_l(kPortIndexInput); 1580 } 1581 } 1582 1583 return StatusFromOMXError(err); 1584} 1585 1586// like emptyBuffer, but the data is already in header->pBuffer 1587status_t OMXNodeInstance::emptyGraphicBuffer( 1588 OMX_BUFFERHEADERTYPE *header, const sp<GraphicBuffer> &graphicBuffer, 1589 OMX_U32 flags, OMX_TICKS timestamp, int fenceFd) { 1590 if (header == NULL) { 1591 ALOGE("b/25884056"); 1592 return BAD_VALUE; 1593 } 1594 1595 Mutex::Autolock autoLock(mLock); 1596 OMX::buffer_id buffer = findBufferID(header); 1597 status_t err = updateGraphicBufferInMeta_l( 1598 kPortIndexInput, graphicBuffer, buffer, header, 1599 true /* updateCodecBuffer */); 1600 if (err != OK) { 1601 CLOG_ERROR(emptyGraphicBuffer, err, FULL_BUFFER( 1602 (intptr_t)header->pBuffer, header, fenceFd)); 1603 return err; 1604 } 1605 1606 header->nOffset = 0; 1607 if (graphicBuffer == NULL) { 1608 header->nFilledLen = 0; 1609 } else if (mMetadataType[kPortIndexInput] == kMetadataBufferTypeGrallocSource) { 1610 header->nFilledLen = sizeof(VideoGrallocMetadata); 1611 } else { 1612 header->nFilledLen = sizeof(VideoNativeMetadata); 1613 } 1614 return emptyBuffer_l(header, flags, timestamp, (intptr_t)header->pBuffer, fenceFd); 1615} 1616 1617status_t OMXNodeInstance::getExtensionIndex( 1618 const char *parameterName, OMX_INDEXTYPE *index) { 1619 Mutex::Autolock autoLock(mLock); 1620 1621 OMX_ERRORTYPE err = OMX_GetExtensionIndex( 1622 mHandle, const_cast<char *>(parameterName), index); 1623 1624 return StatusFromOMXError(err); 1625} 1626 1627inline static const char *asString(IOMX::InternalOptionType i, const char *def = "??") { 1628 switch (i) { 1629 case IOMX::INTERNAL_OPTION_SUSPEND: return "SUSPEND"; 1630 case IOMX::INTERNAL_OPTION_REPEAT_PREVIOUS_FRAME_DELAY: 1631 return "REPEAT_PREVIOUS_FRAME_DELAY"; 1632 case IOMX::INTERNAL_OPTION_MAX_TIMESTAMP_GAP: return "MAX_TIMESTAMP_GAP"; 1633 case IOMX::INTERNAL_OPTION_MAX_FPS: return "MAX_FPS"; 1634 case IOMX::INTERNAL_OPTION_START_TIME: return "START_TIME"; 1635 case IOMX::INTERNAL_OPTION_TIME_LAPSE: return "TIME_LAPSE"; 1636 case IOMX::INTERNAL_OPTION_TIME_OFFSET: return "TIME_OFFSET"; 1637 default: return def; 1638 } 1639} 1640 1641template<typename T> 1642static bool getInternalOption( 1643 const void *data, size_t size, T *out) { 1644 if (size != sizeof(T)) { 1645 return false; 1646 } 1647 *out = *(T*)data; 1648 return true; 1649} 1650 1651status_t OMXNodeInstance::setInternalOption( 1652 OMX_U32 portIndex, 1653 IOMX::InternalOptionType type, 1654 const void *data, 1655 size_t size) { 1656 CLOG_CONFIG(setInternalOption, "%s(%d): %s:%u %zu@%p", 1657 asString(type), type, portString(portIndex), portIndex, size, data); 1658 switch (type) { 1659 case IOMX::INTERNAL_OPTION_SUSPEND: 1660 case IOMX::INTERNAL_OPTION_REPEAT_PREVIOUS_FRAME_DELAY: 1661 case IOMX::INTERNAL_OPTION_MAX_TIMESTAMP_GAP: 1662 case IOMX::INTERNAL_OPTION_MAX_FPS: 1663 case IOMX::INTERNAL_OPTION_START_TIME: 1664 case IOMX::INTERNAL_OPTION_TIME_LAPSE: 1665 case IOMX::INTERNAL_OPTION_TIME_OFFSET: 1666 case IOMX::INTERNAL_OPTION_COLOR_ASPECTS: 1667 { 1668 const sp<GraphicBufferSource> &bufferSource = 1669 getGraphicBufferSource(); 1670 1671 if (bufferSource == NULL || portIndex != kPortIndexInput) { 1672 CLOGW("setInternalOption is only for Surface input"); 1673 return ERROR_UNSUPPORTED; 1674 } 1675 1676 if (type == IOMX::INTERNAL_OPTION_SUSPEND) { 1677 bool suspend; 1678 if (!getInternalOption(data, size, &suspend)) { 1679 return INVALID_OPERATION; 1680 } 1681 1682 CLOG_CONFIG(setInternalOption, "suspend=%d", suspend); 1683 bufferSource->suspend(suspend); 1684 } else if (type == IOMX::INTERNAL_OPTION_REPEAT_PREVIOUS_FRAME_DELAY) { 1685 int64_t delayUs; 1686 if (!getInternalOption(data, size, &delayUs)) { 1687 return INVALID_OPERATION; 1688 } 1689 1690 CLOG_CONFIG(setInternalOption, "delayUs=%lld", (long long)delayUs); 1691 return bufferSource->setRepeatPreviousFrameDelayUs(delayUs); 1692 } else if (type == IOMX::INTERNAL_OPTION_TIME_OFFSET) { 1693 int64_t timeOffsetUs; 1694 if (!getInternalOption(data, size, &timeOffsetUs)) { 1695 return INVALID_OPERATION; 1696 } 1697 CLOG_CONFIG(setInternalOption, "bufferOffsetUs=%lld", (long long)timeOffsetUs); 1698 return bufferSource->setInputBufferTimeOffset(timeOffsetUs); 1699 } else if (type == IOMX::INTERNAL_OPTION_MAX_TIMESTAMP_GAP) { 1700 int64_t maxGapUs; 1701 if (!getInternalOption(data, size, &maxGapUs)) { 1702 return INVALID_OPERATION; 1703 } 1704 1705 CLOG_CONFIG(setInternalOption, "gapUs=%lld", (long long)maxGapUs); 1706 return bufferSource->setMaxTimestampGapUs(maxGapUs); 1707 } else if (type == IOMX::INTERNAL_OPTION_MAX_FPS) { 1708 float maxFps; 1709 if (!getInternalOption(data, size, &maxFps)) { 1710 return INVALID_OPERATION; 1711 } 1712 1713 CLOG_CONFIG(setInternalOption, "maxFps=%f", maxFps); 1714 return bufferSource->setMaxFps(maxFps); 1715 } else if (type == IOMX::INTERNAL_OPTION_START_TIME) { 1716 int64_t skipFramesBeforeUs; 1717 if (!getInternalOption(data, size, &skipFramesBeforeUs)) { 1718 return INVALID_OPERATION; 1719 } 1720 1721 CLOG_CONFIG(setInternalOption, "beforeUs=%lld", (long long)skipFramesBeforeUs); 1722 bufferSource->setSkipFramesBeforeUs(skipFramesBeforeUs); 1723 } else if (type == IOMX::INTERNAL_OPTION_TIME_LAPSE) { 1724 GraphicBufferSource::TimeLapseConfig config; 1725 if (!getInternalOption(data, size, &config)) { 1726 return INVALID_OPERATION; 1727 } 1728 1729 CLOG_CONFIG(setInternalOption, "perFrameUs=%lld perCaptureUs=%lld", 1730 (long long)config.mTimePerFrameUs, (long long)config.mTimePerCaptureUs); 1731 1732 return bufferSource->setTimeLapseConfig(config); 1733 } else if (type == IOMX::INTERNAL_OPTION_COLOR_ASPECTS) { 1734 ColorAspects aspects; 1735 if (!getInternalOption(data, size, &aspects)) { 1736 return INVALID_OPERATION; 1737 } 1738 1739 CLOG_CONFIG(setInternalOption, "setting color aspects"); 1740 bufferSource->setColorAspects(aspects); 1741 } 1742 1743 return OK; 1744 } 1745 1746 default: 1747 return ERROR_UNSUPPORTED; 1748 } 1749} 1750 1751bool OMXNodeInstance::handleMessage(omx_message &msg) { 1752 const sp<GraphicBufferSource>& bufferSource(getGraphicBufferSource()); 1753 1754 if (msg.type == omx_message::FILL_BUFFER_DONE) { 1755 OMX_BUFFERHEADERTYPE *buffer = 1756 findBufferHeader(msg.u.extended_buffer_data.buffer, kPortIndexOutput); 1757 if (buffer == NULL) { 1758 ALOGE("b/25884056"); 1759 return false; 1760 } 1761 1762 { 1763 Mutex::Autolock _l(mDebugLock); 1764 mOutputBuffersWithCodec.remove(buffer); 1765 1766 CLOG_BUMPED_BUFFER( 1767 FBD, WITH_STATS(FULL_BUFFER( 1768 msg.u.extended_buffer_data.buffer, buffer, msg.fenceFd))); 1769 1770 unbumpDebugLevel_l(kPortIndexOutput); 1771 } 1772 1773 BufferMeta *buffer_meta = 1774 static_cast<BufferMeta *>(buffer->pAppPrivate); 1775 1776 if (buffer->nOffset + buffer->nFilledLen < buffer->nOffset 1777 || buffer->nOffset + buffer->nFilledLen > buffer->nAllocLen) { 1778 CLOG_ERROR(onFillBufferDone, OMX_ErrorBadParameter, 1779 FULL_BUFFER(NULL, buffer, msg.fenceFd)); 1780 } 1781 buffer_meta->CopyFromOMX(buffer); 1782 1783 if (bufferSource != NULL) { 1784 // fix up the buffer info (especially timestamp) if needed 1785 bufferSource->codecBufferFilled(buffer); 1786 1787 msg.u.extended_buffer_data.timestamp = buffer->nTimeStamp; 1788 } 1789 } else if (msg.type == omx_message::EMPTY_BUFFER_DONE) { 1790 OMX_BUFFERHEADERTYPE *buffer = 1791 findBufferHeader(msg.u.buffer_data.buffer, kPortIndexInput); 1792 if (buffer == NULL) { 1793 return false; 1794 } 1795 1796 { 1797 Mutex::Autolock _l(mDebugLock); 1798 mInputBuffersWithCodec.remove(buffer); 1799 1800 CLOG_BUMPED_BUFFER( 1801 EBD, WITH_STATS(EMPTY_BUFFER(msg.u.buffer_data.buffer, buffer, msg.fenceFd))); 1802 } 1803 1804 if (bufferSource != NULL) { 1805 // This is one of the buffers used exclusively by 1806 // GraphicBufferSource. 1807 // Don't dispatch a message back to ACodec, since it doesn't 1808 // know that anyone asked to have the buffer emptied and will 1809 // be very confused. 1810 bufferSource->codecBufferEmptied(buffer, msg.fenceFd); 1811 return true; 1812 } 1813 } 1814 1815 return false; 1816} 1817 1818void OMXNodeInstance::onMessages(std::list<omx_message> &messages) { 1819 for (std::list<omx_message>::iterator it = messages.begin(); it != messages.end(); ) { 1820 if (handleMessage(*it)) { 1821 messages.erase(it++); 1822 } else { 1823 ++it; 1824 } 1825 } 1826 1827 if (!messages.empty()) { 1828 mObserver->onMessages(messages); 1829 } 1830} 1831 1832void OMXNodeInstance::onObserverDied(OMXMaster *master) { 1833 ALOGE("!!! Observer died. Quickly, do something, ... anything..."); 1834 1835 // Try to force shutdown of the node and hope for the best. 1836 freeNode(master); 1837} 1838 1839void OMXNodeInstance::onGetHandleFailed() { 1840 delete this; 1841} 1842 1843// OMXNodeInstance::OnEvent calls OMX::OnEvent, which then calls here. 1844// Don't try to acquire mLock here -- in rare circumstances this will hang. 1845void OMXNodeInstance::onEvent( 1846 OMX_EVENTTYPE event, OMX_U32 arg1, OMX_U32 arg2) { 1847 const char *arg1String = "??"; 1848 const char *arg2String = "??"; 1849 ADebug::Level level = ADebug::kDebugInternalState; 1850 1851 switch (event) { 1852 case OMX_EventCmdComplete: 1853 arg1String = asString((OMX_COMMANDTYPE)arg1); 1854 switch (arg1) { 1855 case OMX_CommandStateSet: 1856 arg2String = asString((OMX_STATETYPE)arg2); 1857 level = ADebug::kDebugState; 1858 break; 1859 case OMX_CommandFlush: 1860 case OMX_CommandPortEnable: 1861 { 1862 // bump internal-state debug level for 2 input and output frames 1863 Mutex::Autolock _l(mDebugLock); 1864 bumpDebugLevel_l(2 /* numInputBuffers */, 2 /* numOutputBuffers */); 1865 } 1866 // fall through 1867 default: 1868 arg2String = portString(arg2); 1869 } 1870 break; 1871 case OMX_EventError: 1872 arg1String = asString((OMX_ERRORTYPE)arg1); 1873 level = ADebug::kDebugLifeCycle; 1874 break; 1875 case OMX_EventPortSettingsChanged: 1876 arg2String = asString((OMX_INDEXEXTTYPE)arg2); 1877 // fall through 1878 default: 1879 arg1String = portString(arg1); 1880 } 1881 1882 CLOGI_(level, onEvent, "%s(%x), %s(%x), %s(%x)", 1883 asString(event), event, arg1String, arg1, arg2String, arg2); 1884 const sp<GraphicBufferSource>& bufferSource(getGraphicBufferSource()); 1885 1886 if (bufferSource != NULL 1887 && event == OMX_EventCmdComplete 1888 && arg1 == OMX_CommandStateSet 1889 && arg2 == OMX_StateExecuting) { 1890 bufferSource->omxExecuting(); 1891 } 1892 1893 // allow configuration if we return to the loaded state 1894 if (event == OMX_EventCmdComplete 1895 && arg1 == OMX_CommandStateSet 1896 && arg2 == OMX_StateLoaded) { 1897 mSailed = false; 1898 } 1899} 1900 1901// static 1902OMX_ERRORTYPE OMXNodeInstance::OnEvent( 1903 OMX_IN OMX_HANDLETYPE /* hComponent */, 1904 OMX_IN OMX_PTR pAppData, 1905 OMX_IN OMX_EVENTTYPE eEvent, 1906 OMX_IN OMX_U32 nData1, 1907 OMX_IN OMX_U32 nData2, 1908 OMX_IN OMX_PTR pEventData) { 1909 if (pAppData == NULL) { 1910 ALOGE("b/25884056"); 1911 return OMX_ErrorBadParameter; 1912 } 1913 OMXNodeInstance *instance = static_cast<OMXNodeInstance *>(pAppData); 1914 if (instance->mDying) { 1915 return OMX_ErrorNone; 1916 } 1917 return instance->owner()->OnEvent( 1918 instance->nodeID(), eEvent, nData1, nData2, pEventData); 1919} 1920 1921// static 1922OMX_ERRORTYPE OMXNodeInstance::OnEmptyBufferDone( 1923 OMX_IN OMX_HANDLETYPE /* hComponent */, 1924 OMX_IN OMX_PTR pAppData, 1925 OMX_IN OMX_BUFFERHEADERTYPE* pBuffer) { 1926 if (pAppData == NULL) { 1927 ALOGE("b/25884056"); 1928 return OMX_ErrorBadParameter; 1929 } 1930 OMXNodeInstance *instance = static_cast<OMXNodeInstance *>(pAppData); 1931 if (instance->mDying) { 1932 return OMX_ErrorNone; 1933 } 1934 int fenceFd = instance->retrieveFenceFromMeta_l(pBuffer, kPortIndexOutput); 1935 return instance->owner()->OnEmptyBufferDone(instance->nodeID(), 1936 instance->findBufferID(pBuffer), pBuffer, fenceFd); 1937} 1938 1939// static 1940OMX_ERRORTYPE OMXNodeInstance::OnFillBufferDone( 1941 OMX_IN OMX_HANDLETYPE /* hComponent */, 1942 OMX_IN OMX_PTR pAppData, 1943 OMX_IN OMX_BUFFERHEADERTYPE* pBuffer) { 1944 if (pAppData == NULL) { 1945 ALOGE("b/25884056"); 1946 return OMX_ErrorBadParameter; 1947 } 1948 OMXNodeInstance *instance = static_cast<OMXNodeInstance *>(pAppData); 1949 if (instance->mDying) { 1950 return OMX_ErrorNone; 1951 } 1952 int fenceFd = instance->retrieveFenceFromMeta_l(pBuffer, kPortIndexOutput); 1953 return instance->owner()->OnFillBufferDone(instance->nodeID(), 1954 instance->findBufferID(pBuffer), pBuffer, fenceFd); 1955} 1956 1957void OMXNodeInstance::addActiveBuffer(OMX_U32 portIndex, OMX::buffer_id id) { 1958 ActiveBuffer active; 1959 active.mPortIndex = portIndex; 1960 active.mID = id; 1961 mActiveBuffers.push(active); 1962 1963 if (portIndex < NELEM(mNumPortBuffers)) { 1964 ++mNumPortBuffers[portIndex]; 1965 } 1966} 1967 1968void OMXNodeInstance::removeActiveBuffer( 1969 OMX_U32 portIndex, OMX::buffer_id id) { 1970 for (size_t i = 0; i < mActiveBuffers.size(); ++i) { 1971 if (mActiveBuffers[i].mPortIndex == portIndex 1972 && mActiveBuffers[i].mID == id) { 1973 mActiveBuffers.removeItemsAt(i); 1974 1975 if (portIndex < NELEM(mNumPortBuffers)) { 1976 --mNumPortBuffers[portIndex]; 1977 } 1978 return; 1979 } 1980 } 1981 1982 CLOGW("Attempt to remove an active buffer [%#x] we know nothing about...", id); 1983} 1984 1985void OMXNodeInstance::freeActiveBuffers() { 1986 // Make sure to count down here, as freeBuffer will in turn remove 1987 // the active buffer from the vector... 1988 for (size_t i = mActiveBuffers.size(); i > 0;) { 1989 i--; 1990 freeBuffer(mActiveBuffers[i].mPortIndex, mActiveBuffers[i].mID); 1991 } 1992} 1993 1994OMX::buffer_id OMXNodeInstance::makeBufferID(OMX_BUFFERHEADERTYPE *bufferHeader) { 1995 if (bufferHeader == NULL) { 1996 return 0; 1997 } 1998 Mutex::Autolock autoLock(mBufferIDLock); 1999 OMX::buffer_id buffer; 2000 do { // handle the very unlikely case of ID overflow 2001 if (++mBufferIDCount == 0) { 2002 ++mBufferIDCount; 2003 } 2004 buffer = (OMX::buffer_id)mBufferIDCount; 2005 } while (mBufferIDToBufferHeader.indexOfKey(buffer) >= 0); 2006 mBufferIDToBufferHeader.add(buffer, bufferHeader); 2007 mBufferHeaderToBufferID.add(bufferHeader, buffer); 2008 return buffer; 2009} 2010 2011OMX_BUFFERHEADERTYPE *OMXNodeInstance::findBufferHeader( 2012 OMX::buffer_id buffer, OMX_U32 portIndex) { 2013 if (buffer == 0) { 2014 return NULL; 2015 } 2016 Mutex::Autolock autoLock(mBufferIDLock); 2017 ssize_t index = mBufferIDToBufferHeader.indexOfKey(buffer); 2018 if (index < 0) { 2019 CLOGW("findBufferHeader: buffer %u not found", buffer); 2020 return NULL; 2021 } 2022 OMX_BUFFERHEADERTYPE *header = mBufferIDToBufferHeader.valueAt(index); 2023 BufferMeta *buffer_meta = 2024 static_cast<BufferMeta *>(header->pAppPrivate); 2025 if (buffer_meta->getPortIndex() != portIndex) { 2026 CLOGW("findBufferHeader: buffer %u found but with incorrect port index.", buffer); 2027 android_errorWriteLog(0x534e4554, "28816827"); 2028 return NULL; 2029 } 2030 return header; 2031} 2032 2033OMX::buffer_id OMXNodeInstance::findBufferID(OMX_BUFFERHEADERTYPE *bufferHeader) { 2034 if (bufferHeader == NULL) { 2035 return 0; 2036 } 2037 Mutex::Autolock autoLock(mBufferIDLock); 2038 ssize_t index = mBufferHeaderToBufferID.indexOfKey(bufferHeader); 2039 if (index < 0) { 2040 CLOGW("findBufferID: bufferHeader %p not found", bufferHeader); 2041 return 0; 2042 } 2043 return mBufferHeaderToBufferID.valueAt(index); 2044} 2045 2046void OMXNodeInstance::invalidateBufferID(OMX::buffer_id buffer) { 2047 if (buffer == 0) { 2048 return; 2049 } 2050 Mutex::Autolock autoLock(mBufferIDLock); 2051 ssize_t index = mBufferIDToBufferHeader.indexOfKey(buffer); 2052 if (index < 0) { 2053 CLOGW("invalidateBufferID: buffer %u not found", buffer); 2054 return; 2055 } 2056 mBufferHeaderToBufferID.removeItem(mBufferIDToBufferHeader.valueAt(index)); 2057 mBufferIDToBufferHeader.removeItemsAt(index); 2058} 2059 2060} // namespace android 2061