OMXNodeInstance.cpp revision 79608158c2254fe1357959157f2d0c1560a8a6c6
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 "GraphicBufferSource.h" 26 27#include <OMX_Component.h> 28#include <OMX_IndexExt.h> 29#include <OMX_AsString.h> 30 31#include <binder/IMemory.h> 32#include <gui/BufferQueue.h> 33#include <HardwareAPI.h> 34#include <media/stagefright/foundation/ADebug.h> 35#include <media/stagefright/MediaErrors.h> 36 37#include <utils/misc.h> 38 39static const OMX_U32 kPortIndexInput = 0; 40static const OMX_U32 kPortIndexOutput = 1; 41 42#define CLOGW(fmt, ...) ALOGW("[%x:%s] " fmt, mNodeID, mName, ##__VA_ARGS__) 43 44#define CLOG_ERROR_IF(cond, fn, err, fmt, ...) \ 45 ALOGE_IF(cond, #fn "(%x:%s, " fmt ") ERROR: %s(%#x)", \ 46 mNodeID, mName, ##__VA_ARGS__, asString(err), err) 47#define CLOG_ERROR(fn, err, fmt, ...) CLOG_ERROR_IF(true, fn, err, fmt, ##__VA_ARGS__) 48#define CLOG_IF_ERROR(fn, err, fmt, ...) \ 49 CLOG_ERROR_IF((err) != OMX_ErrorNone, fn, err, fmt, ##__VA_ARGS__) 50 51#define CLOGI_(level, fn, fmt, ...) \ 52 ALOGI_IF(DEBUG >= (level), #fn "(%x:%s, " fmt ")", mNodeID, mName, ##__VA_ARGS__) 53#define CLOGD_(level, fn, fmt, ...) \ 54 ALOGD_IF(DEBUG >= (level), #fn "(%x:%s, " fmt ")", mNodeID, mName, ##__VA_ARGS__) 55 56#define CLOG_LIFE(fn, fmt, ...) CLOGI_(ADebug::kDebugLifeCycle, fn, fmt, ##__VA_ARGS__) 57#define CLOG_STATE(fn, fmt, ...) CLOGI_(ADebug::kDebugState, fn, fmt, ##__VA_ARGS__) 58#define CLOG_CONFIG(fn, fmt, ...) CLOGI_(ADebug::kDebugConfig, fn, fmt, ##__VA_ARGS__) 59#define CLOG_INTERNAL(fn, fmt, ...) CLOGD_(ADebug::kDebugInternalState, fn, fmt, ##__VA_ARGS__) 60 61#define CLOG_DEBUG_IF(cond, fn, fmt, ...) \ 62 ALOGD_IF(cond, #fn "(%x, " fmt ")", mNodeID, ##__VA_ARGS__) 63 64#define CLOG_BUFFER(fn, fmt, ...) \ 65 CLOG_DEBUG_IF(DEBUG >= ADebug::kDebugAll, fn, fmt, ##__VA_ARGS__) 66#define CLOG_BUMPED_BUFFER(fn, fmt, ...) \ 67 CLOG_DEBUG_IF(DEBUG_BUMP >= ADebug::kDebugAll, fn, fmt, ##__VA_ARGS__) 68 69/* buffer formatting */ 70#define BUFFER_FMT(port, fmt, ...) "%s:%u " fmt, portString(port), (port), ##__VA_ARGS__ 71#define NEW_BUFFER_FMT(buffer_id, port, fmt, ...) \ 72 BUFFER_FMT(port, fmt ") (#%zu => %#x", ##__VA_ARGS__, mActiveBuffers.size(), (buffer_id)) 73 74#define SIMPLE_BUFFER(port, size, data) BUFFER_FMT(port, "%zu@%p", (size), (data)) 75#define SIMPLE_NEW_BUFFER(buffer_id, port, size, data) \ 76 NEW_BUFFER_FMT(buffer_id, port, "%zu@%p", (size), (data)) 77 78#define EMPTY_BUFFER(addr, header) "%#x [%u@%p]", \ 79 (addr), (header)->nAllocLen, (header)->pBuffer 80#define FULL_BUFFER(addr, header) "%#" PRIxPTR " [%u@%p (%u..+%u) f=%x ts=%lld]", \ 81 (intptr_t)(addr), (header)->nAllocLen, (header)->pBuffer, \ 82 (header)->nOffset, (header)->nFilledLen, (header)->nFlags, (header)->nTimeStamp 83 84#define WITH_STATS_WRAPPER(fmt, ...) fmt " { IN=%zu/%zu OUT=%zu/%zu }", ##__VA_ARGS__, \ 85 mInputBuffersWithCodec.size(), mNumPortBuffers[kPortIndexInput], \ 86 mOutputBuffersWithCodec.size(), mNumPortBuffers[kPortIndexOutput] 87// TRICKY: this is needed so formatting macros expand before substitution 88#define WITH_STATS(fmt, ...) WITH_STATS_WRAPPER(fmt, ##__VA_ARGS__) 89 90template<class T> 91static void InitOMXParams(T *params) { 92 memset(params, 0, sizeof(T)); 93 params->nSize = sizeof(T); 94 params->nVersion.s.nVersionMajor = 1; 95 params->nVersion.s.nVersionMinor = 0; 96 params->nVersion.s.nRevision = 0; 97 params->nVersion.s.nStep = 0; 98} 99 100namespace android { 101 102struct BufferMeta { 103 BufferMeta(const sp<IMemory> &mem, bool is_backup = false) 104 : mMem(mem), 105 mIsBackup(is_backup) { 106 } 107 108 BufferMeta(size_t size) 109 : mSize(size), 110 mIsBackup(false) { 111 } 112 113 BufferMeta(const sp<GraphicBuffer> &graphicBuffer) 114 : mGraphicBuffer(graphicBuffer), 115 mIsBackup(false) { 116 } 117 118 void CopyFromOMX(const OMX_BUFFERHEADERTYPE *header) { 119 if (!mIsBackup) { 120 return; 121 } 122 123 memcpy((OMX_U8 *)mMem->pointer() + header->nOffset, 124 header->pBuffer + header->nOffset, 125 header->nFilledLen); 126 } 127 128 void CopyToOMX(const OMX_BUFFERHEADERTYPE *header) { 129 if (!mIsBackup) { 130 return; 131 } 132 133 memcpy(header->pBuffer + header->nOffset, 134 (const OMX_U8 *)mMem->pointer() + header->nOffset, 135 header->nFilledLen); 136 } 137 138 void setGraphicBuffer(const sp<GraphicBuffer> &graphicBuffer) { 139 mGraphicBuffer = graphicBuffer; 140 } 141 142private: 143 sp<GraphicBuffer> mGraphicBuffer; 144 sp<IMemory> mMem; 145 size_t mSize; 146 bool mIsBackup; 147 148 BufferMeta(const BufferMeta &); 149 BufferMeta &operator=(const BufferMeta &); 150}; 151 152// static 153OMX_CALLBACKTYPE OMXNodeInstance::kCallbacks = { 154 &OnEvent, &OnEmptyBufferDone, &OnFillBufferDone 155}; 156 157static inline const char *portString(OMX_U32 portIndex) { 158 switch (portIndex) { 159 case kPortIndexInput: return "Input"; 160 case kPortIndexOutput: return "Output"; 161 case ~0U: return "All"; 162 default: return "port"; 163 } 164} 165 166OMXNodeInstance::OMXNodeInstance( 167 OMX *owner, const sp<IOMXObserver> &observer, const char *name) 168 : mOwner(owner), 169 mNodeID(0), 170 mHandle(NULL), 171 mObserver(observer), 172 mDying(false) 173#ifdef __LP64__ 174 , mBufferIDCount(0) 175#endif 176{ 177 mName = ADebug::GetDebugName(name); 178 DEBUG = ADebug::GetDebugLevelFromProperty(name, "debug.stagefright.omx-debug"); 179 ALOGV("debug level for %s is %d", name, DEBUG); 180 DEBUG_BUMP = DEBUG; 181 mNumPortBuffers[0] = 0; 182 mNumPortBuffers[1] = 0; 183 mDebugLevelBumpPendingBuffers[0] = 0; 184 mDebugLevelBumpPendingBuffers[1] = 0; 185} 186 187OMXNodeInstance::~OMXNodeInstance() { 188 free(mName); 189 CHECK(mHandle == NULL); 190} 191 192void OMXNodeInstance::setHandle(OMX::node_id node_id, OMX_HANDLETYPE handle) { 193 mNodeID = node_id; 194 CLOG_LIFE(allocateNode, "handle=%p", handle); 195 CHECK(mHandle == NULL); 196 mHandle = handle; 197} 198 199sp<GraphicBufferSource> OMXNodeInstance::getGraphicBufferSource() { 200 Mutex::Autolock autoLock(mGraphicBufferSourceLock); 201 return mGraphicBufferSource; 202} 203 204void OMXNodeInstance::setGraphicBufferSource( 205 const sp<GraphicBufferSource>& bufferSource) { 206 Mutex::Autolock autoLock(mGraphicBufferSourceLock); 207 CLOG_INTERNAL(setGraphicBufferSource, "%p", bufferSource.get()); 208 mGraphicBufferSource = bufferSource; 209} 210 211OMX *OMXNodeInstance::owner() { 212 return mOwner; 213} 214 215sp<IOMXObserver> OMXNodeInstance::observer() { 216 return mObserver; 217} 218 219OMX::node_id OMXNodeInstance::nodeID() { 220 return mNodeID; 221} 222 223status_t StatusFromOMXError(OMX_ERRORTYPE err) { 224 switch (err) { 225 case OMX_ErrorNone: 226 return OK; 227 case OMX_ErrorUnsupportedSetting: 228 case OMX_ErrorUnsupportedIndex: 229 return ERROR_UNSUPPORTED; 230 case OMX_ErrorInsufficientResources: 231 return NO_MEMORY; 232 default: 233 return UNKNOWN_ERROR; 234 } 235} 236 237status_t OMXNodeInstance::freeNode(OMXMaster *master) { 238 CLOG_LIFE(freeNode, "handle=%p", mHandle); 239 static int32_t kMaxNumIterations = 10; 240 241 // exit if we have already freed the node 242 if (mHandle == NULL) { 243 return OK; 244 } 245 246 // Transition the node from its current state all the way down 247 // to "Loaded". 248 // This ensures that all active buffers are properly freed even 249 // for components that don't do this themselves on a call to 250 // "FreeHandle". 251 252 // The code below may trigger some more events to be dispatched 253 // by the OMX component - we want to ignore them as our client 254 // does not expect them. 255 mDying = true; 256 257 OMX_STATETYPE state; 258 CHECK_EQ(OMX_GetState(mHandle, &state), OMX_ErrorNone); 259 switch (state) { 260 case OMX_StateExecuting: 261 { 262 ALOGV("forcing Executing->Idle"); 263 sendCommand(OMX_CommandStateSet, OMX_StateIdle); 264 OMX_ERRORTYPE err; 265 int32_t iteration = 0; 266 while ((err = OMX_GetState(mHandle, &state)) == OMX_ErrorNone 267 && state != OMX_StateIdle 268 && state != OMX_StateInvalid) { 269 if (++iteration > kMaxNumIterations) { 270 CLOGW("failed to enter Idle state (now %s(%d), aborting.", 271 asString(state), state); 272 state = OMX_StateInvalid; 273 break; 274 } 275 276 usleep(100000); 277 } 278 CHECK_EQ(err, OMX_ErrorNone); 279 280 if (state == OMX_StateInvalid) { 281 break; 282 } 283 284 // fall through 285 } 286 287 case OMX_StateIdle: 288 { 289 ALOGV("forcing Idle->Loaded"); 290 sendCommand(OMX_CommandStateSet, OMX_StateLoaded); 291 292 freeActiveBuffers(); 293 294 OMX_ERRORTYPE err; 295 int32_t iteration = 0; 296 while ((err = OMX_GetState(mHandle, &state)) == OMX_ErrorNone 297 && state != OMX_StateLoaded 298 && state != OMX_StateInvalid) { 299 if (++iteration > kMaxNumIterations) { 300 CLOGW("failed to enter Loaded state (now %s(%d), aborting.", 301 asString(state), state); 302 state = OMX_StateInvalid; 303 break; 304 } 305 306 ALOGV("waiting for Loaded state..."); 307 usleep(100000); 308 } 309 CHECK_EQ(err, OMX_ErrorNone); 310 311 // fall through 312 } 313 314 case OMX_StateLoaded: 315 case OMX_StateInvalid: 316 break; 317 318 default: 319 LOG_ALWAYS_FATAL("unknown state %s(%#x).", asString(state), state); 320 break; 321 } 322 323 ALOGV("[%x:%s] calling destroyComponentInstance", mNodeID, mName); 324 OMX_ERRORTYPE err = master->destroyComponentInstance( 325 static_cast<OMX_COMPONENTTYPE *>(mHandle)); 326 327 mHandle = NULL; 328 CLOG_IF_ERROR(freeNode, err, ""); 329 free(mName); 330 mName = NULL; 331 332 mOwner->invalidateNodeID(mNodeID); 333 mNodeID = 0; 334 335 ALOGV("OMXNodeInstance going away."); 336 delete this; 337 338 return StatusFromOMXError(err); 339} 340 341status_t OMXNodeInstance::sendCommand( 342 OMX_COMMANDTYPE cmd, OMX_S32 param) { 343 const sp<GraphicBufferSource>& bufferSource(getGraphicBufferSource()); 344 if (bufferSource != NULL && cmd == OMX_CommandStateSet) { 345 if (param == OMX_StateIdle) { 346 // Initiating transition from Executing -> Idle 347 // ACodec is waiting for all buffers to be returned, do NOT 348 // submit any more buffers to the codec. 349 bufferSource->omxIdle(); 350 } else if (param == OMX_StateLoaded) { 351 // Initiating transition from Idle/Executing -> Loaded 352 // Buffers are about to be freed. 353 bufferSource->omxLoaded(); 354 setGraphicBufferSource(NULL); 355 } 356 357 // fall through 358 } 359 360 Mutex::Autolock autoLock(mLock); 361 362 // bump internal-state debug level for 2 input and output frames past a command 363 { 364 Mutex::Autolock _l(mDebugLock); 365 bumpDebugLevel_l(2 /* numInputBuffers */, 2 /* numOutputBuffers */); 366 } 367 368 const char *paramString = 369 cmd == OMX_CommandStateSet ? asString((OMX_STATETYPE)param) : portString(param); 370 CLOG_STATE(sendCommand, "%s(%d), %s(%d)", asString(cmd), cmd, paramString, param); 371 OMX_ERRORTYPE err = OMX_SendCommand(mHandle, cmd, param, NULL); 372 CLOG_IF_ERROR(sendCommand, err, "%s(%d), %s(%d)", asString(cmd), cmd, paramString, param); 373 return StatusFromOMXError(err); 374} 375 376status_t OMXNodeInstance::getParameter( 377 OMX_INDEXTYPE index, void *params, size_t /* size */) { 378 Mutex::Autolock autoLock(mLock); 379 380 OMX_ERRORTYPE err = OMX_GetParameter(mHandle, index, params); 381 OMX_INDEXEXTTYPE extIndex = (OMX_INDEXEXTTYPE)index; 382 // some errors are expected for getParameter 383 if (err != OMX_ErrorNoMore) { 384 CLOG_IF_ERROR(getParameter, err, "%s(%#x)", asString(extIndex), index); 385 } 386 return StatusFromOMXError(err); 387} 388 389status_t OMXNodeInstance::setParameter( 390 OMX_INDEXTYPE index, const void *params, size_t size) { 391 Mutex::Autolock autoLock(mLock); 392 OMX_INDEXEXTTYPE extIndex = (OMX_INDEXEXTTYPE)index; 393 CLOG_CONFIG(setParameter, "%s(%#x), %zu@%p)", asString(extIndex), index, size, params); 394 395 OMX_ERRORTYPE err = OMX_SetParameter( 396 mHandle, index, const_cast<void *>(params)); 397 CLOG_IF_ERROR(setParameter, err, "%s(%#x)", asString(extIndex), index); 398 return StatusFromOMXError(err); 399} 400 401status_t OMXNodeInstance::getConfig( 402 OMX_INDEXTYPE index, void *params, size_t /* size */) { 403 Mutex::Autolock autoLock(mLock); 404 405 OMX_ERRORTYPE err = OMX_GetConfig(mHandle, index, params); 406 OMX_INDEXEXTTYPE extIndex = (OMX_INDEXEXTTYPE)index; 407 // some errors are expected for getConfig 408 if (err != OMX_ErrorNoMore) { 409 CLOG_IF_ERROR(getConfig, err, "%s(%#x)", asString(extIndex), index); 410 } 411 return StatusFromOMXError(err); 412} 413 414status_t OMXNodeInstance::setConfig( 415 OMX_INDEXTYPE index, const void *params, size_t size) { 416 Mutex::Autolock autoLock(mLock); 417 OMX_INDEXEXTTYPE extIndex = (OMX_INDEXEXTTYPE)index; 418 CLOG_CONFIG(setConfig, "%s(%#x), %zu@%p)", asString(extIndex), index, size, params); 419 420 OMX_ERRORTYPE err = OMX_SetConfig( 421 mHandle, index, const_cast<void *>(params)); 422 CLOG_IF_ERROR(setConfig, err, "%s(%#x)", asString(extIndex), index); 423 return StatusFromOMXError(err); 424} 425 426status_t OMXNodeInstance::getState(OMX_STATETYPE* state) { 427 Mutex::Autolock autoLock(mLock); 428 429 OMX_ERRORTYPE err = OMX_GetState(mHandle, state); 430 CLOG_IF_ERROR(getState, err, ""); 431 return StatusFromOMXError(err); 432} 433 434status_t OMXNodeInstance::enableGraphicBuffers( 435 OMX_U32 portIndex, OMX_BOOL enable) { 436 Mutex::Autolock autoLock(mLock); 437 CLOG_CONFIG(enableGraphicBuffers, "%s:%u, %d", portString(portIndex), portIndex, enable); 438 OMX_STRING name = const_cast<OMX_STRING>( 439 "OMX.google.android.index.enableAndroidNativeBuffers"); 440 441 OMX_INDEXTYPE index; 442 OMX_ERRORTYPE err = OMX_GetExtensionIndex(mHandle, name, &index); 443 444 if (err != OMX_ErrorNone) { 445 CLOG_ERROR_IF(enable, getExtensionIndex, err, "%s", name); 446 return StatusFromOMXError(err); 447 } 448 449 EnableAndroidNativeBuffersParams params; 450 InitOMXParams(¶ms); 451 params.nPortIndex = portIndex; 452 params.enable = enable; 453 454 err = OMX_SetParameter(mHandle, index, ¶ms); 455 CLOG_IF_ERROR(setParameter, err, "%s(%#x): %s:%u en=%d", name, index, 456 portString(portIndex), portIndex, enable); 457 return StatusFromOMXError(err); 458} 459 460status_t OMXNodeInstance::getGraphicBufferUsage( 461 OMX_U32 portIndex, OMX_U32* usage) { 462 Mutex::Autolock autoLock(mLock); 463 464 OMX_INDEXTYPE index; 465 OMX_STRING name = const_cast<OMX_STRING>( 466 "OMX.google.android.index.getAndroidNativeBufferUsage"); 467 OMX_ERRORTYPE err = OMX_GetExtensionIndex(mHandle, name, &index); 468 469 if (err != OMX_ErrorNone) { 470 CLOG_ERROR(getExtensionIndex, err, "%s", name); 471 return StatusFromOMXError(err); 472 } 473 474 GetAndroidNativeBufferUsageParams params; 475 InitOMXParams(¶ms); 476 params.nPortIndex = portIndex; 477 478 err = OMX_GetParameter(mHandle, index, ¶ms); 479 if (err != OMX_ErrorNone) { 480 CLOG_ERROR(getParameter, err, "%s(%#x): %s:%u", name, index, 481 portString(portIndex), portIndex); 482 return StatusFromOMXError(err); 483 } 484 485 *usage = params.nUsage; 486 487 return OK; 488} 489 490status_t OMXNodeInstance::storeMetaDataInBuffers( 491 OMX_U32 portIndex, 492 OMX_BOOL enable) { 493 Mutex::Autolock autolock(mLock); 494 CLOG_CONFIG(storeMetaDataInBuffers, "%s:%u en:%d", portString(portIndex), portIndex, enable); 495 return storeMetaDataInBuffers_l( 496 portIndex, enable, 497 OMX_FALSE /* useGraphicBuffer */, NULL /* usingGraphicBufferInMetadata */); 498} 499 500status_t OMXNodeInstance::storeMetaDataInBuffers_l( 501 OMX_U32 portIndex, 502 OMX_BOOL enable, 503 OMX_BOOL useGraphicBuffer, 504 OMX_BOOL *usingGraphicBufferInMetadata) { 505 OMX_INDEXTYPE index; 506 OMX_STRING name = const_cast<OMX_STRING>( 507 "OMX.google.android.index.storeMetaDataInBuffers"); 508 509 OMX_STRING graphicBufferName = const_cast<OMX_STRING>( 510 "OMX.google.android.index.storeGraphicBufferInMetaData"); 511 if (usingGraphicBufferInMetadata == NULL) { 512 usingGraphicBufferInMetadata = &useGraphicBuffer; 513 } 514 515 OMX_ERRORTYPE err = 516 (useGraphicBuffer && portIndex == kPortIndexInput) 517 ? OMX_GetExtensionIndex(mHandle, graphicBufferName, &index) 518 : OMX_ErrorBadParameter; 519 if (err == OMX_ErrorNone) { 520 *usingGraphicBufferInMetadata = OMX_TRUE; 521 name = graphicBufferName; 522 } else { 523 err = OMX_GetExtensionIndex(mHandle, name, &index); 524 } 525 526 OMX_ERRORTYPE xerr = err; 527 if (err == OMX_ErrorNone) { 528 StoreMetaDataInBuffersParams params; 529 InitOMXParams(¶ms); 530 params.nPortIndex = portIndex; 531 params.bStoreMetaData = enable; 532 533 err = OMX_SetParameter(mHandle, index, ¶ms); 534 } 535 536 // don't log loud error if component does not support metadata mode on the output 537 if (err != OMX_ErrorNone) { 538 *usingGraphicBufferInMetadata = OMX_FALSE; 539 if (err == OMX_ErrorUnsupportedIndex && portIndex == kPortIndexOutput) { 540 CLOGW("component does not support metadata mode; using fallback"); 541 } else if (xerr != OMX_ErrorNone) { 542 CLOG_ERROR(getExtensionIndex, xerr, "%s", name); 543 } else { 544 CLOG_ERROR(setParameter, err, "%s(%#x): %s:%u en=%d GB=%d", name, index, 545 portString(portIndex), portIndex, enable, useGraphicBuffer); 546 } 547 } 548 return StatusFromOMXError(err); 549} 550 551status_t OMXNodeInstance::prepareForAdaptivePlayback( 552 OMX_U32 portIndex, OMX_BOOL enable, OMX_U32 maxFrameWidth, 553 OMX_U32 maxFrameHeight) { 554 Mutex::Autolock autolock(mLock); 555 CLOG_CONFIG(prepareForAdaptivePlayback, "%s:%u en=%d max=%ux%u", 556 portString(portIndex), portIndex, enable, maxFrameWidth, maxFrameHeight); 557 558 OMX_INDEXTYPE index; 559 OMX_STRING name = const_cast<OMX_STRING>( 560 "OMX.google.android.index.prepareForAdaptivePlayback"); 561 562 OMX_ERRORTYPE err = OMX_GetExtensionIndex(mHandle, name, &index); 563 if (err != OMX_ErrorNone) { 564 CLOG_ERROR_IF(enable, getExtensionIndex, err, "%s", name); 565 return StatusFromOMXError(err); 566 } 567 568 PrepareForAdaptivePlaybackParams params; 569 InitOMXParams(¶ms); 570 params.nPortIndex = portIndex; 571 params.bEnable = enable; 572 params.nMaxFrameWidth = maxFrameWidth; 573 params.nMaxFrameHeight = maxFrameHeight; 574 575 err = OMX_SetParameter(mHandle, index, ¶ms); 576 CLOG_IF_ERROR(setParameter, err, "%s(%#x): %s:%u en=%d max=%ux%u", name, index, 577 portString(portIndex), portIndex, enable, maxFrameWidth, maxFrameHeight); 578 return StatusFromOMXError(err); 579} 580 581status_t OMXNodeInstance::configureVideoTunnelMode( 582 OMX_U32 portIndex, OMX_BOOL tunneled, OMX_U32 audioHwSync, 583 native_handle_t **sidebandHandle) { 584 Mutex::Autolock autolock(mLock); 585 CLOG_CONFIG(configureVideoTunnelMode, "%s:%u tun=%d sync=%u", 586 portString(portIndex), portIndex, tunneled, audioHwSync); 587 588 OMX_INDEXTYPE index; 589 OMX_STRING name = const_cast<OMX_STRING>( 590 "OMX.google.android.index.configureVideoTunnelMode"); 591 592 OMX_ERRORTYPE err = OMX_GetExtensionIndex(mHandle, name, &index); 593 if (err != OMX_ErrorNone) { 594 CLOG_ERROR_IF(tunneled, getExtensionIndex, err, "%s", name); 595 return StatusFromOMXError(err); 596 } 597 598 ConfigureVideoTunnelModeParams tunnelParams; 599 InitOMXParams(&tunnelParams); 600 tunnelParams.nPortIndex = portIndex; 601 tunnelParams.bTunneled = tunneled; 602 tunnelParams.nAudioHwSync = audioHwSync; 603 err = OMX_SetParameter(mHandle, index, &tunnelParams); 604 if (err != OMX_ErrorNone) { 605 CLOG_ERROR(setParameter, err, "%s(%#x): %s:%u tun=%d sync=%u", name, index, 606 portString(portIndex), portIndex, tunneled, audioHwSync); 607 return StatusFromOMXError(err); 608 } 609 610 err = OMX_GetParameter(mHandle, index, &tunnelParams); 611 if (err != OMX_ErrorNone) { 612 CLOG_ERROR(getParameter, err, "%s(%#x): %s:%u tun=%d sync=%u", name, index, 613 portString(portIndex), portIndex, tunneled, audioHwSync); 614 return StatusFromOMXError(err); 615 } 616 if (sidebandHandle) { 617 *sidebandHandle = (native_handle_t*)tunnelParams.pSidebandWindow; 618 } 619 620 return OK; 621} 622 623status_t OMXNodeInstance::useBuffer( 624 OMX_U32 portIndex, const sp<IMemory> ¶ms, 625 OMX::buffer_id *buffer) { 626 Mutex::Autolock autoLock(mLock); 627 628 BufferMeta *buffer_meta = new BufferMeta(params); 629 630 OMX_BUFFERHEADERTYPE *header; 631 632 OMX_ERRORTYPE err = OMX_UseBuffer( 633 mHandle, &header, portIndex, buffer_meta, 634 params->size(), static_cast<OMX_U8 *>(params->pointer())); 635 636 if (err != OMX_ErrorNone) { 637 CLOG_ERROR(useBuffer, err, SIMPLE_BUFFER(portIndex, params->size(), params->pointer())); 638 639 delete buffer_meta; 640 buffer_meta = NULL; 641 642 *buffer = 0; 643 644 return StatusFromOMXError(err); 645 } 646 647 CHECK_EQ(header->pAppPrivate, buffer_meta); 648 649 *buffer = makeBufferID(header); 650 651 addActiveBuffer(portIndex, *buffer); 652 653 sp<GraphicBufferSource> bufferSource(getGraphicBufferSource()); 654 if (bufferSource != NULL && portIndex == kPortIndexInput) { 655 bufferSource->addCodecBuffer(header); 656 } 657 658 CLOG_BUFFER(useBuffer, NEW_BUFFER_FMT( 659 *buffer, portIndex, "%zu@%p", params->size(), params->pointer())); 660 return OK; 661} 662 663status_t OMXNodeInstance::useGraphicBuffer2_l( 664 OMX_U32 portIndex, const sp<GraphicBuffer>& graphicBuffer, 665 OMX::buffer_id *buffer) { 666 667 // port definition 668 OMX_PARAM_PORTDEFINITIONTYPE def; 669 InitOMXParams(&def); 670 def.nPortIndex = portIndex; 671 OMX_ERRORTYPE err = OMX_GetParameter(mHandle, OMX_IndexParamPortDefinition, &def); 672 if (err != OMX_ErrorNone) { 673 OMX_INDEXTYPE index = OMX_IndexParamPortDefinition; 674 CLOG_ERROR(getParameter, err, "%s(%#x): %s:%u", 675 asString(index), index, portString(portIndex), portIndex); 676 return UNKNOWN_ERROR; 677 } 678 679 BufferMeta *bufferMeta = new BufferMeta(graphicBuffer); 680 681 OMX_BUFFERHEADERTYPE *header = NULL; 682 OMX_U8* bufferHandle = const_cast<OMX_U8*>( 683 reinterpret_cast<const OMX_U8*>(graphicBuffer->handle)); 684 685 err = OMX_UseBuffer( 686 mHandle, 687 &header, 688 portIndex, 689 bufferMeta, 690 def.nBufferSize, 691 bufferHandle); 692 693 if (err != OMX_ErrorNone) { 694 CLOG_ERROR(useBuffer, err, BUFFER_FMT(portIndex, "%u@%p", def.nBufferSize, bufferHandle)); 695 delete bufferMeta; 696 bufferMeta = NULL; 697 *buffer = 0; 698 return StatusFromOMXError(err); 699 } 700 701 CHECK_EQ(header->pBuffer, bufferHandle); 702 CHECK_EQ(header->pAppPrivate, bufferMeta); 703 704 *buffer = makeBufferID(header); 705 706 addActiveBuffer(portIndex, *buffer); 707 CLOG_BUFFER(useGraphicBuffer2, NEW_BUFFER_FMT( 708 *buffer, portIndex, "%u@%p", def.nBufferSize, bufferHandle)); 709 return OK; 710} 711 712// XXX: This function is here for backwards compatibility. Once the OMX 713// implementations have been updated this can be removed and useGraphicBuffer2 714// can be renamed to useGraphicBuffer. 715status_t OMXNodeInstance::useGraphicBuffer( 716 OMX_U32 portIndex, const sp<GraphicBuffer>& graphicBuffer, 717 OMX::buffer_id *buffer) { 718 Mutex::Autolock autoLock(mLock); 719 720 // See if the newer version of the extension is present. 721 OMX_INDEXTYPE index; 722 if (OMX_GetExtensionIndex( 723 mHandle, 724 const_cast<OMX_STRING>("OMX.google.android.index.useAndroidNativeBuffer2"), 725 &index) == OMX_ErrorNone) { 726 return useGraphicBuffer2_l(portIndex, graphicBuffer, buffer); 727 } 728 729 OMX_STRING name = const_cast<OMX_STRING>( 730 "OMX.google.android.index.useAndroidNativeBuffer"); 731 OMX_ERRORTYPE err = OMX_GetExtensionIndex(mHandle, name, &index); 732 if (err != OMX_ErrorNone) { 733 CLOG_ERROR(getExtensionIndex, err, "%s", name); 734 return StatusFromOMXError(err); 735 } 736 737 BufferMeta *bufferMeta = new BufferMeta(graphicBuffer); 738 739 OMX_BUFFERHEADERTYPE *header; 740 741 OMX_VERSIONTYPE ver; 742 ver.s.nVersionMajor = 1; 743 ver.s.nVersionMinor = 0; 744 ver.s.nRevision = 0; 745 ver.s.nStep = 0; 746 UseAndroidNativeBufferParams params = { 747 sizeof(UseAndroidNativeBufferParams), ver, portIndex, bufferMeta, 748 &header, graphicBuffer, 749 }; 750 751 err = OMX_SetParameter(mHandle, index, ¶ms); 752 753 if (err != OMX_ErrorNone) { 754 CLOG_ERROR(setParameter, err, "%s(%#x): %s:%u meta=%p GB=%p", name, index, 755 portString(portIndex), portIndex, bufferMeta, graphicBuffer->handle); 756 757 delete bufferMeta; 758 bufferMeta = NULL; 759 760 *buffer = 0; 761 762 return StatusFromOMXError(err); 763 } 764 765 CHECK_EQ(header->pAppPrivate, bufferMeta); 766 767 *buffer = makeBufferID(header); 768 769 addActiveBuffer(portIndex, *buffer); 770 CLOG_BUFFER(useGraphicBuffer, NEW_BUFFER_FMT( 771 *buffer, portIndex, "GB=%p", graphicBuffer->handle)); 772 return OK; 773} 774 775status_t OMXNodeInstance::updateGraphicBufferInMeta( 776 OMX_U32 portIndex, const sp<GraphicBuffer>& graphicBuffer, 777 OMX::buffer_id buffer) { 778 Mutex::Autolock autoLock(mLock); 779 780 OMX_BUFFERHEADERTYPE *header = findBufferHeader(buffer); 781 VideoDecoderOutputMetaData *metadata = 782 (VideoDecoderOutputMetaData *)(header->pBuffer); 783 BufferMeta *bufferMeta = (BufferMeta *)(header->pAppPrivate); 784 bufferMeta->setGraphicBuffer(graphicBuffer); 785 metadata->eType = kMetadataBufferTypeGrallocSource; 786 metadata->pHandle = graphicBuffer->handle; 787 CLOG_BUFFER(updateGraphicBufferInMeta, "%s:%u, %#x := %p", 788 portString(portIndex), portIndex, buffer, graphicBuffer->handle); 789 return OK; 790} 791 792status_t OMXNodeInstance::createGraphicBufferSource( 793 OMX_U32 portIndex, sp<IGraphicBufferConsumer> bufferConsumer) { 794 status_t err; 795 796 const sp<GraphicBufferSource>& surfaceCheck = getGraphicBufferSource(); 797 if (surfaceCheck != NULL) { 798 return ALREADY_EXISTS; 799 } 800 801 // Input buffers will hold meta-data (gralloc references). 802 OMX_BOOL usingGraphicBuffer = OMX_FALSE; 803 err = storeMetaDataInBuffers_l( 804 portIndex, OMX_TRUE, 805 OMX_TRUE /* useGraphicBuffer */, &usingGraphicBuffer); 806 if (err != OK) { 807 return err; 808 } 809 810 // Retrieve the width and height of the graphic buffer, set when the 811 // codec was configured. 812 OMX_PARAM_PORTDEFINITIONTYPE def; 813 InitOMXParams(&def); 814 def.nPortIndex = portIndex; 815 OMX_ERRORTYPE oerr = OMX_GetParameter( 816 mHandle, OMX_IndexParamPortDefinition, &def); 817 if (oerr != OMX_ErrorNone) { 818 OMX_INDEXTYPE index = OMX_IndexParamPortDefinition; 819 CLOG_ERROR(getParameter, oerr, "%s(%#x): %s:%u", 820 asString(index), index, portString(portIndex), portIndex); 821 return UNKNOWN_ERROR; 822 } 823 824 if (def.format.video.eColorFormat != OMX_COLOR_FormatAndroidOpaque) { 825 CLOGW("createInputSurface requires COLOR_FormatSurface " 826 "(AndroidOpaque) color format instead of %s(%#x)", 827 asString(def.format.video.eColorFormat), def.format.video.eColorFormat); 828 return INVALID_OPERATION; 829 } 830 831 sp<GraphicBufferSource> bufferSource = new GraphicBufferSource(this, 832 def.format.video.nFrameWidth, 833 def.format.video.nFrameHeight, 834 def.nBufferCountActual, 835 usingGraphicBuffer, 836 bufferConsumer); 837 838 if ((err = bufferSource->initCheck()) != OK) { 839 return err; 840 } 841 setGraphicBufferSource(bufferSource); 842 843 return OK; 844} 845 846status_t OMXNodeInstance::createInputSurface( 847 OMX_U32 portIndex, sp<IGraphicBufferProducer> *bufferProducer) { 848 Mutex::Autolock autolock(mLock); 849 status_t err = createGraphicBufferSource(portIndex); 850 851 if (err != OK) { 852 return err; 853 } 854 855 *bufferProducer = mGraphicBufferSource->getIGraphicBufferProducer(); 856 return OK; 857} 858 859//static 860status_t OMXNodeInstance::createPersistentInputSurface( 861 sp<IGraphicBufferProducer> *bufferProducer, 862 sp<IGraphicBufferConsumer> *bufferConsumer) { 863 String8 name("GraphicBufferSource"); 864 865 sp<IGraphicBufferProducer> producer; 866 sp<IGraphicBufferConsumer> consumer; 867 BufferQueue::createBufferQueue(&producer, &consumer); 868 consumer->setConsumerName(name); 869 consumer->setConsumerUsageBits(GRALLOC_USAGE_HW_VIDEO_ENCODER); 870 871 sp<BufferQueue::ProxyConsumerListener> proxy = 872 new BufferQueue::ProxyConsumerListener(NULL); 873 status_t err = consumer->consumerConnect(proxy, false); 874 if (err != NO_ERROR) { 875 ALOGE("Error connecting to BufferQueue: %s (%d)", 876 strerror(-err), err); 877 return err; 878 } 879 880 *bufferProducer = producer; 881 *bufferConsumer = consumer; 882 883 return OK; 884} 885 886status_t OMXNodeInstance::setInputSurface( 887 OMX_U32 portIndex, const sp<IGraphicBufferConsumer> &bufferConsumer) { 888 Mutex::Autolock autolock(mLock); 889 return createGraphicBufferSource(portIndex, bufferConsumer); 890} 891 892status_t OMXNodeInstance::signalEndOfInputStream() { 893 // For non-Surface input, the MediaCodec should convert the call to a 894 // pair of requests (dequeue input buffer, queue input buffer with EOS 895 // flag set). Seems easier than doing the equivalent from here. 896 sp<GraphicBufferSource> bufferSource(getGraphicBufferSource()); 897 if (bufferSource == NULL) { 898 CLOGW("signalEndOfInputStream can only be used with Surface input"); 899 return INVALID_OPERATION; 900 } 901 return bufferSource->signalEndOfInputStream(); 902} 903 904status_t OMXNodeInstance::allocateBuffer( 905 OMX_U32 portIndex, size_t size, OMX::buffer_id *buffer, 906 void **buffer_data) { 907 Mutex::Autolock autoLock(mLock); 908 909 BufferMeta *buffer_meta = new BufferMeta(size); 910 911 OMX_BUFFERHEADERTYPE *header; 912 913 OMX_ERRORTYPE err = OMX_AllocateBuffer( 914 mHandle, &header, portIndex, buffer_meta, size); 915 916 if (err != OMX_ErrorNone) { 917 CLOG_ERROR(allocateBuffer, err, BUFFER_FMT(portIndex, "%zu@", size)); 918 delete buffer_meta; 919 buffer_meta = NULL; 920 921 *buffer = 0; 922 923 return StatusFromOMXError(err); 924 } 925 926 CHECK_EQ(header->pAppPrivate, buffer_meta); 927 928 *buffer = makeBufferID(header); 929 *buffer_data = header->pBuffer; 930 931 addActiveBuffer(portIndex, *buffer); 932 933 sp<GraphicBufferSource> bufferSource(getGraphicBufferSource()); 934 if (bufferSource != NULL && portIndex == kPortIndexInput) { 935 bufferSource->addCodecBuffer(header); 936 } 937 CLOG_BUFFER(allocateBuffer, NEW_BUFFER_FMT(*buffer, portIndex, "%zu@%p", size, *buffer_data)); 938 939 return OK; 940} 941 942status_t OMXNodeInstance::allocateBufferWithBackup( 943 OMX_U32 portIndex, const sp<IMemory> ¶ms, 944 OMX::buffer_id *buffer) { 945 Mutex::Autolock autoLock(mLock); 946 947 BufferMeta *buffer_meta = new BufferMeta(params, true); 948 949 OMX_BUFFERHEADERTYPE *header; 950 951 OMX_ERRORTYPE err = OMX_AllocateBuffer( 952 mHandle, &header, portIndex, buffer_meta, params->size()); 953 954 if (err != OMX_ErrorNone) { 955 CLOG_ERROR(allocateBufferWithBackup, err, 956 SIMPLE_BUFFER(portIndex, params->size(), params->pointer())); 957 delete buffer_meta; 958 buffer_meta = NULL; 959 960 *buffer = 0; 961 962 return StatusFromOMXError(err); 963 } 964 965 CHECK_EQ(header->pAppPrivate, buffer_meta); 966 967 *buffer = makeBufferID(header); 968 969 addActiveBuffer(portIndex, *buffer); 970 971 sp<GraphicBufferSource> bufferSource(getGraphicBufferSource()); 972 if (bufferSource != NULL && portIndex == kPortIndexInput) { 973 bufferSource->addCodecBuffer(header); 974 } 975 976 CLOG_BUFFER(allocateBufferWithBackup, NEW_BUFFER_FMT(*buffer, portIndex, "%zu@%p :> %p", 977 params->size(), params->pointer(), header->pBuffer)); 978 979 return OK; 980} 981 982status_t OMXNodeInstance::freeBuffer( 983 OMX_U32 portIndex, OMX::buffer_id buffer) { 984 Mutex::Autolock autoLock(mLock); 985 CLOG_BUFFER(freeBuffer, "%s:%u %#x", portString(portIndex), portIndex, buffer); 986 987 removeActiveBuffer(portIndex, buffer); 988 989 OMX_BUFFERHEADERTYPE *header = findBufferHeader(buffer); 990 BufferMeta *buffer_meta = static_cast<BufferMeta *>(header->pAppPrivate); 991 992 OMX_ERRORTYPE err = OMX_FreeBuffer(mHandle, portIndex, header); 993 CLOG_IF_ERROR(freeBuffer, err, "%s:%u %#x", portString(portIndex), portIndex, buffer); 994 995 delete buffer_meta; 996 buffer_meta = NULL; 997 invalidateBufferID(buffer); 998 999 return StatusFromOMXError(err); 1000} 1001 1002status_t OMXNodeInstance::fillBuffer(OMX::buffer_id buffer) { 1003 Mutex::Autolock autoLock(mLock); 1004 1005 OMX_BUFFERHEADERTYPE *header = findBufferHeader(buffer); 1006 header->nFilledLen = 0; 1007 header->nOffset = 0; 1008 header->nFlags = 0; 1009 1010 { 1011 Mutex::Autolock _l(mDebugLock); 1012 mOutputBuffersWithCodec.add(header); 1013 CLOG_BUMPED_BUFFER(fillBuffer, WITH_STATS(EMPTY_BUFFER(buffer, header))); 1014 } 1015 1016 OMX_ERRORTYPE err = OMX_FillThisBuffer(mHandle, header); 1017 if (err != OMX_ErrorNone) { 1018 CLOG_ERROR(fillBuffer, err, EMPTY_BUFFER(buffer, header)); 1019 Mutex::Autolock _l(mDebugLock); 1020 mOutputBuffersWithCodec.remove(header); 1021 } 1022 return StatusFromOMXError(err); 1023} 1024 1025status_t OMXNodeInstance::emptyBuffer( 1026 OMX::buffer_id buffer, 1027 OMX_U32 rangeOffset, OMX_U32 rangeLength, 1028 OMX_U32 flags, OMX_TICKS timestamp) { 1029 Mutex::Autolock autoLock(mLock); 1030 1031 OMX_BUFFERHEADERTYPE *header = findBufferHeader(buffer); 1032 header->nFilledLen = rangeLength; 1033 header->nOffset = rangeOffset; 1034 1035 BufferMeta *buffer_meta = 1036 static_cast<BufferMeta *>(header->pAppPrivate); 1037 buffer_meta->CopyToOMX(header); 1038 1039 return emptyBuffer_l(header, flags, timestamp, (intptr_t)buffer); 1040} 1041 1042// log queued buffer activity for the next few input and/or output frames 1043// if logging at internal state level 1044void OMXNodeInstance::bumpDebugLevel_l(size_t numInputBuffers, size_t numOutputBuffers) { 1045 if (DEBUG == ADebug::kDebugInternalState) { 1046 DEBUG_BUMP = ADebug::kDebugAll; 1047 if (numInputBuffers > 0) { 1048 mDebugLevelBumpPendingBuffers[kPortIndexInput] = numInputBuffers; 1049 } 1050 if (numOutputBuffers > 0) { 1051 mDebugLevelBumpPendingBuffers[kPortIndexOutput] = numOutputBuffers; 1052 } 1053 } 1054} 1055 1056void OMXNodeInstance::unbumpDebugLevel_l(size_t portIndex) { 1057 if (mDebugLevelBumpPendingBuffers[portIndex]) { 1058 --mDebugLevelBumpPendingBuffers[portIndex]; 1059 } 1060 if (!mDebugLevelBumpPendingBuffers[0] 1061 && !mDebugLevelBumpPendingBuffers[1]) { 1062 DEBUG_BUMP = DEBUG; 1063 } 1064} 1065 1066status_t OMXNodeInstance::emptyBuffer_l( 1067 OMX_BUFFERHEADERTYPE *header, OMX_U32 flags, OMX_TICKS timestamp, intptr_t debugAddr) { 1068 header->nFlags = flags; 1069 header->nTimeStamp = timestamp; 1070 1071 { 1072 Mutex::Autolock _l(mDebugLock); 1073 mInputBuffersWithCodec.add(header); 1074 1075 // bump internal-state debug level for 2 input frames past a buffer with CSD 1076 if ((flags & OMX_BUFFERFLAG_CODECCONFIG) != 0) { 1077 bumpDebugLevel_l(2 /* numInputBuffers */, 0 /* numOutputBuffers */); 1078 } 1079 1080 CLOG_BUMPED_BUFFER(emptyBuffer, WITH_STATS(FULL_BUFFER(debugAddr, header))); 1081 } 1082 1083 OMX_ERRORTYPE err = OMX_EmptyThisBuffer(mHandle, header); 1084 CLOG_IF_ERROR(emptyBuffer, err, FULL_BUFFER(debugAddr, header)); 1085 1086 { 1087 Mutex::Autolock _l(mDebugLock); 1088 if (err != OMX_ErrorNone) { 1089 mInputBuffersWithCodec.remove(header); 1090 } else if (!(flags & OMX_BUFFERFLAG_CODECCONFIG)) { 1091 unbumpDebugLevel_l(kPortIndexInput); 1092 } 1093 } 1094 1095 return StatusFromOMXError(err); 1096} 1097 1098// like emptyBuffer, but the data is already in header->pBuffer 1099status_t OMXNodeInstance::emptyDirectBuffer( 1100 OMX_BUFFERHEADERTYPE *header, 1101 OMX_U32 rangeOffset, OMX_U32 rangeLength, 1102 OMX_U32 flags, OMX_TICKS timestamp) { 1103 Mutex::Autolock autoLock(mLock); 1104 1105 header->nFilledLen = rangeLength; 1106 header->nOffset = rangeOffset; 1107 1108 return emptyBuffer_l(header, flags, timestamp, (intptr_t)header->pBuffer); 1109} 1110 1111status_t OMXNodeInstance::getExtensionIndex( 1112 const char *parameterName, OMX_INDEXTYPE *index) { 1113 Mutex::Autolock autoLock(mLock); 1114 1115 OMX_ERRORTYPE err = OMX_GetExtensionIndex( 1116 mHandle, const_cast<char *>(parameterName), index); 1117 1118 return StatusFromOMXError(err); 1119} 1120 1121inline static const char *asString(IOMX::InternalOptionType i, const char *def = "??") { 1122 switch (i) { 1123 case IOMX::INTERNAL_OPTION_SUSPEND: return "SUSPEND"; 1124 case IOMX::INTERNAL_OPTION_REPEAT_PREVIOUS_FRAME_DELAY: 1125 return "REPEAT_PREVIOUS_FRAME_DELAY"; 1126 case IOMX::INTERNAL_OPTION_MAX_TIMESTAMP_GAP: return "MAX_TIMESTAMP_GAP"; 1127 case IOMX::INTERNAL_OPTION_MAX_FPS: return "MAX_FPS"; 1128 case IOMX::INTERNAL_OPTION_START_TIME: return "START_TIME"; 1129 case IOMX::INTERNAL_OPTION_TIME_LAPSE: return "TIME_LAPSE"; 1130 default: return def; 1131 } 1132} 1133 1134status_t OMXNodeInstance::setInternalOption( 1135 OMX_U32 portIndex, 1136 IOMX::InternalOptionType type, 1137 const void *data, 1138 size_t size) { 1139 CLOG_CONFIG(setInternalOption, "%s(%d): %s:%u %zu@%p", 1140 asString(type), type, portString(portIndex), portIndex, size, data); 1141 switch (type) { 1142 case IOMX::INTERNAL_OPTION_SUSPEND: 1143 case IOMX::INTERNAL_OPTION_REPEAT_PREVIOUS_FRAME_DELAY: 1144 case IOMX::INTERNAL_OPTION_MAX_TIMESTAMP_GAP: 1145 case IOMX::INTERNAL_OPTION_MAX_FPS: 1146 case IOMX::INTERNAL_OPTION_START_TIME: 1147 case IOMX::INTERNAL_OPTION_TIME_LAPSE: 1148 { 1149 const sp<GraphicBufferSource> &bufferSource = 1150 getGraphicBufferSource(); 1151 1152 if (bufferSource == NULL || portIndex != kPortIndexInput) { 1153 CLOGW("setInternalOption is only for Surface input"); 1154 return ERROR_UNSUPPORTED; 1155 } 1156 1157 if (type == IOMX::INTERNAL_OPTION_SUSPEND) { 1158 if (size != sizeof(bool)) { 1159 return INVALID_OPERATION; 1160 } 1161 1162 bool suspend = *(bool *)data; 1163 CLOG_CONFIG(setInternalOption, "suspend=%d", suspend); 1164 bufferSource->suspend(suspend); 1165 } else if (type == 1166 IOMX::INTERNAL_OPTION_REPEAT_PREVIOUS_FRAME_DELAY){ 1167 if (size != sizeof(int64_t)) { 1168 return INVALID_OPERATION; 1169 } 1170 1171 int64_t delayUs = *(int64_t *)data; 1172 CLOG_CONFIG(setInternalOption, "delayUs=%lld", (long long)delayUs); 1173 return bufferSource->setRepeatPreviousFrameDelayUs(delayUs); 1174 } else if (type == 1175 IOMX::INTERNAL_OPTION_MAX_TIMESTAMP_GAP){ 1176 if (size != sizeof(int64_t)) { 1177 return INVALID_OPERATION; 1178 } 1179 1180 int64_t maxGapUs = *(int64_t *)data; 1181 CLOG_CONFIG(setInternalOption, "gapUs=%lld", (long long)maxGapUs); 1182 return bufferSource->setMaxTimestampGapUs(maxGapUs); 1183 } else if (type == IOMX::INTERNAL_OPTION_MAX_FPS) { 1184 if (size != sizeof(float)) { 1185 return INVALID_OPERATION; 1186 } 1187 1188 float maxFps = *(float *)data; 1189 CLOG_CONFIG(setInternalOption, "maxFps=%f", maxFps); 1190 return bufferSource->setMaxFps(maxFps); 1191 } else if (type == IOMX::INTERNAL_OPTION_START_TIME) { 1192 if (size != sizeof(int64_t)) { 1193 return INVALID_OPERATION; 1194 } 1195 1196 int64_t skipFramesBeforeUs = *(int64_t *)data; 1197 CLOG_CONFIG(setInternalOption, "beforeUs=%lld", (long long)skipFramesBeforeUs); 1198 bufferSource->setSkipFramesBeforeUs(skipFramesBeforeUs); 1199 } else { // IOMX::INTERNAL_OPTION_TIME_LAPSE 1200 if (size != sizeof(int64_t) * 2) { 1201 return INVALID_OPERATION; 1202 } 1203 1204 int64_t timePerFrameUs = ((int64_t *)data)[0]; 1205 int64_t timePerCaptureUs = ((int64_t *)data)[1]; 1206 CLOG_CONFIG(setInternalOption, "perFrameUs=%lld perCaptureUs=%lld", 1207 (long long)timePerFrameUs, (long long)timePerCaptureUs); 1208 1209 bufferSource->setTimeLapseUs((int64_t *)data); 1210 } 1211 1212 return OK; 1213 } 1214 1215 default: 1216 return ERROR_UNSUPPORTED; 1217 } 1218} 1219 1220void OMXNodeInstance::onMessage(const omx_message &msg) { 1221 const sp<GraphicBufferSource>& bufferSource(getGraphicBufferSource()); 1222 1223 if (msg.type == omx_message::FILL_BUFFER_DONE) { 1224 OMX_BUFFERHEADERTYPE *buffer = 1225 findBufferHeader(msg.u.extended_buffer_data.buffer); 1226 1227 { 1228 Mutex::Autolock _l(mDebugLock); 1229 mOutputBuffersWithCodec.remove(buffer); 1230 1231 CLOG_BUMPED_BUFFER( 1232 FBD, WITH_STATS(FULL_BUFFER(msg.u.extended_buffer_data.buffer, buffer))); 1233 1234 unbumpDebugLevel_l(kPortIndexOutput); 1235 } 1236 1237 BufferMeta *buffer_meta = 1238 static_cast<BufferMeta *>(buffer->pAppPrivate); 1239 1240 buffer_meta->CopyFromOMX(buffer); 1241 1242 if (bufferSource != NULL) { 1243 // fix up the buffer info (especially timestamp) if needed 1244 bufferSource->codecBufferFilled(buffer); 1245 1246 omx_message newMsg = msg; 1247 newMsg.u.extended_buffer_data.timestamp = buffer->nTimeStamp; 1248 mObserver->onMessage(newMsg); 1249 return; 1250 } 1251 } else if (msg.type == omx_message::EMPTY_BUFFER_DONE) { 1252 OMX_BUFFERHEADERTYPE *buffer = 1253 findBufferHeader(msg.u.buffer_data.buffer); 1254 1255 { 1256 Mutex::Autolock _l(mDebugLock); 1257 mInputBuffersWithCodec.remove(buffer); 1258 1259 CLOG_BUMPED_BUFFER( 1260 EBD, WITH_STATS(EMPTY_BUFFER(msg.u.buffer_data.buffer, buffer))); 1261 } 1262 1263 if (bufferSource != NULL) { 1264 // This is one of the buffers used exclusively by 1265 // GraphicBufferSource. 1266 // Don't dispatch a message back to ACodec, since it doesn't 1267 // know that anyone asked to have the buffer emptied and will 1268 // be very confused. 1269 bufferSource->codecBufferEmptied(buffer); 1270 return; 1271 } 1272 } 1273 1274 mObserver->onMessage(msg); 1275} 1276 1277void OMXNodeInstance::onObserverDied(OMXMaster *master) { 1278 ALOGE("!!! Observer died. Quickly, do something, ... anything..."); 1279 1280 // Try to force shutdown of the node and hope for the best. 1281 freeNode(master); 1282} 1283 1284void OMXNodeInstance::onGetHandleFailed() { 1285 delete this; 1286} 1287 1288// OMXNodeInstance::OnEvent calls OMX::OnEvent, which then calls here. 1289// Don't try to acquire mLock here -- in rare circumstances this will hang. 1290void OMXNodeInstance::onEvent( 1291 OMX_EVENTTYPE event, OMX_U32 arg1, OMX_U32 arg2) { 1292 const char *arg1String = "??"; 1293 const char *arg2String = "??"; 1294 ADebug::Level level = ADebug::kDebugInternalState; 1295 1296 switch (event) { 1297 case OMX_EventCmdComplete: 1298 arg1String = asString((OMX_COMMANDTYPE)arg1); 1299 switch (arg1) { 1300 case OMX_CommandStateSet: 1301 arg2String = asString((OMX_STATETYPE)arg2); 1302 level = ADebug::kDebugState; 1303 break; 1304 case OMX_CommandFlush: 1305 case OMX_CommandPortEnable: 1306 { 1307 // bump internal-state debug level for 2 input and output frames 1308 Mutex::Autolock _l(mDebugLock); 1309 bumpDebugLevel_l(2 /* numInputBuffers */, 2 /* numOutputBuffers */); 1310 } 1311 // fall through 1312 default: 1313 arg2String = portString(arg2); 1314 } 1315 break; 1316 case OMX_EventError: 1317 arg1String = asString((OMX_ERRORTYPE)arg1); 1318 level = ADebug::kDebugLifeCycle; 1319 break; 1320 case OMX_EventPortSettingsChanged: 1321 arg2String = asString((OMX_INDEXEXTTYPE)arg2); 1322 // fall through 1323 default: 1324 arg1String = portString(arg1); 1325 } 1326 1327 CLOGI_(level, onEvent, "%s(%x), %s(%x), %s(%x)", 1328 asString(event), event, arg1String, arg1, arg2String, arg2); 1329 const sp<GraphicBufferSource>& bufferSource(getGraphicBufferSource()); 1330 1331 if (bufferSource != NULL 1332 && event == OMX_EventCmdComplete 1333 && arg1 == OMX_CommandStateSet 1334 && arg2 == OMX_StateExecuting) { 1335 bufferSource->omxExecuting(); 1336 } 1337} 1338 1339// static 1340OMX_ERRORTYPE OMXNodeInstance::OnEvent( 1341 OMX_IN OMX_HANDLETYPE /* hComponent */, 1342 OMX_IN OMX_PTR pAppData, 1343 OMX_IN OMX_EVENTTYPE eEvent, 1344 OMX_IN OMX_U32 nData1, 1345 OMX_IN OMX_U32 nData2, 1346 OMX_IN OMX_PTR pEventData) { 1347 OMXNodeInstance *instance = static_cast<OMXNodeInstance *>(pAppData); 1348 if (instance->mDying) { 1349 return OMX_ErrorNone; 1350 } 1351 return instance->owner()->OnEvent( 1352 instance->nodeID(), eEvent, nData1, nData2, pEventData); 1353} 1354 1355// static 1356OMX_ERRORTYPE OMXNodeInstance::OnEmptyBufferDone( 1357 OMX_IN OMX_HANDLETYPE /* hComponent */, 1358 OMX_IN OMX_PTR pAppData, 1359 OMX_IN OMX_BUFFERHEADERTYPE* pBuffer) { 1360 OMXNodeInstance *instance = static_cast<OMXNodeInstance *>(pAppData); 1361 if (instance->mDying) { 1362 return OMX_ErrorNone; 1363 } 1364 return instance->owner()->OnEmptyBufferDone(instance->nodeID(), 1365 instance->findBufferID(pBuffer), pBuffer); 1366} 1367 1368// static 1369OMX_ERRORTYPE OMXNodeInstance::OnFillBufferDone( 1370 OMX_IN OMX_HANDLETYPE /* hComponent */, 1371 OMX_IN OMX_PTR pAppData, 1372 OMX_IN OMX_BUFFERHEADERTYPE* pBuffer) { 1373 OMXNodeInstance *instance = static_cast<OMXNodeInstance *>(pAppData); 1374 if (instance->mDying) { 1375 return OMX_ErrorNone; 1376 } 1377 return instance->owner()->OnFillBufferDone(instance->nodeID(), 1378 instance->findBufferID(pBuffer), pBuffer); 1379} 1380 1381void OMXNodeInstance::addActiveBuffer(OMX_U32 portIndex, OMX::buffer_id id) { 1382 ActiveBuffer active; 1383 active.mPortIndex = portIndex; 1384 active.mID = id; 1385 mActiveBuffers.push(active); 1386 1387 if (portIndex < NELEM(mNumPortBuffers)) { 1388 ++mNumPortBuffers[portIndex]; 1389 } 1390} 1391 1392void OMXNodeInstance::removeActiveBuffer( 1393 OMX_U32 portIndex, OMX::buffer_id id) { 1394 for (size_t i = 0; i < mActiveBuffers.size(); ++i) { 1395 if (mActiveBuffers[i].mPortIndex == portIndex 1396 && mActiveBuffers[i].mID == id) { 1397 mActiveBuffers.removeItemsAt(i); 1398 1399 if (portIndex < NELEM(mNumPortBuffers)) { 1400 --mNumPortBuffers[portIndex]; 1401 } 1402 return; 1403 } 1404 } 1405 1406 CLOGW("Attempt to remove an active buffer [%#x] we know nothing about...", id); 1407} 1408 1409void OMXNodeInstance::freeActiveBuffers() { 1410 // Make sure to count down here, as freeBuffer will in turn remove 1411 // the active buffer from the vector... 1412 for (size_t i = mActiveBuffers.size(); i--;) { 1413 freeBuffer(mActiveBuffers[i].mPortIndex, mActiveBuffers[i].mID); 1414 } 1415} 1416 1417#ifdef __LP64__ 1418 1419OMX::buffer_id OMXNodeInstance::makeBufferID(OMX_BUFFERHEADERTYPE *bufferHeader) { 1420 if (bufferHeader == NULL) { 1421 return 0; 1422 } 1423 Mutex::Autolock autoLock(mBufferIDLock); 1424 OMX::buffer_id buffer; 1425 do { // handle the very unlikely case of ID overflow 1426 if (++mBufferIDCount == 0) { 1427 ++mBufferIDCount; 1428 } 1429 buffer = (OMX::buffer_id)mBufferIDCount; 1430 } while (mBufferIDToBufferHeader.indexOfKey(buffer) >= 0); 1431 mBufferIDToBufferHeader.add(buffer, bufferHeader); 1432 mBufferHeaderToBufferID.add(bufferHeader, buffer); 1433 return buffer; 1434} 1435 1436OMX_BUFFERHEADERTYPE *OMXNodeInstance::findBufferHeader(OMX::buffer_id buffer) { 1437 if (buffer == 0) { 1438 return NULL; 1439 } 1440 Mutex::Autolock autoLock(mBufferIDLock); 1441 return mBufferIDToBufferHeader.valueFor(buffer); 1442} 1443 1444OMX::buffer_id OMXNodeInstance::findBufferID(OMX_BUFFERHEADERTYPE *bufferHeader) { 1445 if (bufferHeader == NULL) { 1446 return 0; 1447 } 1448 Mutex::Autolock autoLock(mBufferIDLock); 1449 return mBufferHeaderToBufferID.valueFor(bufferHeader); 1450} 1451 1452void OMXNodeInstance::invalidateBufferID(OMX::buffer_id buffer) { 1453 if (buffer == 0) { 1454 return; 1455 } 1456 Mutex::Autolock autoLock(mBufferIDLock); 1457 mBufferHeaderToBufferID.removeItem(mBufferIDToBufferHeader.valueFor(buffer)); 1458 mBufferIDToBufferHeader.removeItem(buffer); 1459} 1460 1461#else 1462 1463OMX::buffer_id OMXNodeInstance::makeBufferID(OMX_BUFFERHEADERTYPE *bufferHeader) { 1464 return (OMX::buffer_id)bufferHeader; 1465} 1466 1467OMX_BUFFERHEADERTYPE *OMXNodeInstance::findBufferHeader(OMX::buffer_id buffer) { 1468 return (OMX_BUFFERHEADERTYPE *)buffer; 1469} 1470 1471OMX::buffer_id OMXNodeInstance::findBufferID(OMX_BUFFERHEADERTYPE *bufferHeader) { 1472 return (OMX::buffer_id)bufferHeader; 1473} 1474 1475void OMXNodeInstance::invalidateBufferID(OMX::buffer_id buffer __unused) { 1476} 1477 1478#endif 1479 1480} // namespace android 1481