ACodec.cpp revision 1f9374bad4f59d619ef30f227705a926dabf41d5
1/* 2 * Copyright (C) 2010 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 "ACodec" 19 20#include <media/stagefright/ACodec.h> 21 22#include <binder/MemoryDealer.h> 23 24#include <media/stagefright/foundation/hexdump.h> 25#include <media/stagefright/foundation/ABuffer.h> 26#include <media/stagefright/foundation/ADebug.h> 27#include <media/stagefright/foundation/AMessage.h> 28 29#include <media/stagefright/BufferProducerWrapper.h> 30#include <media/stagefright/MediaCodecList.h> 31#include <media/stagefright/MediaDefs.h> 32#include <media/stagefright/NativeWindowWrapper.h> 33#include <media/stagefright/OMXClient.h> 34#include <media/stagefright/OMXCodec.h> 35 36#include <media/hardware/HardwareAPI.h> 37 38#include <OMX_Component.h> 39 40#include "include/avc_utils.h" 41 42namespace android { 43 44template<class T> 45static void InitOMXParams(T *params) { 46 params->nSize = sizeof(T); 47 params->nVersion.s.nVersionMajor = 1; 48 params->nVersion.s.nVersionMinor = 0; 49 params->nVersion.s.nRevision = 0; 50 params->nVersion.s.nStep = 0; 51} 52 53struct CodecObserver : public BnOMXObserver { 54 CodecObserver() {} 55 56 void setNotificationMessage(const sp<AMessage> &msg) { 57 mNotify = msg; 58 } 59 60 // from IOMXObserver 61 virtual void onMessage(const omx_message &omx_msg) { 62 sp<AMessage> msg = mNotify->dup(); 63 64 msg->setInt32("type", omx_msg.type); 65 msg->setPointer("node", omx_msg.node); 66 67 switch (omx_msg.type) { 68 case omx_message::EVENT: 69 { 70 msg->setInt32("event", omx_msg.u.event_data.event); 71 msg->setInt32("data1", omx_msg.u.event_data.data1); 72 msg->setInt32("data2", omx_msg.u.event_data.data2); 73 break; 74 } 75 76 case omx_message::EMPTY_BUFFER_DONE: 77 { 78 msg->setPointer("buffer", omx_msg.u.buffer_data.buffer); 79 break; 80 } 81 82 case omx_message::FILL_BUFFER_DONE: 83 { 84 msg->setPointer( 85 "buffer", omx_msg.u.extended_buffer_data.buffer); 86 msg->setInt32( 87 "range_offset", 88 omx_msg.u.extended_buffer_data.range_offset); 89 msg->setInt32( 90 "range_length", 91 omx_msg.u.extended_buffer_data.range_length); 92 msg->setInt32( 93 "flags", 94 omx_msg.u.extended_buffer_data.flags); 95 msg->setInt64( 96 "timestamp", 97 omx_msg.u.extended_buffer_data.timestamp); 98 msg->setPointer( 99 "platform_private", 100 omx_msg.u.extended_buffer_data.platform_private); 101 msg->setPointer( 102 "data_ptr", 103 omx_msg.u.extended_buffer_data.data_ptr); 104 break; 105 } 106 107 default: 108 TRESPASS(); 109 break; 110 } 111 112 msg->post(); 113 } 114 115protected: 116 virtual ~CodecObserver() {} 117 118private: 119 sp<AMessage> mNotify; 120 121 DISALLOW_EVIL_CONSTRUCTORS(CodecObserver); 122}; 123 124//////////////////////////////////////////////////////////////////////////////// 125 126struct ACodec::BaseState : public AState { 127 BaseState(ACodec *codec, const sp<AState> &parentState = NULL); 128 129protected: 130 enum PortMode { 131 KEEP_BUFFERS, 132 RESUBMIT_BUFFERS, 133 FREE_BUFFERS, 134 }; 135 136 ACodec *mCodec; 137 138 virtual PortMode getPortMode(OMX_U32 portIndex); 139 140 virtual bool onMessageReceived(const sp<AMessage> &msg); 141 142 virtual bool onOMXEvent(OMX_EVENTTYPE event, OMX_U32 data1, OMX_U32 data2); 143 144 virtual void onOutputBufferDrained(const sp<AMessage> &msg); 145 virtual void onInputBufferFilled(const sp<AMessage> &msg); 146 147 void postFillThisBuffer(BufferInfo *info); 148 149private: 150 bool onOMXMessage(const sp<AMessage> &msg); 151 152 bool onOMXEmptyBufferDone(IOMX::buffer_id bufferID); 153 154 bool onOMXFillBufferDone( 155 IOMX::buffer_id bufferID, 156 size_t rangeOffset, size_t rangeLength, 157 OMX_U32 flags, 158 int64_t timeUs, 159 void *platformPrivate, 160 void *dataPtr); 161 162 void getMoreInputDataIfPossible(); 163 164 DISALLOW_EVIL_CONSTRUCTORS(BaseState); 165}; 166 167//////////////////////////////////////////////////////////////////////////////// 168 169struct ACodec::DeathNotifier : public IBinder::DeathRecipient { 170 DeathNotifier(const sp<AMessage> ¬ify) 171 : mNotify(notify) { 172 } 173 174 virtual void binderDied(const wp<IBinder> &) { 175 mNotify->post(); 176 } 177 178protected: 179 virtual ~DeathNotifier() {} 180 181private: 182 sp<AMessage> mNotify; 183 184 DISALLOW_EVIL_CONSTRUCTORS(DeathNotifier); 185}; 186 187struct ACodec::UninitializedState : public ACodec::BaseState { 188 UninitializedState(ACodec *codec); 189 190protected: 191 virtual bool onMessageReceived(const sp<AMessage> &msg); 192 virtual void stateEntered(); 193 194private: 195 void onSetup(const sp<AMessage> &msg); 196 bool onAllocateComponent(const sp<AMessage> &msg); 197 198 sp<DeathNotifier> mDeathNotifier; 199 200 DISALLOW_EVIL_CONSTRUCTORS(UninitializedState); 201}; 202 203//////////////////////////////////////////////////////////////////////////////// 204 205struct ACodec::LoadedState : public ACodec::BaseState { 206 LoadedState(ACodec *codec); 207 208protected: 209 virtual bool onMessageReceived(const sp<AMessage> &msg); 210 virtual void stateEntered(); 211 212private: 213 friend struct ACodec::UninitializedState; 214 215 bool onConfigureComponent(const sp<AMessage> &msg); 216 void onCreateInputSurface(const sp<AMessage> &msg); 217 void onStart(); 218 void onShutdown(bool keepComponentAllocated); 219 220 DISALLOW_EVIL_CONSTRUCTORS(LoadedState); 221}; 222 223//////////////////////////////////////////////////////////////////////////////// 224 225struct ACodec::LoadedToIdleState : public ACodec::BaseState { 226 LoadedToIdleState(ACodec *codec); 227 228protected: 229 virtual bool onMessageReceived(const sp<AMessage> &msg); 230 virtual bool onOMXEvent(OMX_EVENTTYPE event, OMX_U32 data1, OMX_U32 data2); 231 virtual void stateEntered(); 232 233private: 234 status_t allocateBuffers(); 235 236 DISALLOW_EVIL_CONSTRUCTORS(LoadedToIdleState); 237}; 238 239//////////////////////////////////////////////////////////////////////////////// 240 241struct ACodec::IdleToExecutingState : public ACodec::BaseState { 242 IdleToExecutingState(ACodec *codec); 243 244protected: 245 virtual bool onMessageReceived(const sp<AMessage> &msg); 246 virtual bool onOMXEvent(OMX_EVENTTYPE event, OMX_U32 data1, OMX_U32 data2); 247 virtual void stateEntered(); 248 249private: 250 DISALLOW_EVIL_CONSTRUCTORS(IdleToExecutingState); 251}; 252 253//////////////////////////////////////////////////////////////////////////////// 254 255struct ACodec::ExecutingState : public ACodec::BaseState { 256 ExecutingState(ACodec *codec); 257 258 void submitOutputBuffers(); 259 260 // Submit output buffers to the decoder, submit input buffers to client 261 // to fill with data. 262 void resume(); 263 264 // Returns true iff input and output buffers are in play. 265 bool active() const { return mActive; } 266 267protected: 268 virtual PortMode getPortMode(OMX_U32 portIndex); 269 virtual bool onMessageReceived(const sp<AMessage> &msg); 270 virtual void stateEntered(); 271 272 virtual bool onOMXEvent(OMX_EVENTTYPE event, OMX_U32 data1, OMX_U32 data2); 273 274private: 275 bool mActive; 276 277 DISALLOW_EVIL_CONSTRUCTORS(ExecutingState); 278}; 279 280//////////////////////////////////////////////////////////////////////////////// 281 282struct ACodec::OutputPortSettingsChangedState : public ACodec::BaseState { 283 OutputPortSettingsChangedState(ACodec *codec); 284 285protected: 286 virtual PortMode getPortMode(OMX_U32 portIndex); 287 virtual bool onMessageReceived(const sp<AMessage> &msg); 288 virtual void stateEntered(); 289 290 virtual bool onOMXEvent(OMX_EVENTTYPE event, OMX_U32 data1, OMX_U32 data2); 291 292private: 293 DISALLOW_EVIL_CONSTRUCTORS(OutputPortSettingsChangedState); 294}; 295 296//////////////////////////////////////////////////////////////////////////////// 297 298struct ACodec::ExecutingToIdleState : public ACodec::BaseState { 299 ExecutingToIdleState(ACodec *codec); 300 301protected: 302 virtual bool onMessageReceived(const sp<AMessage> &msg); 303 virtual void stateEntered(); 304 305 virtual bool onOMXEvent(OMX_EVENTTYPE event, OMX_U32 data1, OMX_U32 data2); 306 307 virtual void onOutputBufferDrained(const sp<AMessage> &msg); 308 virtual void onInputBufferFilled(const sp<AMessage> &msg); 309 310private: 311 void changeStateIfWeOwnAllBuffers(); 312 313 bool mComponentNowIdle; 314 315 DISALLOW_EVIL_CONSTRUCTORS(ExecutingToIdleState); 316}; 317 318//////////////////////////////////////////////////////////////////////////////// 319 320struct ACodec::IdleToLoadedState : public ACodec::BaseState { 321 IdleToLoadedState(ACodec *codec); 322 323protected: 324 virtual bool onMessageReceived(const sp<AMessage> &msg); 325 virtual void stateEntered(); 326 327 virtual bool onOMXEvent(OMX_EVENTTYPE event, OMX_U32 data1, OMX_U32 data2); 328 329private: 330 DISALLOW_EVIL_CONSTRUCTORS(IdleToLoadedState); 331}; 332 333//////////////////////////////////////////////////////////////////////////////// 334 335struct ACodec::FlushingState : public ACodec::BaseState { 336 FlushingState(ACodec *codec); 337 338protected: 339 virtual bool onMessageReceived(const sp<AMessage> &msg); 340 virtual void stateEntered(); 341 342 virtual bool onOMXEvent(OMX_EVENTTYPE event, OMX_U32 data1, OMX_U32 data2); 343 344 virtual void onOutputBufferDrained(const sp<AMessage> &msg); 345 virtual void onInputBufferFilled(const sp<AMessage> &msg); 346 347private: 348 bool mFlushComplete[2]; 349 350 void changeStateIfWeOwnAllBuffers(); 351 352 DISALLOW_EVIL_CONSTRUCTORS(FlushingState); 353}; 354 355//////////////////////////////////////////////////////////////////////////////// 356 357ACodec::ACodec() 358 : mQuirks(0), 359 mNode(NULL), 360 mSentFormat(false), 361 mIsEncoder(false), 362 mShutdownInProgress(false), 363 mEncoderDelay(0), 364 mEncoderPadding(0), 365 mChannelMaskPresent(false), 366 mChannelMask(0) { 367 mUninitializedState = new UninitializedState(this); 368 mLoadedState = new LoadedState(this); 369 mLoadedToIdleState = new LoadedToIdleState(this); 370 mIdleToExecutingState = new IdleToExecutingState(this); 371 mExecutingState = new ExecutingState(this); 372 373 mOutputPortSettingsChangedState = 374 new OutputPortSettingsChangedState(this); 375 376 mExecutingToIdleState = new ExecutingToIdleState(this); 377 mIdleToLoadedState = new IdleToLoadedState(this); 378 mFlushingState = new FlushingState(this); 379 380 mPortEOS[kPortIndexInput] = mPortEOS[kPortIndexOutput] = false; 381 mInputEOSResult = OK; 382 383 changeState(mUninitializedState); 384} 385 386ACodec::~ACodec() { 387} 388 389void ACodec::setNotificationMessage(const sp<AMessage> &msg) { 390 mNotify = msg; 391} 392 393void ACodec::initiateSetup(const sp<AMessage> &msg) { 394 msg->setWhat(kWhatSetup); 395 msg->setTarget(id()); 396 msg->post(); 397} 398 399void ACodec::signalSetParameters(const sp<AMessage> ¶ms) { 400 sp<AMessage> msg = new AMessage(kWhatSetParameters, id()); 401 msg->setMessage("params", params); 402 msg->post(); 403} 404 405void ACodec::initiateAllocateComponent(const sp<AMessage> &msg) { 406 msg->setWhat(kWhatAllocateComponent); 407 msg->setTarget(id()); 408 msg->post(); 409} 410 411void ACodec::initiateConfigureComponent(const sp<AMessage> &msg) { 412 msg->setWhat(kWhatConfigureComponent); 413 msg->setTarget(id()); 414 msg->post(); 415} 416 417void ACodec::initiateCreateInputSurface() { 418 (new AMessage(kWhatCreateInputSurface, id()))->post(); 419} 420 421void ACodec::signalEndOfInputStream() { 422 (new AMessage(kWhatSignalEndOfInputStream, id()))->post(); 423} 424 425void ACodec::initiateStart() { 426 (new AMessage(kWhatStart, id()))->post(); 427} 428 429void ACodec::signalFlush() { 430 ALOGV("[%s] signalFlush", mComponentName.c_str()); 431 (new AMessage(kWhatFlush, id()))->post(); 432} 433 434void ACodec::signalResume() { 435 (new AMessage(kWhatResume, id()))->post(); 436} 437 438void ACodec::initiateShutdown(bool keepComponentAllocated) { 439 sp<AMessage> msg = new AMessage(kWhatShutdown, id()); 440 msg->setInt32("keepComponentAllocated", keepComponentAllocated); 441 msg->post(); 442} 443 444void ACodec::signalRequestIDRFrame() { 445 (new AMessage(kWhatRequestIDRFrame, id()))->post(); 446} 447 448status_t ACodec::allocateBuffersOnPort(OMX_U32 portIndex) { 449 CHECK(portIndex == kPortIndexInput || portIndex == kPortIndexOutput); 450 451 CHECK(mDealer[portIndex] == NULL); 452 CHECK(mBuffers[portIndex].isEmpty()); 453 454 status_t err; 455 if (mNativeWindow != NULL && portIndex == kPortIndexOutput) { 456 err = allocateOutputBuffersFromNativeWindow(); 457 } else { 458 OMX_PARAM_PORTDEFINITIONTYPE def; 459 InitOMXParams(&def); 460 def.nPortIndex = portIndex; 461 462 err = mOMX->getParameter( 463 mNode, OMX_IndexParamPortDefinition, &def, sizeof(def)); 464 465 if (err == OK) { 466 ALOGV("[%s] Allocating %lu buffers of size %lu on %s port", 467 mComponentName.c_str(), 468 def.nBufferCountActual, def.nBufferSize, 469 portIndex == kPortIndexInput ? "input" : "output"); 470 471 size_t totalSize = def.nBufferCountActual * def.nBufferSize; 472 mDealer[portIndex] = new MemoryDealer(totalSize, "ACodec"); 473 474 for (OMX_U32 i = 0; i < def.nBufferCountActual; ++i) { 475 sp<IMemory> mem = mDealer[portIndex]->allocate(def.nBufferSize); 476 CHECK(mem.get() != NULL); 477 478 BufferInfo info; 479 info.mStatus = BufferInfo::OWNED_BY_US; 480 481 uint32_t requiresAllocateBufferBit = 482 (portIndex == kPortIndexInput) 483 ? OMXCodec::kRequiresAllocateBufferOnInputPorts 484 : OMXCodec::kRequiresAllocateBufferOnOutputPorts; 485 486 if (portIndex == kPortIndexInput && (mFlags & kFlagIsSecure)) { 487 mem.clear(); 488 489 void *ptr; 490 err = mOMX->allocateBuffer( 491 mNode, portIndex, def.nBufferSize, &info.mBufferID, 492 &ptr); 493 494 info.mData = new ABuffer(ptr, def.nBufferSize); 495 } else if (mQuirks & requiresAllocateBufferBit) { 496 err = mOMX->allocateBufferWithBackup( 497 mNode, portIndex, mem, &info.mBufferID); 498 } else { 499 err = mOMX->useBuffer(mNode, portIndex, mem, &info.mBufferID); 500 } 501 502 if (mem != NULL) { 503 info.mData = new ABuffer(mem->pointer(), def.nBufferSize); 504 } 505 506 mBuffers[portIndex].push(info); 507 } 508 } 509 } 510 511 if (err != OK) { 512 return err; 513 } 514 515 sp<AMessage> notify = mNotify->dup(); 516 notify->setInt32("what", ACodec::kWhatBuffersAllocated); 517 518 notify->setInt32("portIndex", portIndex); 519 520 sp<PortDescription> desc = new PortDescription; 521 522 for (size_t i = 0; i < mBuffers[portIndex].size(); ++i) { 523 const BufferInfo &info = mBuffers[portIndex][i]; 524 525 desc->addBuffer(info.mBufferID, info.mData); 526 } 527 528 notify->setObject("portDesc", desc); 529 notify->post(); 530 531 return OK; 532} 533 534status_t ACodec::allocateOutputBuffersFromNativeWindow() { 535 OMX_PARAM_PORTDEFINITIONTYPE def; 536 InitOMXParams(&def); 537 def.nPortIndex = kPortIndexOutput; 538 539 status_t err = mOMX->getParameter( 540 mNode, OMX_IndexParamPortDefinition, &def, sizeof(def)); 541 542 if (err != OK) { 543 return err; 544 } 545 546 err = native_window_set_buffers_geometry( 547 mNativeWindow.get(), 548 def.format.video.nFrameWidth, 549 def.format.video.nFrameHeight, 550 def.format.video.eColorFormat); 551 552 if (err != 0) { 553 ALOGE("native_window_set_buffers_geometry failed: %s (%d)", 554 strerror(-err), -err); 555 return err; 556 } 557 558 // Set up the native window. 559 OMX_U32 usage = 0; 560 err = mOMX->getGraphicBufferUsage(mNode, kPortIndexOutput, &usage); 561 if (err != 0) { 562 ALOGW("querying usage flags from OMX IL component failed: %d", err); 563 // XXX: Currently this error is logged, but not fatal. 564 usage = 0; 565 } 566 567 if (mFlags & kFlagIsSecure) { 568 usage |= GRALLOC_USAGE_PROTECTED; 569 } 570 571 // Make sure to check whether either Stagefright or the video decoder 572 // requested protected buffers. 573 if (usage & GRALLOC_USAGE_PROTECTED) { 574 // Verify that the ANativeWindow sends images directly to 575 // SurfaceFlinger. 576 int queuesToNativeWindow = 0; 577 err = mNativeWindow->query( 578 mNativeWindow.get(), NATIVE_WINDOW_QUEUES_TO_WINDOW_COMPOSER, 579 &queuesToNativeWindow); 580 if (err != 0) { 581 ALOGE("error authenticating native window: %d", err); 582 return err; 583 } 584 if (queuesToNativeWindow != 1) { 585 ALOGE("native window could not be authenticated"); 586 return PERMISSION_DENIED; 587 } 588 } 589 590 err = native_window_set_usage( 591 mNativeWindow.get(), 592 usage | GRALLOC_USAGE_HW_TEXTURE | GRALLOC_USAGE_EXTERNAL_DISP); 593 594 if (err != 0) { 595 ALOGE("native_window_set_usage failed: %s (%d)", strerror(-err), -err); 596 return err; 597 } 598 599 int minUndequeuedBufs = 0; 600 err = mNativeWindow->query( 601 mNativeWindow.get(), NATIVE_WINDOW_MIN_UNDEQUEUED_BUFFERS, 602 &minUndequeuedBufs); 603 604 if (err != 0) { 605 ALOGE("NATIVE_WINDOW_MIN_UNDEQUEUED_BUFFERS query failed: %s (%d)", 606 strerror(-err), -err); 607 return err; 608 } 609 610 // XXX: Is this the right logic to use? It's not clear to me what the OMX 611 // buffer counts refer to - how do they account for the renderer holding on 612 // to buffers? 613 if (def.nBufferCountActual < def.nBufferCountMin + minUndequeuedBufs) { 614 OMX_U32 newBufferCount = def.nBufferCountMin + minUndequeuedBufs; 615 def.nBufferCountActual = newBufferCount; 616 err = mOMX->setParameter( 617 mNode, OMX_IndexParamPortDefinition, &def, sizeof(def)); 618 619 if (err != OK) { 620 ALOGE("[%s] setting nBufferCountActual to %lu failed: %d", 621 mComponentName.c_str(), newBufferCount, err); 622 return err; 623 } 624 } 625 626 err = native_window_set_buffer_count( 627 mNativeWindow.get(), def.nBufferCountActual); 628 629 if (err != 0) { 630 ALOGE("native_window_set_buffer_count failed: %s (%d)", strerror(-err), 631 -err); 632 return err; 633 } 634 635 ALOGV("[%s] Allocating %lu buffers from a native window of size %lu on " 636 "output port", 637 mComponentName.c_str(), def.nBufferCountActual, def.nBufferSize); 638 639 // Dequeue buffers and send them to OMX 640 for (OMX_U32 i = 0; i < def.nBufferCountActual; i++) { 641 ANativeWindowBuffer *buf; 642 err = native_window_dequeue_buffer_and_wait(mNativeWindow.get(), &buf); 643 if (err != 0) { 644 ALOGE("dequeueBuffer failed: %s (%d)", strerror(-err), -err); 645 break; 646 } 647 648 sp<GraphicBuffer> graphicBuffer(new GraphicBuffer(buf, false)); 649 BufferInfo info; 650 info.mStatus = BufferInfo::OWNED_BY_US; 651 info.mData = new ABuffer(NULL /* data */, def.nBufferSize /* capacity */); 652 info.mGraphicBuffer = graphicBuffer; 653 mBuffers[kPortIndexOutput].push(info); 654 655 IOMX::buffer_id bufferId; 656 err = mOMX->useGraphicBuffer(mNode, kPortIndexOutput, graphicBuffer, 657 &bufferId); 658 if (err != 0) { 659 ALOGE("registering GraphicBuffer %lu with OMX IL component failed: " 660 "%d", i, err); 661 break; 662 } 663 664 mBuffers[kPortIndexOutput].editItemAt(i).mBufferID = bufferId; 665 666 ALOGV("[%s] Registered graphic buffer with ID %p (pointer = %p)", 667 mComponentName.c_str(), 668 bufferId, graphicBuffer.get()); 669 } 670 671 OMX_U32 cancelStart; 672 OMX_U32 cancelEnd; 673 674 if (err != 0) { 675 // If an error occurred while dequeuing we need to cancel any buffers 676 // that were dequeued. 677 cancelStart = 0; 678 cancelEnd = mBuffers[kPortIndexOutput].size(); 679 } else { 680 // Return the last two buffers to the native window. 681 cancelStart = def.nBufferCountActual - minUndequeuedBufs; 682 cancelEnd = def.nBufferCountActual; 683 } 684 685 for (OMX_U32 i = cancelStart; i < cancelEnd; i++) { 686 BufferInfo *info = &mBuffers[kPortIndexOutput].editItemAt(i); 687 cancelBufferToNativeWindow(info); 688 } 689 690 return err; 691} 692 693status_t ACodec::cancelBufferToNativeWindow(BufferInfo *info) { 694 CHECK_EQ((int)info->mStatus, (int)BufferInfo::OWNED_BY_US); 695 696 ALOGV("[%s] Calling cancelBuffer on buffer %p", 697 mComponentName.c_str(), info->mBufferID); 698 699 int err = mNativeWindow->cancelBuffer( 700 mNativeWindow.get(), info->mGraphicBuffer.get(), -1); 701 702 CHECK_EQ(err, 0); 703 704 info->mStatus = BufferInfo::OWNED_BY_NATIVE_WINDOW; 705 706 return OK; 707} 708 709ACodec::BufferInfo *ACodec::dequeueBufferFromNativeWindow() { 710 ANativeWindowBuffer *buf; 711 int fenceFd = -1; 712 if (native_window_dequeue_buffer_and_wait(mNativeWindow.get(), &buf) != 0) { 713 ALOGE("dequeueBuffer failed."); 714 return NULL; 715 } 716 717 for (size_t i = mBuffers[kPortIndexOutput].size(); i-- > 0;) { 718 BufferInfo *info = 719 &mBuffers[kPortIndexOutput].editItemAt(i); 720 721 if (info->mGraphicBuffer->handle == buf->handle) { 722 CHECK_EQ((int)info->mStatus, 723 (int)BufferInfo::OWNED_BY_NATIVE_WINDOW); 724 725 info->mStatus = BufferInfo::OWNED_BY_US; 726 727 return info; 728 } 729 } 730 731 TRESPASS(); 732 733 return NULL; 734} 735 736status_t ACodec::freeBuffersOnPort(OMX_U32 portIndex) { 737 for (size_t i = mBuffers[portIndex].size(); i-- > 0;) { 738 CHECK_EQ((status_t)OK, freeBuffer(portIndex, i)); 739 } 740 741 mDealer[portIndex].clear(); 742 743 return OK; 744} 745 746status_t ACodec::freeOutputBuffersNotOwnedByComponent() { 747 for (size_t i = mBuffers[kPortIndexOutput].size(); i-- > 0;) { 748 BufferInfo *info = 749 &mBuffers[kPortIndexOutput].editItemAt(i); 750 751 // At this time some buffers may still be with the component 752 // or being drained. 753 if (info->mStatus != BufferInfo::OWNED_BY_COMPONENT && 754 info->mStatus != BufferInfo::OWNED_BY_DOWNSTREAM) { 755 CHECK_EQ((status_t)OK, freeBuffer(kPortIndexOutput, i)); 756 } 757 } 758 759 return OK; 760} 761 762status_t ACodec::freeBuffer(OMX_U32 portIndex, size_t i) { 763 BufferInfo *info = &mBuffers[portIndex].editItemAt(i); 764 765 CHECK(info->mStatus == BufferInfo::OWNED_BY_US 766 || info->mStatus == BufferInfo::OWNED_BY_NATIVE_WINDOW); 767 768 if (portIndex == kPortIndexOutput && mNativeWindow != NULL 769 && info->mStatus == BufferInfo::OWNED_BY_US) { 770 CHECK_EQ((status_t)OK, cancelBufferToNativeWindow(info)); 771 } 772 773 CHECK_EQ(mOMX->freeBuffer( 774 mNode, portIndex, info->mBufferID), 775 (status_t)OK); 776 777 mBuffers[portIndex].removeAt(i); 778 779 return OK; 780} 781 782ACodec::BufferInfo *ACodec::findBufferByID( 783 uint32_t portIndex, IOMX::buffer_id bufferID, 784 ssize_t *index) { 785 for (size_t i = 0; i < mBuffers[portIndex].size(); ++i) { 786 BufferInfo *info = &mBuffers[portIndex].editItemAt(i); 787 788 if (info->mBufferID == bufferID) { 789 if (index != NULL) { 790 *index = i; 791 } 792 return info; 793 } 794 } 795 796 TRESPASS(); 797 798 return NULL; 799} 800 801status_t ACodec::setComponentRole( 802 bool isEncoder, const char *mime) { 803 struct MimeToRole { 804 const char *mime; 805 const char *decoderRole; 806 const char *encoderRole; 807 }; 808 809 static const MimeToRole kMimeToRole[] = { 810 { MEDIA_MIMETYPE_AUDIO_MPEG, 811 "audio_decoder.mp3", "audio_encoder.mp3" }, 812 { MEDIA_MIMETYPE_AUDIO_MPEG_LAYER_I, 813 "audio_decoder.mp1", "audio_encoder.mp1" }, 814 { MEDIA_MIMETYPE_AUDIO_MPEG_LAYER_II, 815 "audio_decoder.mp2", "audio_encoder.mp2" }, 816 { MEDIA_MIMETYPE_AUDIO_AMR_NB, 817 "audio_decoder.amrnb", "audio_encoder.amrnb" }, 818 { MEDIA_MIMETYPE_AUDIO_AMR_WB, 819 "audio_decoder.amrwb", "audio_encoder.amrwb" }, 820 { MEDIA_MIMETYPE_AUDIO_AAC, 821 "audio_decoder.aac", "audio_encoder.aac" }, 822 { MEDIA_MIMETYPE_AUDIO_VORBIS, 823 "audio_decoder.vorbis", "audio_encoder.vorbis" }, 824 { MEDIA_MIMETYPE_AUDIO_G711_MLAW, 825 "audio_decoder.g711mlaw", "audio_encoder.g711mlaw" }, 826 { MEDIA_MIMETYPE_AUDIO_G711_ALAW, 827 "audio_decoder.g711alaw", "audio_encoder.g711alaw" }, 828 { MEDIA_MIMETYPE_VIDEO_AVC, 829 "video_decoder.avc", "video_encoder.avc" }, 830 { MEDIA_MIMETYPE_VIDEO_MPEG4, 831 "video_decoder.mpeg4", "video_encoder.mpeg4" }, 832 { MEDIA_MIMETYPE_VIDEO_H263, 833 "video_decoder.h263", "video_encoder.h263" }, 834 { MEDIA_MIMETYPE_VIDEO_VPX, 835 "video_decoder.vpx", "video_encoder.vpx" }, 836 { MEDIA_MIMETYPE_AUDIO_RAW, 837 "audio_decoder.raw", "audio_encoder.raw" }, 838 { MEDIA_MIMETYPE_AUDIO_FLAC, 839 "audio_decoder.flac", "audio_encoder.flac" }, 840 { MEDIA_MIMETYPE_AUDIO_MSGSM, 841 "audio_decoder.gsm", "audio_encoder.gsm" }, 842 }; 843 844 static const size_t kNumMimeToRole = 845 sizeof(kMimeToRole) / sizeof(kMimeToRole[0]); 846 847 size_t i; 848 for (i = 0; i < kNumMimeToRole; ++i) { 849 if (!strcasecmp(mime, kMimeToRole[i].mime)) { 850 break; 851 } 852 } 853 854 if (i == kNumMimeToRole) { 855 return ERROR_UNSUPPORTED; 856 } 857 858 const char *role = 859 isEncoder ? kMimeToRole[i].encoderRole 860 : kMimeToRole[i].decoderRole; 861 862 if (role != NULL) { 863 OMX_PARAM_COMPONENTROLETYPE roleParams; 864 InitOMXParams(&roleParams); 865 866 strncpy((char *)roleParams.cRole, 867 role, OMX_MAX_STRINGNAME_SIZE - 1); 868 869 roleParams.cRole[OMX_MAX_STRINGNAME_SIZE - 1] = '\0'; 870 871 status_t err = mOMX->setParameter( 872 mNode, OMX_IndexParamStandardComponentRole, 873 &roleParams, sizeof(roleParams)); 874 875 if (err != OK) { 876 ALOGW("[%s] Failed to set standard component role '%s'.", 877 mComponentName.c_str(), role); 878 879 return err; 880 } 881 } 882 883 return OK; 884} 885 886status_t ACodec::configureCodec( 887 const char *mime, const sp<AMessage> &msg) { 888 int32_t encoder; 889 if (!msg->findInt32("encoder", &encoder)) { 890 encoder = false; 891 } 892 893 mIsEncoder = encoder; 894 895 status_t err = setComponentRole(encoder /* isEncoder */, mime); 896 897 if (err != OK) { 898 return err; 899 } 900 901 int32_t bitRate = 0; 902 // FLAC encoder doesn't need a bitrate, other encoders do 903 if (encoder && strcasecmp(mime, MEDIA_MIMETYPE_AUDIO_FLAC) 904 && !msg->findInt32("bitrate", &bitRate)) { 905 return INVALID_OPERATION; 906 } 907 908 int32_t storeMeta; 909 if (encoder 910 && msg->findInt32("store-metadata-in-buffers", &storeMeta) 911 && storeMeta != 0) { 912 err = mOMX->storeMetaDataInBuffers(mNode, kPortIndexInput, OMX_TRUE); 913 914 if (err != OK) { 915 ALOGE("[%s] storeMetaDataInBuffers failed w/ err %d", 916 mComponentName.c_str(), err); 917 918 return err; 919 } 920 } 921 922 int32_t prependSPSPPS; 923 if (encoder 924 && msg->findInt32("prepend-sps-pps-to-idr-frames", &prependSPSPPS) 925 && prependSPSPPS != 0) { 926 OMX_INDEXTYPE index; 927 err = mOMX->getExtensionIndex( 928 mNode, 929 "OMX.google.android.index.prependSPSPPSToIDRFrames", 930 &index); 931 932 if (err == OK) { 933 PrependSPSPPSToIDRFramesParams params; 934 InitOMXParams(¶ms); 935 params.bEnable = OMX_TRUE; 936 937 err = mOMX->setParameter( 938 mNode, index, ¶ms, sizeof(params)); 939 } 940 941 if (err != OK) { 942 ALOGE("Encoder could not be configured to emit SPS/PPS before " 943 "IDR frames. (err %d)", err); 944 945 return err; 946 } 947 } 948 949 if (!strncasecmp(mime, "video/", 6)) { 950 if (encoder) { 951 err = setupVideoEncoder(mime, msg); 952 } else { 953 int32_t width, height; 954 if (!msg->findInt32("width", &width) 955 || !msg->findInt32("height", &height)) { 956 err = INVALID_OPERATION; 957 } else { 958 err = setupVideoDecoder(mime, width, height); 959 } 960 } 961 } else if (!strcasecmp(mime, MEDIA_MIMETYPE_AUDIO_MPEG)) { 962 int32_t numChannels, sampleRate; 963 if (!msg->findInt32("channel-count", &numChannels) 964 || !msg->findInt32("sample-rate", &sampleRate)) { 965 // Since we did not always check for these, leave them optional 966 // and have the decoder figure it all out. 967 err = OK; 968 } else { 969 err = setupRawAudioFormat( 970 encoder ? kPortIndexInput : kPortIndexOutput, 971 sampleRate, 972 numChannels); 973 } 974 } else if (!strcasecmp(mime, MEDIA_MIMETYPE_AUDIO_AAC)) { 975 int32_t numChannels, sampleRate; 976 if (!msg->findInt32("channel-count", &numChannels) 977 || !msg->findInt32("sample-rate", &sampleRate)) { 978 err = INVALID_OPERATION; 979 } else { 980 int32_t isADTS, aacProfile; 981 if (!msg->findInt32("is-adts", &isADTS)) { 982 isADTS = 0; 983 } 984 if (!msg->findInt32("aac-profile", &aacProfile)) { 985 aacProfile = OMX_AUDIO_AACObjectNull; 986 } 987 988 err = setupAACCodec( 989 encoder, numChannels, sampleRate, bitRate, aacProfile, 990 isADTS != 0); 991 } 992 } else if (!strcasecmp(mime, MEDIA_MIMETYPE_AUDIO_AMR_NB)) { 993 err = setupAMRCodec(encoder, false /* isWAMR */, bitRate); 994 } else if (!strcasecmp(mime, MEDIA_MIMETYPE_AUDIO_AMR_WB)) { 995 err = setupAMRCodec(encoder, true /* isWAMR */, bitRate); 996 } else if (!strcasecmp(mime, MEDIA_MIMETYPE_AUDIO_G711_ALAW) 997 || !strcasecmp(mime, MEDIA_MIMETYPE_AUDIO_G711_MLAW)) { 998 // These are PCM-like formats with a fixed sample rate but 999 // a variable number of channels. 1000 1001 int32_t numChannels; 1002 if (!msg->findInt32("channel-count", &numChannels)) { 1003 err = INVALID_OPERATION; 1004 } else { 1005 err = setupG711Codec(encoder, numChannels); 1006 } 1007 } else if (!strcasecmp(mime, MEDIA_MIMETYPE_AUDIO_FLAC)) { 1008 int32_t numChannels, sampleRate, compressionLevel = -1; 1009 if (encoder && 1010 (!msg->findInt32("channel-count", &numChannels) 1011 || !msg->findInt32("sample-rate", &sampleRate))) { 1012 ALOGE("missing channel count or sample rate for FLAC encoder"); 1013 err = INVALID_OPERATION; 1014 } else { 1015 if (encoder) { 1016 if (!msg->findInt32( 1017 "flac-compression-level", &compressionLevel)) { 1018 compressionLevel = 5;// default FLAC compression level 1019 } else if (compressionLevel < 0) { 1020 ALOGW("compression level %d outside [0..8] range, " 1021 "using 0", 1022 compressionLevel); 1023 compressionLevel = 0; 1024 } else if (compressionLevel > 8) { 1025 ALOGW("compression level %d outside [0..8] range, " 1026 "using 8", 1027 compressionLevel); 1028 compressionLevel = 8; 1029 } 1030 } 1031 err = setupFlacCodec( 1032 encoder, numChannels, sampleRate, compressionLevel); 1033 } 1034 } else if (!strcasecmp(mime, MEDIA_MIMETYPE_AUDIO_RAW)) { 1035 int32_t numChannels, sampleRate; 1036 if (encoder 1037 || !msg->findInt32("channel-count", &numChannels) 1038 || !msg->findInt32("sample-rate", &sampleRate)) { 1039 err = INVALID_OPERATION; 1040 } else { 1041 err = setupRawAudioFormat(kPortIndexInput, sampleRate, numChannels); 1042 } 1043 } 1044 1045 if (err != OK) { 1046 return err; 1047 } 1048 1049 if (!msg->findInt32("encoder-delay", &mEncoderDelay)) { 1050 mEncoderDelay = 0; 1051 } 1052 1053 if (!msg->findInt32("encoder-padding", &mEncoderPadding)) { 1054 mEncoderPadding = 0; 1055 } 1056 1057 if (msg->findInt32("channel-mask", &mChannelMask)) { 1058 mChannelMaskPresent = true; 1059 } else { 1060 mChannelMaskPresent = false; 1061 } 1062 1063 int32_t maxInputSize; 1064 if (msg->findInt32("max-input-size", &maxInputSize)) { 1065 err = setMinBufferSize(kPortIndexInput, (size_t)maxInputSize); 1066 } else if (!strcmp("OMX.Nvidia.aac.decoder", mComponentName.c_str())) { 1067 err = setMinBufferSize(kPortIndexInput, 8192); // XXX 1068 } 1069 1070 return err; 1071} 1072 1073status_t ACodec::setMinBufferSize(OMX_U32 portIndex, size_t size) { 1074 OMX_PARAM_PORTDEFINITIONTYPE def; 1075 InitOMXParams(&def); 1076 def.nPortIndex = portIndex; 1077 1078 status_t err = mOMX->getParameter( 1079 mNode, OMX_IndexParamPortDefinition, &def, sizeof(def)); 1080 1081 if (err != OK) { 1082 return err; 1083 } 1084 1085 if (def.nBufferSize >= size) { 1086 return OK; 1087 } 1088 1089 def.nBufferSize = size; 1090 1091 err = mOMX->setParameter( 1092 mNode, OMX_IndexParamPortDefinition, &def, sizeof(def)); 1093 1094 if (err != OK) { 1095 return err; 1096 } 1097 1098 err = mOMX->getParameter( 1099 mNode, OMX_IndexParamPortDefinition, &def, sizeof(def)); 1100 1101 if (err != OK) { 1102 return err; 1103 } 1104 1105 CHECK(def.nBufferSize >= size); 1106 1107 return OK; 1108} 1109 1110status_t ACodec::selectAudioPortFormat( 1111 OMX_U32 portIndex, OMX_AUDIO_CODINGTYPE desiredFormat) { 1112 OMX_AUDIO_PARAM_PORTFORMATTYPE format; 1113 InitOMXParams(&format); 1114 1115 format.nPortIndex = portIndex; 1116 for (OMX_U32 index = 0;; ++index) { 1117 format.nIndex = index; 1118 1119 status_t err = mOMX->getParameter( 1120 mNode, OMX_IndexParamAudioPortFormat, 1121 &format, sizeof(format)); 1122 1123 if (err != OK) { 1124 return err; 1125 } 1126 1127 if (format.eEncoding == desiredFormat) { 1128 break; 1129 } 1130 } 1131 1132 return mOMX->setParameter( 1133 mNode, OMX_IndexParamAudioPortFormat, &format, sizeof(format)); 1134} 1135 1136status_t ACodec::setupAACCodec( 1137 bool encoder, int32_t numChannels, int32_t sampleRate, 1138 int32_t bitRate, int32_t aacProfile, bool isADTS) { 1139 if (encoder && isADTS) { 1140 return -EINVAL; 1141 } 1142 1143 status_t err = setupRawAudioFormat( 1144 encoder ? kPortIndexInput : kPortIndexOutput, 1145 sampleRate, 1146 numChannels); 1147 1148 if (err != OK) { 1149 return err; 1150 } 1151 1152 if (encoder) { 1153 err = selectAudioPortFormat(kPortIndexOutput, OMX_AUDIO_CodingAAC); 1154 1155 if (err != OK) { 1156 return err; 1157 } 1158 1159 OMX_PARAM_PORTDEFINITIONTYPE def; 1160 InitOMXParams(&def); 1161 def.nPortIndex = kPortIndexOutput; 1162 1163 err = mOMX->getParameter( 1164 mNode, OMX_IndexParamPortDefinition, &def, sizeof(def)); 1165 1166 if (err != OK) { 1167 return err; 1168 } 1169 1170 def.format.audio.bFlagErrorConcealment = OMX_TRUE; 1171 def.format.audio.eEncoding = OMX_AUDIO_CodingAAC; 1172 1173 err = mOMX->setParameter( 1174 mNode, OMX_IndexParamPortDefinition, &def, sizeof(def)); 1175 1176 if (err != OK) { 1177 return err; 1178 } 1179 1180 OMX_AUDIO_PARAM_AACPROFILETYPE profile; 1181 InitOMXParams(&profile); 1182 profile.nPortIndex = kPortIndexOutput; 1183 1184 err = mOMX->getParameter( 1185 mNode, OMX_IndexParamAudioAac, &profile, sizeof(profile)); 1186 1187 if (err != OK) { 1188 return err; 1189 } 1190 1191 profile.nChannels = numChannels; 1192 1193 profile.eChannelMode = 1194 (numChannels == 1) 1195 ? OMX_AUDIO_ChannelModeMono: OMX_AUDIO_ChannelModeStereo; 1196 1197 profile.nSampleRate = sampleRate; 1198 profile.nBitRate = bitRate; 1199 profile.nAudioBandWidth = 0; 1200 profile.nFrameLength = 0; 1201 profile.nAACtools = OMX_AUDIO_AACToolAll; 1202 profile.nAACERtools = OMX_AUDIO_AACERNone; 1203 profile.eAACProfile = (OMX_AUDIO_AACPROFILETYPE) aacProfile; 1204 profile.eAACStreamFormat = OMX_AUDIO_AACStreamFormatMP4FF; 1205 1206 err = mOMX->setParameter( 1207 mNode, OMX_IndexParamAudioAac, &profile, sizeof(profile)); 1208 1209 if (err != OK) { 1210 return err; 1211 } 1212 1213 return err; 1214 } 1215 1216 OMX_AUDIO_PARAM_AACPROFILETYPE profile; 1217 InitOMXParams(&profile); 1218 profile.nPortIndex = kPortIndexInput; 1219 1220 err = mOMX->getParameter( 1221 mNode, OMX_IndexParamAudioAac, &profile, sizeof(profile)); 1222 1223 if (err != OK) { 1224 return err; 1225 } 1226 1227 profile.nChannels = numChannels; 1228 profile.nSampleRate = sampleRate; 1229 1230 profile.eAACStreamFormat = 1231 isADTS 1232 ? OMX_AUDIO_AACStreamFormatMP4ADTS 1233 : OMX_AUDIO_AACStreamFormatMP4FF; 1234 1235 return mOMX->setParameter( 1236 mNode, OMX_IndexParamAudioAac, &profile, sizeof(profile)); 1237} 1238 1239static OMX_AUDIO_AMRBANDMODETYPE pickModeFromBitRate( 1240 bool isAMRWB, int32_t bps) { 1241 if (isAMRWB) { 1242 if (bps <= 6600) { 1243 return OMX_AUDIO_AMRBandModeWB0; 1244 } else if (bps <= 8850) { 1245 return OMX_AUDIO_AMRBandModeWB1; 1246 } else if (bps <= 12650) { 1247 return OMX_AUDIO_AMRBandModeWB2; 1248 } else if (bps <= 14250) { 1249 return OMX_AUDIO_AMRBandModeWB3; 1250 } else if (bps <= 15850) { 1251 return OMX_AUDIO_AMRBandModeWB4; 1252 } else if (bps <= 18250) { 1253 return OMX_AUDIO_AMRBandModeWB5; 1254 } else if (bps <= 19850) { 1255 return OMX_AUDIO_AMRBandModeWB6; 1256 } else if (bps <= 23050) { 1257 return OMX_AUDIO_AMRBandModeWB7; 1258 } 1259 1260 // 23850 bps 1261 return OMX_AUDIO_AMRBandModeWB8; 1262 } else { // AMRNB 1263 if (bps <= 4750) { 1264 return OMX_AUDIO_AMRBandModeNB0; 1265 } else if (bps <= 5150) { 1266 return OMX_AUDIO_AMRBandModeNB1; 1267 } else if (bps <= 5900) { 1268 return OMX_AUDIO_AMRBandModeNB2; 1269 } else if (bps <= 6700) { 1270 return OMX_AUDIO_AMRBandModeNB3; 1271 } else if (bps <= 7400) { 1272 return OMX_AUDIO_AMRBandModeNB4; 1273 } else if (bps <= 7950) { 1274 return OMX_AUDIO_AMRBandModeNB5; 1275 } else if (bps <= 10200) { 1276 return OMX_AUDIO_AMRBandModeNB6; 1277 } 1278 1279 // 12200 bps 1280 return OMX_AUDIO_AMRBandModeNB7; 1281 } 1282} 1283 1284status_t ACodec::setupAMRCodec(bool encoder, bool isWAMR, int32_t bitrate) { 1285 OMX_AUDIO_PARAM_AMRTYPE def; 1286 InitOMXParams(&def); 1287 def.nPortIndex = encoder ? kPortIndexOutput : kPortIndexInput; 1288 1289 status_t err = 1290 mOMX->getParameter(mNode, OMX_IndexParamAudioAmr, &def, sizeof(def)); 1291 1292 if (err != OK) { 1293 return err; 1294 } 1295 1296 def.eAMRFrameFormat = OMX_AUDIO_AMRFrameFormatFSF; 1297 def.eAMRBandMode = pickModeFromBitRate(isWAMR, bitrate); 1298 1299 err = mOMX->setParameter( 1300 mNode, OMX_IndexParamAudioAmr, &def, sizeof(def)); 1301 1302 if (err != OK) { 1303 return err; 1304 } 1305 1306 return setupRawAudioFormat( 1307 encoder ? kPortIndexInput : kPortIndexOutput, 1308 isWAMR ? 16000 : 8000 /* sampleRate */, 1309 1 /* numChannels */); 1310} 1311 1312status_t ACodec::setupG711Codec(bool encoder, int32_t numChannels) { 1313 CHECK(!encoder); // XXX TODO 1314 1315 return setupRawAudioFormat( 1316 kPortIndexInput, 8000 /* sampleRate */, numChannels); 1317} 1318 1319status_t ACodec::setupFlacCodec( 1320 bool encoder, int32_t numChannels, int32_t sampleRate, int32_t compressionLevel) { 1321 1322 if (encoder) { 1323 OMX_AUDIO_PARAM_FLACTYPE def; 1324 InitOMXParams(&def); 1325 def.nPortIndex = kPortIndexOutput; 1326 1327 // configure compression level 1328 status_t err = mOMX->getParameter(mNode, OMX_IndexParamAudioFlac, &def, sizeof(def)); 1329 if (err != OK) { 1330 ALOGE("setupFlacCodec(): Error %d getting OMX_IndexParamAudioFlac parameter", err); 1331 return err; 1332 } 1333 def.nCompressionLevel = compressionLevel; 1334 err = mOMX->setParameter(mNode, OMX_IndexParamAudioFlac, &def, sizeof(def)); 1335 if (err != OK) { 1336 ALOGE("setupFlacCodec(): Error %d setting OMX_IndexParamAudioFlac parameter", err); 1337 return err; 1338 } 1339 } 1340 1341 return setupRawAudioFormat( 1342 encoder ? kPortIndexInput : kPortIndexOutput, 1343 sampleRate, 1344 numChannels); 1345} 1346 1347status_t ACodec::setupRawAudioFormat( 1348 OMX_U32 portIndex, int32_t sampleRate, int32_t numChannels) { 1349 OMX_PARAM_PORTDEFINITIONTYPE def; 1350 InitOMXParams(&def); 1351 def.nPortIndex = portIndex; 1352 1353 status_t err = mOMX->getParameter( 1354 mNode, OMX_IndexParamPortDefinition, &def, sizeof(def)); 1355 1356 if (err != OK) { 1357 return err; 1358 } 1359 1360 def.format.audio.eEncoding = OMX_AUDIO_CodingPCM; 1361 1362 err = mOMX->setParameter( 1363 mNode, OMX_IndexParamPortDefinition, &def, sizeof(def)); 1364 1365 if (err != OK) { 1366 return err; 1367 } 1368 1369 OMX_AUDIO_PARAM_PCMMODETYPE pcmParams; 1370 InitOMXParams(&pcmParams); 1371 pcmParams.nPortIndex = portIndex; 1372 1373 err = mOMX->getParameter( 1374 mNode, OMX_IndexParamAudioPcm, &pcmParams, sizeof(pcmParams)); 1375 1376 if (err != OK) { 1377 return err; 1378 } 1379 1380 pcmParams.nChannels = numChannels; 1381 pcmParams.eNumData = OMX_NumericalDataSigned; 1382 pcmParams.bInterleaved = OMX_TRUE; 1383 pcmParams.nBitPerSample = 16; 1384 pcmParams.nSamplingRate = sampleRate; 1385 pcmParams.ePCMMode = OMX_AUDIO_PCMModeLinear; 1386 1387 if (getOMXChannelMapping(numChannels, pcmParams.eChannelMapping) != OK) { 1388 return OMX_ErrorNone; 1389 } 1390 1391 return mOMX->setParameter( 1392 mNode, OMX_IndexParamAudioPcm, &pcmParams, sizeof(pcmParams)); 1393} 1394 1395status_t ACodec::setVideoPortFormatType( 1396 OMX_U32 portIndex, 1397 OMX_VIDEO_CODINGTYPE compressionFormat, 1398 OMX_COLOR_FORMATTYPE colorFormat) { 1399 OMX_VIDEO_PARAM_PORTFORMATTYPE format; 1400 InitOMXParams(&format); 1401 format.nPortIndex = portIndex; 1402 format.nIndex = 0; 1403 bool found = false; 1404 1405 OMX_U32 index = 0; 1406 for (;;) { 1407 format.nIndex = index; 1408 status_t err = mOMX->getParameter( 1409 mNode, OMX_IndexParamVideoPortFormat, 1410 &format, sizeof(format)); 1411 1412 if (err != OK) { 1413 return err; 1414 } 1415 1416 // The following assertion is violated by TI's video decoder. 1417 // CHECK_EQ(format.nIndex, index); 1418 1419 if (!strcmp("OMX.TI.Video.encoder", mComponentName.c_str())) { 1420 if (portIndex == kPortIndexInput 1421 && colorFormat == format.eColorFormat) { 1422 // eCompressionFormat does not seem right. 1423 found = true; 1424 break; 1425 } 1426 if (portIndex == kPortIndexOutput 1427 && compressionFormat == format.eCompressionFormat) { 1428 // eColorFormat does not seem right. 1429 found = true; 1430 break; 1431 } 1432 } 1433 1434 if (format.eCompressionFormat == compressionFormat 1435 && format.eColorFormat == colorFormat) { 1436 found = true; 1437 break; 1438 } 1439 1440 ++index; 1441 } 1442 1443 if (!found) { 1444 return UNKNOWN_ERROR; 1445 } 1446 1447 status_t err = mOMX->setParameter( 1448 mNode, OMX_IndexParamVideoPortFormat, 1449 &format, sizeof(format)); 1450 1451 return err; 1452} 1453 1454status_t ACodec::setSupportedOutputFormat() { 1455 OMX_VIDEO_PARAM_PORTFORMATTYPE format; 1456 InitOMXParams(&format); 1457 format.nPortIndex = kPortIndexOutput; 1458 format.nIndex = 0; 1459 1460 status_t err = mOMX->getParameter( 1461 mNode, OMX_IndexParamVideoPortFormat, 1462 &format, sizeof(format)); 1463 CHECK_EQ(err, (status_t)OK); 1464 CHECK_EQ((int)format.eCompressionFormat, (int)OMX_VIDEO_CodingUnused); 1465 1466 return mOMX->setParameter( 1467 mNode, OMX_IndexParamVideoPortFormat, 1468 &format, sizeof(format)); 1469} 1470 1471static const struct VideoCodingMapEntry { 1472 const char *mMime; 1473 OMX_VIDEO_CODINGTYPE mVideoCodingType; 1474} kVideoCodingMapEntry[] = { 1475 { MEDIA_MIMETYPE_VIDEO_AVC, OMX_VIDEO_CodingAVC }, 1476 { MEDIA_MIMETYPE_VIDEO_MPEG4, OMX_VIDEO_CodingMPEG4 }, 1477 { MEDIA_MIMETYPE_VIDEO_H263, OMX_VIDEO_CodingH263 }, 1478 { MEDIA_MIMETYPE_VIDEO_MPEG2, OMX_VIDEO_CodingMPEG2 }, 1479 { MEDIA_MIMETYPE_VIDEO_VPX, OMX_VIDEO_CodingVPX }, 1480}; 1481 1482static status_t GetVideoCodingTypeFromMime( 1483 const char *mime, OMX_VIDEO_CODINGTYPE *codingType) { 1484 for (size_t i = 0; 1485 i < sizeof(kVideoCodingMapEntry) / sizeof(kVideoCodingMapEntry[0]); 1486 ++i) { 1487 if (!strcasecmp(mime, kVideoCodingMapEntry[i].mMime)) { 1488 *codingType = kVideoCodingMapEntry[i].mVideoCodingType; 1489 return OK; 1490 } 1491 } 1492 1493 *codingType = OMX_VIDEO_CodingUnused; 1494 1495 return ERROR_UNSUPPORTED; 1496} 1497 1498static status_t GetMimeTypeForVideoCoding( 1499 OMX_VIDEO_CODINGTYPE codingType, AString *mime) { 1500 for (size_t i = 0; 1501 i < sizeof(kVideoCodingMapEntry) / sizeof(kVideoCodingMapEntry[0]); 1502 ++i) { 1503 if (codingType == kVideoCodingMapEntry[i].mVideoCodingType) { 1504 *mime = kVideoCodingMapEntry[i].mMime; 1505 return OK; 1506 } 1507 } 1508 1509 mime->clear(); 1510 1511 return ERROR_UNSUPPORTED; 1512} 1513 1514status_t ACodec::setupVideoDecoder( 1515 const char *mime, int32_t width, int32_t height) { 1516 OMX_VIDEO_CODINGTYPE compressionFormat; 1517 status_t err = GetVideoCodingTypeFromMime(mime, &compressionFormat); 1518 1519 if (err != OK) { 1520 return err; 1521 } 1522 1523 err = setVideoPortFormatType( 1524 kPortIndexInput, compressionFormat, OMX_COLOR_FormatUnused); 1525 1526 if (err != OK) { 1527 return err; 1528 } 1529 1530 err = setSupportedOutputFormat(); 1531 1532 if (err != OK) { 1533 return err; 1534 } 1535 1536 err = setVideoFormatOnPort( 1537 kPortIndexInput, width, height, compressionFormat); 1538 1539 if (err != OK) { 1540 return err; 1541 } 1542 1543 err = setVideoFormatOnPort( 1544 kPortIndexOutput, width, height, OMX_VIDEO_CodingUnused); 1545 1546 if (err != OK) { 1547 return err; 1548 } 1549 1550 return OK; 1551} 1552 1553status_t ACodec::setupVideoEncoder(const char *mime, const sp<AMessage> &msg) { 1554 int32_t tmp; 1555 if (!msg->findInt32("color-format", &tmp)) { 1556 return INVALID_OPERATION; 1557 } 1558 1559 OMX_COLOR_FORMATTYPE colorFormat = 1560 static_cast<OMX_COLOR_FORMATTYPE>(tmp); 1561 1562 status_t err = setVideoPortFormatType( 1563 kPortIndexInput, OMX_VIDEO_CodingUnused, colorFormat); 1564 1565 if (err != OK) { 1566 ALOGE("[%s] does not support color format %d", 1567 mComponentName.c_str(), colorFormat); 1568 1569 return err; 1570 } 1571 1572 /* Input port configuration */ 1573 1574 OMX_PARAM_PORTDEFINITIONTYPE def; 1575 InitOMXParams(&def); 1576 1577 OMX_VIDEO_PORTDEFINITIONTYPE *video_def = &def.format.video; 1578 1579 def.nPortIndex = kPortIndexInput; 1580 1581 err = mOMX->getParameter( 1582 mNode, OMX_IndexParamPortDefinition, &def, sizeof(def)); 1583 1584 if (err != OK) { 1585 return err; 1586 } 1587 1588 int32_t width, height, bitrate; 1589 if (!msg->findInt32("width", &width) 1590 || !msg->findInt32("height", &height) 1591 || !msg->findInt32("bitrate", &bitrate)) { 1592 return INVALID_OPERATION; 1593 } 1594 1595 video_def->nFrameWidth = width; 1596 video_def->nFrameHeight = height; 1597 1598 int32_t stride; 1599 if (!msg->findInt32("stride", &stride)) { 1600 stride = width; 1601 } 1602 1603 video_def->nStride = stride; 1604 1605 int32_t sliceHeight; 1606 if (!msg->findInt32("slice-height", &sliceHeight)) { 1607 sliceHeight = height; 1608 } 1609 1610 video_def->nSliceHeight = sliceHeight; 1611 1612 def.nBufferSize = (video_def->nStride * video_def->nSliceHeight * 3) / 2; 1613 1614 float frameRate; 1615 if (!msg->findFloat("frame-rate", &frameRate)) { 1616 int32_t tmp; 1617 if (!msg->findInt32("frame-rate", &tmp)) { 1618 return INVALID_OPERATION; 1619 } 1620 frameRate = (float)tmp; 1621 } 1622 1623 video_def->xFramerate = (OMX_U32)(frameRate * 65536.0f); 1624 video_def->eCompressionFormat = OMX_VIDEO_CodingUnused; 1625 video_def->eColorFormat = colorFormat; 1626 1627 err = mOMX->setParameter( 1628 mNode, OMX_IndexParamPortDefinition, &def, sizeof(def)); 1629 1630 if (err != OK) { 1631 ALOGE("[%s] failed to set input port definition parameters.", 1632 mComponentName.c_str()); 1633 1634 return err; 1635 } 1636 1637 /* Output port configuration */ 1638 1639 OMX_VIDEO_CODINGTYPE compressionFormat; 1640 err = GetVideoCodingTypeFromMime(mime, &compressionFormat); 1641 1642 if (err != OK) { 1643 return err; 1644 } 1645 1646 err = setVideoPortFormatType( 1647 kPortIndexOutput, compressionFormat, OMX_COLOR_FormatUnused); 1648 1649 if (err != OK) { 1650 ALOGE("[%s] does not support compression format %d", 1651 mComponentName.c_str(), compressionFormat); 1652 1653 return err; 1654 } 1655 1656 def.nPortIndex = kPortIndexOutput; 1657 1658 err = mOMX->getParameter( 1659 mNode, OMX_IndexParamPortDefinition, &def, sizeof(def)); 1660 1661 if (err != OK) { 1662 return err; 1663 } 1664 1665 video_def->nFrameWidth = width; 1666 video_def->nFrameHeight = height; 1667 video_def->xFramerate = 0; 1668 video_def->nBitrate = bitrate; 1669 video_def->eCompressionFormat = compressionFormat; 1670 video_def->eColorFormat = OMX_COLOR_FormatUnused; 1671 1672 err = mOMX->setParameter( 1673 mNode, OMX_IndexParamPortDefinition, &def, sizeof(def)); 1674 1675 if (err != OK) { 1676 ALOGE("[%s] failed to set output port definition parameters.", 1677 mComponentName.c_str()); 1678 1679 return err; 1680 } 1681 1682 switch (compressionFormat) { 1683 case OMX_VIDEO_CodingMPEG4: 1684 err = setupMPEG4EncoderParameters(msg); 1685 break; 1686 1687 case OMX_VIDEO_CodingH263: 1688 err = setupH263EncoderParameters(msg); 1689 break; 1690 1691 case OMX_VIDEO_CodingAVC: 1692 err = setupAVCEncoderParameters(msg); 1693 break; 1694 1695 default: 1696 break; 1697 } 1698 1699 ALOGI("setupVideoEncoder succeeded"); 1700 1701 return err; 1702} 1703 1704status_t ACodec::setCyclicIntraMacroblockRefresh(const sp<AMessage> &msg, int32_t mode) { 1705 OMX_VIDEO_PARAM_INTRAREFRESHTYPE params; 1706 InitOMXParams(¶ms); 1707 params.nPortIndex = kPortIndexOutput; 1708 1709 params.eRefreshMode = static_cast<OMX_VIDEO_INTRAREFRESHTYPE>(mode); 1710 1711 if (params.eRefreshMode == OMX_VIDEO_IntraRefreshCyclic || 1712 params.eRefreshMode == OMX_VIDEO_IntraRefreshBoth) { 1713 int32_t mbs; 1714 if (!msg->findInt32("intra-refresh-CIR-mbs", &mbs)) { 1715 return INVALID_OPERATION; 1716 } 1717 params.nCirMBs = mbs; 1718 } 1719 1720 if (params.eRefreshMode == OMX_VIDEO_IntraRefreshAdaptive || 1721 params.eRefreshMode == OMX_VIDEO_IntraRefreshBoth) { 1722 int32_t mbs; 1723 if (!msg->findInt32("intra-refresh-AIR-mbs", &mbs)) { 1724 return INVALID_OPERATION; 1725 } 1726 params.nAirMBs = mbs; 1727 1728 int32_t ref; 1729 if (!msg->findInt32("intra-refresh-AIR-ref", &ref)) { 1730 return INVALID_OPERATION; 1731 } 1732 params.nAirRef = ref; 1733 } 1734 1735 status_t err = mOMX->setParameter( 1736 mNode, OMX_IndexParamVideoIntraRefresh, 1737 ¶ms, sizeof(params)); 1738 return err; 1739} 1740 1741static OMX_U32 setPFramesSpacing(int32_t iFramesInterval, int32_t frameRate) { 1742 if (iFramesInterval < 0) { 1743 return 0xFFFFFFFF; 1744 } else if (iFramesInterval == 0) { 1745 return 0; 1746 } 1747 OMX_U32 ret = frameRate * iFramesInterval; 1748 CHECK(ret > 1); 1749 return ret; 1750} 1751 1752static OMX_VIDEO_CONTROLRATETYPE getBitrateMode(const sp<AMessage> &msg) { 1753 int32_t tmp; 1754 if (!msg->findInt32("bitrate-mode", &tmp)) { 1755 return OMX_Video_ControlRateVariable; 1756 } 1757 1758 return static_cast<OMX_VIDEO_CONTROLRATETYPE>(tmp); 1759} 1760 1761status_t ACodec::setupMPEG4EncoderParameters(const sp<AMessage> &msg) { 1762 int32_t bitrate, iFrameInterval; 1763 if (!msg->findInt32("bitrate", &bitrate) 1764 || !msg->findInt32("i-frame-interval", &iFrameInterval)) { 1765 return INVALID_OPERATION; 1766 } 1767 1768 OMX_VIDEO_CONTROLRATETYPE bitrateMode = getBitrateMode(msg); 1769 1770 float frameRate; 1771 if (!msg->findFloat("frame-rate", &frameRate)) { 1772 int32_t tmp; 1773 if (!msg->findInt32("frame-rate", &tmp)) { 1774 return INVALID_OPERATION; 1775 } 1776 frameRate = (float)tmp; 1777 } 1778 1779 OMX_VIDEO_PARAM_MPEG4TYPE mpeg4type; 1780 InitOMXParams(&mpeg4type); 1781 mpeg4type.nPortIndex = kPortIndexOutput; 1782 1783 status_t err = mOMX->getParameter( 1784 mNode, OMX_IndexParamVideoMpeg4, &mpeg4type, sizeof(mpeg4type)); 1785 1786 if (err != OK) { 1787 return err; 1788 } 1789 1790 mpeg4type.nSliceHeaderSpacing = 0; 1791 mpeg4type.bSVH = OMX_FALSE; 1792 mpeg4type.bGov = OMX_FALSE; 1793 1794 mpeg4type.nAllowedPictureTypes = 1795 OMX_VIDEO_PictureTypeI | OMX_VIDEO_PictureTypeP; 1796 1797 mpeg4type.nPFrames = setPFramesSpacing(iFrameInterval, frameRate); 1798 if (mpeg4type.nPFrames == 0) { 1799 mpeg4type.nAllowedPictureTypes = OMX_VIDEO_PictureTypeI; 1800 } 1801 mpeg4type.nBFrames = 0; 1802 mpeg4type.nIDCVLCThreshold = 0; 1803 mpeg4type.bACPred = OMX_TRUE; 1804 mpeg4type.nMaxPacketSize = 256; 1805 mpeg4type.nTimeIncRes = 1000; 1806 mpeg4type.nHeaderExtension = 0; 1807 mpeg4type.bReversibleVLC = OMX_FALSE; 1808 1809 int32_t profile; 1810 if (msg->findInt32("profile", &profile)) { 1811 int32_t level; 1812 if (!msg->findInt32("level", &level)) { 1813 return INVALID_OPERATION; 1814 } 1815 1816 err = verifySupportForProfileAndLevel(profile, level); 1817 1818 if (err != OK) { 1819 return err; 1820 } 1821 1822 mpeg4type.eProfile = static_cast<OMX_VIDEO_MPEG4PROFILETYPE>(profile); 1823 mpeg4type.eLevel = static_cast<OMX_VIDEO_MPEG4LEVELTYPE>(level); 1824 } 1825 1826 err = mOMX->setParameter( 1827 mNode, OMX_IndexParamVideoMpeg4, &mpeg4type, sizeof(mpeg4type)); 1828 1829 if (err != OK) { 1830 return err; 1831 } 1832 1833 err = configureBitrate(bitrate, bitrateMode); 1834 1835 if (err != OK) { 1836 return err; 1837 } 1838 1839 return setupErrorCorrectionParameters(); 1840} 1841 1842status_t ACodec::setupH263EncoderParameters(const sp<AMessage> &msg) { 1843 int32_t bitrate, iFrameInterval; 1844 if (!msg->findInt32("bitrate", &bitrate) 1845 || !msg->findInt32("i-frame-interval", &iFrameInterval)) { 1846 return INVALID_OPERATION; 1847 } 1848 1849 OMX_VIDEO_CONTROLRATETYPE bitrateMode = getBitrateMode(msg); 1850 1851 float frameRate; 1852 if (!msg->findFloat("frame-rate", &frameRate)) { 1853 int32_t tmp; 1854 if (!msg->findInt32("frame-rate", &tmp)) { 1855 return INVALID_OPERATION; 1856 } 1857 frameRate = (float)tmp; 1858 } 1859 1860 OMX_VIDEO_PARAM_H263TYPE h263type; 1861 InitOMXParams(&h263type); 1862 h263type.nPortIndex = kPortIndexOutput; 1863 1864 status_t err = mOMX->getParameter( 1865 mNode, OMX_IndexParamVideoH263, &h263type, sizeof(h263type)); 1866 1867 if (err != OK) { 1868 return err; 1869 } 1870 1871 h263type.nAllowedPictureTypes = 1872 OMX_VIDEO_PictureTypeI | OMX_VIDEO_PictureTypeP; 1873 1874 h263type.nPFrames = setPFramesSpacing(iFrameInterval, frameRate); 1875 if (h263type.nPFrames == 0) { 1876 h263type.nAllowedPictureTypes = OMX_VIDEO_PictureTypeI; 1877 } 1878 h263type.nBFrames = 0; 1879 1880 int32_t profile; 1881 if (msg->findInt32("profile", &profile)) { 1882 int32_t level; 1883 if (!msg->findInt32("level", &level)) { 1884 return INVALID_OPERATION; 1885 } 1886 1887 err = verifySupportForProfileAndLevel(profile, level); 1888 1889 if (err != OK) { 1890 return err; 1891 } 1892 1893 h263type.eProfile = static_cast<OMX_VIDEO_H263PROFILETYPE>(profile); 1894 h263type.eLevel = static_cast<OMX_VIDEO_H263LEVELTYPE>(level); 1895 } 1896 1897 h263type.bPLUSPTYPEAllowed = OMX_FALSE; 1898 h263type.bForceRoundingTypeToZero = OMX_FALSE; 1899 h263type.nPictureHeaderRepetition = 0; 1900 h263type.nGOBHeaderInterval = 0; 1901 1902 err = mOMX->setParameter( 1903 mNode, OMX_IndexParamVideoH263, &h263type, sizeof(h263type)); 1904 1905 if (err != OK) { 1906 return err; 1907 } 1908 1909 err = configureBitrate(bitrate, bitrateMode); 1910 1911 if (err != OK) { 1912 return err; 1913 } 1914 1915 return setupErrorCorrectionParameters(); 1916} 1917 1918status_t ACodec::setupAVCEncoderParameters(const sp<AMessage> &msg) { 1919 int32_t bitrate, iFrameInterval; 1920 if (!msg->findInt32("bitrate", &bitrate) 1921 || !msg->findInt32("i-frame-interval", &iFrameInterval)) { 1922 return INVALID_OPERATION; 1923 } 1924 1925 OMX_VIDEO_CONTROLRATETYPE bitrateMode = getBitrateMode(msg); 1926 1927 float frameRate; 1928 if (!msg->findFloat("frame-rate", &frameRate)) { 1929 int32_t tmp; 1930 if (!msg->findInt32("frame-rate", &tmp)) { 1931 return INVALID_OPERATION; 1932 } 1933 frameRate = (float)tmp; 1934 } 1935 1936 status_t err = OK; 1937 int32_t intraRefreshMode = 0; 1938 if (msg->findInt32("intra-refresh-mode", &intraRefreshMode)) { 1939 err = setCyclicIntraMacroblockRefresh(msg, intraRefreshMode); 1940 if (err != OK) { 1941 ALOGE("Setting intra macroblock refresh mode (%d) failed: 0x%x", 1942 err, intraRefreshMode); 1943 return err; 1944 } 1945 } 1946 1947 OMX_VIDEO_PARAM_AVCTYPE h264type; 1948 InitOMXParams(&h264type); 1949 h264type.nPortIndex = kPortIndexOutput; 1950 1951 err = mOMX->getParameter( 1952 mNode, OMX_IndexParamVideoAvc, &h264type, sizeof(h264type)); 1953 1954 if (err != OK) { 1955 return err; 1956 } 1957 1958 h264type.nAllowedPictureTypes = 1959 OMX_VIDEO_PictureTypeI | OMX_VIDEO_PictureTypeP; 1960 1961 int32_t profile; 1962 if (msg->findInt32("profile", &profile)) { 1963 int32_t level; 1964 if (!msg->findInt32("level", &level)) { 1965 return INVALID_OPERATION; 1966 } 1967 1968 err = verifySupportForProfileAndLevel(profile, level); 1969 1970 if (err != OK) { 1971 return err; 1972 } 1973 1974 h264type.eProfile = static_cast<OMX_VIDEO_AVCPROFILETYPE>(profile); 1975 h264type.eLevel = static_cast<OMX_VIDEO_AVCLEVELTYPE>(level); 1976 } 1977 1978 // XXX 1979 if (h264type.eProfile != OMX_VIDEO_AVCProfileBaseline) { 1980 ALOGW("Use baseline profile instead of %d for AVC recording", 1981 h264type.eProfile); 1982 h264type.eProfile = OMX_VIDEO_AVCProfileBaseline; 1983 } 1984 1985 if (h264type.eProfile == OMX_VIDEO_AVCProfileBaseline) { 1986 h264type.nSliceHeaderSpacing = 0; 1987 h264type.bUseHadamard = OMX_TRUE; 1988 h264type.nRefFrames = 1; 1989 h264type.nBFrames = 0; 1990 h264type.nPFrames = setPFramesSpacing(iFrameInterval, frameRate); 1991 if (h264type.nPFrames == 0) { 1992 h264type.nAllowedPictureTypes = OMX_VIDEO_PictureTypeI; 1993 } 1994 h264type.nRefIdx10ActiveMinus1 = 0; 1995 h264type.nRefIdx11ActiveMinus1 = 0; 1996 h264type.bEntropyCodingCABAC = OMX_FALSE; 1997 h264type.bWeightedPPrediction = OMX_FALSE; 1998 h264type.bconstIpred = OMX_FALSE; 1999 h264type.bDirect8x8Inference = OMX_FALSE; 2000 h264type.bDirectSpatialTemporal = OMX_FALSE; 2001 h264type.nCabacInitIdc = 0; 2002 } 2003 2004 if (h264type.nBFrames != 0) { 2005 h264type.nAllowedPictureTypes |= OMX_VIDEO_PictureTypeB; 2006 } 2007 2008 h264type.bEnableUEP = OMX_FALSE; 2009 h264type.bEnableFMO = OMX_FALSE; 2010 h264type.bEnableASO = OMX_FALSE; 2011 h264type.bEnableRS = OMX_FALSE; 2012 h264type.bFrameMBsOnly = OMX_TRUE; 2013 h264type.bMBAFF = OMX_FALSE; 2014 h264type.eLoopFilterMode = OMX_VIDEO_AVCLoopFilterEnable; 2015 2016 err = mOMX->setParameter( 2017 mNode, OMX_IndexParamVideoAvc, &h264type, sizeof(h264type)); 2018 2019 if (err != OK) { 2020 return err; 2021 } 2022 2023 return configureBitrate(bitrate, bitrateMode); 2024} 2025 2026status_t ACodec::verifySupportForProfileAndLevel( 2027 int32_t profile, int32_t level) { 2028 OMX_VIDEO_PARAM_PROFILELEVELTYPE params; 2029 InitOMXParams(¶ms); 2030 params.nPortIndex = kPortIndexOutput; 2031 2032 for (params.nProfileIndex = 0;; ++params.nProfileIndex) { 2033 status_t err = mOMX->getParameter( 2034 mNode, 2035 OMX_IndexParamVideoProfileLevelQuerySupported, 2036 ¶ms, 2037 sizeof(params)); 2038 2039 if (err != OK) { 2040 return err; 2041 } 2042 2043 int32_t supportedProfile = static_cast<int32_t>(params.eProfile); 2044 int32_t supportedLevel = static_cast<int32_t>(params.eLevel); 2045 2046 if (profile == supportedProfile && level <= supportedLevel) { 2047 return OK; 2048 } 2049 } 2050} 2051 2052status_t ACodec::configureBitrate( 2053 int32_t bitrate, OMX_VIDEO_CONTROLRATETYPE bitrateMode) { 2054 OMX_VIDEO_PARAM_BITRATETYPE bitrateType; 2055 InitOMXParams(&bitrateType); 2056 bitrateType.nPortIndex = kPortIndexOutput; 2057 2058 status_t err = mOMX->getParameter( 2059 mNode, OMX_IndexParamVideoBitrate, 2060 &bitrateType, sizeof(bitrateType)); 2061 2062 if (err != OK) { 2063 return err; 2064 } 2065 2066 bitrateType.eControlRate = bitrateMode; 2067 bitrateType.nTargetBitrate = bitrate; 2068 2069 return mOMX->setParameter( 2070 mNode, OMX_IndexParamVideoBitrate, 2071 &bitrateType, sizeof(bitrateType)); 2072} 2073 2074status_t ACodec::setupErrorCorrectionParameters() { 2075 OMX_VIDEO_PARAM_ERRORCORRECTIONTYPE errorCorrectionType; 2076 InitOMXParams(&errorCorrectionType); 2077 errorCorrectionType.nPortIndex = kPortIndexOutput; 2078 2079 status_t err = mOMX->getParameter( 2080 mNode, OMX_IndexParamVideoErrorCorrection, 2081 &errorCorrectionType, sizeof(errorCorrectionType)); 2082 2083 if (err != OK) { 2084 return OK; // Optional feature. Ignore this failure 2085 } 2086 2087 errorCorrectionType.bEnableHEC = OMX_FALSE; 2088 errorCorrectionType.bEnableResync = OMX_TRUE; 2089 errorCorrectionType.nResynchMarkerSpacing = 256; 2090 errorCorrectionType.bEnableDataPartitioning = OMX_FALSE; 2091 errorCorrectionType.bEnableRVLC = OMX_FALSE; 2092 2093 return mOMX->setParameter( 2094 mNode, OMX_IndexParamVideoErrorCorrection, 2095 &errorCorrectionType, sizeof(errorCorrectionType)); 2096} 2097 2098status_t ACodec::setVideoFormatOnPort( 2099 OMX_U32 portIndex, 2100 int32_t width, int32_t height, OMX_VIDEO_CODINGTYPE compressionFormat) { 2101 OMX_PARAM_PORTDEFINITIONTYPE def; 2102 InitOMXParams(&def); 2103 def.nPortIndex = portIndex; 2104 2105 OMX_VIDEO_PORTDEFINITIONTYPE *video_def = &def.format.video; 2106 2107 status_t err = mOMX->getParameter( 2108 mNode, OMX_IndexParamPortDefinition, &def, sizeof(def)); 2109 2110 CHECK_EQ(err, (status_t)OK); 2111 2112 if (portIndex == kPortIndexInput) { 2113 // XXX Need a (much) better heuristic to compute input buffer sizes. 2114 const size_t X = 64 * 1024; 2115 if (def.nBufferSize < X) { 2116 def.nBufferSize = X; 2117 } 2118 } 2119 2120 CHECK_EQ((int)def.eDomain, (int)OMX_PortDomainVideo); 2121 2122 video_def->nFrameWidth = width; 2123 video_def->nFrameHeight = height; 2124 2125 if (portIndex == kPortIndexInput) { 2126 video_def->eCompressionFormat = compressionFormat; 2127 video_def->eColorFormat = OMX_COLOR_FormatUnused; 2128 } 2129 2130 err = mOMX->setParameter( 2131 mNode, OMX_IndexParamPortDefinition, &def, sizeof(def)); 2132 2133 return err; 2134} 2135 2136status_t ACodec::initNativeWindow() { 2137 if (mNativeWindow != NULL) { 2138 return mOMX->enableGraphicBuffers(mNode, kPortIndexOutput, OMX_TRUE); 2139 } 2140 2141 mOMX->enableGraphicBuffers(mNode, kPortIndexOutput, OMX_FALSE); 2142 return OK; 2143} 2144 2145size_t ACodec::countBuffersOwnedByComponent(OMX_U32 portIndex) const { 2146 size_t n = 0; 2147 2148 for (size_t i = 0; i < mBuffers[portIndex].size(); ++i) { 2149 const BufferInfo &info = mBuffers[portIndex].itemAt(i); 2150 2151 if (info.mStatus == BufferInfo::OWNED_BY_COMPONENT) { 2152 ++n; 2153 } 2154 } 2155 2156 return n; 2157} 2158 2159size_t ACodec::countBuffersOwnedByNativeWindow() const { 2160 size_t n = 0; 2161 2162 for (size_t i = 0; i < mBuffers[kPortIndexOutput].size(); ++i) { 2163 const BufferInfo &info = mBuffers[kPortIndexOutput].itemAt(i); 2164 2165 if (info.mStatus == BufferInfo::OWNED_BY_NATIVE_WINDOW) { 2166 ++n; 2167 } 2168 } 2169 2170 return n; 2171} 2172 2173void ACodec::waitUntilAllPossibleNativeWindowBuffersAreReturnedToUs() { 2174 if (mNativeWindow == NULL) { 2175 return; 2176 } 2177 2178 int minUndequeuedBufs = 0; 2179 status_t err = mNativeWindow->query( 2180 mNativeWindow.get(), NATIVE_WINDOW_MIN_UNDEQUEUED_BUFFERS, 2181 &minUndequeuedBufs); 2182 2183 if (err != OK) { 2184 ALOGE("[%s] NATIVE_WINDOW_MIN_UNDEQUEUED_BUFFERS query failed: %s (%d)", 2185 mComponentName.c_str(), strerror(-err), -err); 2186 2187 minUndequeuedBufs = 0; 2188 } 2189 2190 while (countBuffersOwnedByNativeWindow() > (size_t)minUndequeuedBufs 2191 && dequeueBufferFromNativeWindow() != NULL) { 2192 } 2193} 2194 2195bool ACodec::allYourBuffersAreBelongToUs( 2196 OMX_U32 portIndex) { 2197 for (size_t i = 0; i < mBuffers[portIndex].size(); ++i) { 2198 BufferInfo *info = &mBuffers[portIndex].editItemAt(i); 2199 2200 if (info->mStatus != BufferInfo::OWNED_BY_US 2201 && info->mStatus != BufferInfo::OWNED_BY_NATIVE_WINDOW) { 2202 ALOGV("[%s] Buffer %p on port %ld still has status %d", 2203 mComponentName.c_str(), 2204 info->mBufferID, portIndex, info->mStatus); 2205 return false; 2206 } 2207 } 2208 2209 return true; 2210} 2211 2212bool ACodec::allYourBuffersAreBelongToUs() { 2213 return allYourBuffersAreBelongToUs(kPortIndexInput) 2214 && allYourBuffersAreBelongToUs(kPortIndexOutput); 2215} 2216 2217void ACodec::deferMessage(const sp<AMessage> &msg) { 2218 bool wasEmptyBefore = mDeferredQueue.empty(); 2219 mDeferredQueue.push_back(msg); 2220} 2221 2222void ACodec::processDeferredMessages() { 2223 List<sp<AMessage> > queue = mDeferredQueue; 2224 mDeferredQueue.clear(); 2225 2226 List<sp<AMessage> >::iterator it = queue.begin(); 2227 while (it != queue.end()) { 2228 onMessageReceived(*it++); 2229 } 2230} 2231 2232void ACodec::sendFormatChange() { 2233 sp<AMessage> notify = mNotify->dup(); 2234 notify->setInt32("what", kWhatOutputFormatChanged); 2235 2236 OMX_PARAM_PORTDEFINITIONTYPE def; 2237 InitOMXParams(&def); 2238 def.nPortIndex = kPortIndexOutput; 2239 2240 CHECK_EQ(mOMX->getParameter( 2241 mNode, OMX_IndexParamPortDefinition, &def, sizeof(def)), 2242 (status_t)OK); 2243 2244 CHECK_EQ((int)def.eDir, (int)OMX_DirOutput); 2245 2246 switch (def.eDomain) { 2247 case OMX_PortDomainVideo: 2248 { 2249 OMX_VIDEO_PORTDEFINITIONTYPE *videoDef = &def.format.video; 2250 2251 AString mime; 2252 if (!mIsEncoder) { 2253 notify->setString("mime", MEDIA_MIMETYPE_VIDEO_RAW); 2254 } else if (GetMimeTypeForVideoCoding( 2255 videoDef->eCompressionFormat, &mime) != OK) { 2256 notify->setString("mime", "application/octet-stream"); 2257 } else { 2258 notify->setString("mime", mime.c_str()); 2259 } 2260 2261 notify->setInt32("width", videoDef->nFrameWidth); 2262 notify->setInt32("height", videoDef->nFrameHeight); 2263 2264 if (!mIsEncoder) { 2265 notify->setInt32("stride", videoDef->nStride); 2266 notify->setInt32("slice-height", videoDef->nSliceHeight); 2267 notify->setInt32("color-format", videoDef->eColorFormat); 2268 2269 OMX_CONFIG_RECTTYPE rect; 2270 InitOMXParams(&rect); 2271 rect.nPortIndex = kPortIndexOutput; 2272 2273 if (mOMX->getConfig( 2274 mNode, OMX_IndexConfigCommonOutputCrop, 2275 &rect, sizeof(rect)) != OK) { 2276 rect.nLeft = 0; 2277 rect.nTop = 0; 2278 rect.nWidth = videoDef->nFrameWidth; 2279 rect.nHeight = videoDef->nFrameHeight; 2280 } 2281 2282 CHECK_GE(rect.nLeft, 0); 2283 CHECK_GE(rect.nTop, 0); 2284 CHECK_GE(rect.nWidth, 0u); 2285 CHECK_GE(rect.nHeight, 0u); 2286 CHECK_LE(rect.nLeft + rect.nWidth - 1, videoDef->nFrameWidth); 2287 CHECK_LE(rect.nTop + rect.nHeight - 1, videoDef->nFrameHeight); 2288 2289 notify->setRect( 2290 "crop", 2291 rect.nLeft, 2292 rect.nTop, 2293 rect.nLeft + rect.nWidth - 1, 2294 rect.nTop + rect.nHeight - 1); 2295 2296 if (mNativeWindow != NULL) { 2297 android_native_rect_t crop; 2298 crop.left = rect.nLeft; 2299 crop.top = rect.nTop; 2300 crop.right = rect.nLeft + rect.nWidth; 2301 crop.bottom = rect.nTop + rect.nHeight; 2302 2303 CHECK_EQ(0, native_window_set_crop( 2304 mNativeWindow.get(), &crop)); 2305 } 2306 } 2307 break; 2308 } 2309 2310 case OMX_PortDomainAudio: 2311 { 2312 OMX_AUDIO_PORTDEFINITIONTYPE *audioDef = &def.format.audio; 2313 2314 switch (audioDef->eEncoding) { 2315 case OMX_AUDIO_CodingPCM: 2316 { 2317 OMX_AUDIO_PARAM_PCMMODETYPE params; 2318 InitOMXParams(¶ms); 2319 params.nPortIndex = kPortIndexOutput; 2320 2321 CHECK_EQ(mOMX->getParameter( 2322 mNode, OMX_IndexParamAudioPcm, 2323 ¶ms, sizeof(params)), 2324 (status_t)OK); 2325 2326 CHECK(params.nChannels == 1 || params.bInterleaved); 2327 CHECK_EQ(params.nBitPerSample, 16u); 2328 CHECK_EQ((int)params.eNumData, (int)OMX_NumericalDataSigned); 2329 CHECK_EQ((int)params.ePCMMode, (int)OMX_AUDIO_PCMModeLinear); 2330 2331 notify->setString("mime", MEDIA_MIMETYPE_AUDIO_RAW); 2332 notify->setInt32("channel-count", params.nChannels); 2333 notify->setInt32("sample-rate", params.nSamplingRate); 2334 if (mEncoderDelay + mEncoderPadding) { 2335 size_t frameSize = params.nChannels * sizeof(int16_t); 2336 if (mSkipCutBuffer != NULL) { 2337 size_t prevbufsize = mSkipCutBuffer->size(); 2338 if (prevbufsize != 0) { 2339 ALOGW("Replacing SkipCutBuffer holding %d bytes", prevbufsize); 2340 } 2341 } 2342 mSkipCutBuffer = new SkipCutBuffer(mEncoderDelay * frameSize, 2343 mEncoderPadding * frameSize); 2344 } 2345 2346 if (mChannelMaskPresent) { 2347 notify->setInt32("channel-mask", mChannelMask); 2348 } 2349 break; 2350 } 2351 2352 case OMX_AUDIO_CodingAAC: 2353 { 2354 OMX_AUDIO_PARAM_AACPROFILETYPE params; 2355 InitOMXParams(¶ms); 2356 params.nPortIndex = kPortIndexOutput; 2357 2358 CHECK_EQ(mOMX->getParameter( 2359 mNode, OMX_IndexParamAudioAac, 2360 ¶ms, sizeof(params)), 2361 (status_t)OK); 2362 2363 notify->setString("mime", MEDIA_MIMETYPE_AUDIO_AAC); 2364 notify->setInt32("channel-count", params.nChannels); 2365 notify->setInt32("sample-rate", params.nSampleRate); 2366 break; 2367 } 2368 2369 case OMX_AUDIO_CodingAMR: 2370 { 2371 OMX_AUDIO_PARAM_AMRTYPE params; 2372 InitOMXParams(¶ms); 2373 params.nPortIndex = kPortIndexOutput; 2374 2375 CHECK_EQ(mOMX->getParameter( 2376 mNode, OMX_IndexParamAudioAmr, 2377 ¶ms, sizeof(params)), 2378 (status_t)OK); 2379 2380 notify->setInt32("channel-count", 1); 2381 if (params.eAMRBandMode >= OMX_AUDIO_AMRBandModeWB0) { 2382 notify->setString( 2383 "mime", MEDIA_MIMETYPE_AUDIO_AMR_WB); 2384 2385 notify->setInt32("sample-rate", 16000); 2386 } else { 2387 notify->setString( 2388 "mime", MEDIA_MIMETYPE_AUDIO_AMR_NB); 2389 2390 notify->setInt32("sample-rate", 8000); 2391 } 2392 break; 2393 } 2394 2395 case OMX_AUDIO_CodingFLAC: 2396 { 2397 OMX_AUDIO_PARAM_FLACTYPE params; 2398 InitOMXParams(¶ms); 2399 params.nPortIndex = kPortIndexOutput; 2400 2401 CHECK_EQ(mOMX->getParameter( 2402 mNode, OMX_IndexParamAudioFlac, 2403 ¶ms, sizeof(params)), 2404 (status_t)OK); 2405 2406 notify->setString("mime", MEDIA_MIMETYPE_AUDIO_FLAC); 2407 notify->setInt32("channel-count", params.nChannels); 2408 notify->setInt32("sample-rate", params.nSampleRate); 2409 break; 2410 } 2411 2412 default: 2413 TRESPASS(); 2414 } 2415 break; 2416 } 2417 2418 default: 2419 TRESPASS(); 2420 } 2421 2422 notify->post(); 2423 2424 mSentFormat = true; 2425} 2426 2427void ACodec::signalError(OMX_ERRORTYPE error, status_t internalError) { 2428 sp<AMessage> notify = mNotify->dup(); 2429 notify->setInt32("what", ACodec::kWhatError); 2430 notify->setInt32("omx-error", error); 2431 notify->setInt32("err", internalError); 2432 notify->post(); 2433} 2434 2435status_t ACodec::pushBlankBuffersToNativeWindow() { 2436 status_t err = NO_ERROR; 2437 ANativeWindowBuffer* anb = NULL; 2438 int numBufs = 0; 2439 int minUndequeuedBufs = 0; 2440 2441 // We need to reconnect to the ANativeWindow as a CPU client to ensure that 2442 // no frames get dropped by SurfaceFlinger assuming that these are video 2443 // frames. 2444 err = native_window_api_disconnect(mNativeWindow.get(), 2445 NATIVE_WINDOW_API_MEDIA); 2446 if (err != NO_ERROR) { 2447 ALOGE("error pushing blank frames: api_disconnect failed: %s (%d)", 2448 strerror(-err), -err); 2449 return err; 2450 } 2451 2452 err = native_window_api_connect(mNativeWindow.get(), 2453 NATIVE_WINDOW_API_CPU); 2454 if (err != NO_ERROR) { 2455 ALOGE("error pushing blank frames: api_connect failed: %s (%d)", 2456 strerror(-err), -err); 2457 return err; 2458 } 2459 2460 err = native_window_set_buffers_geometry(mNativeWindow.get(), 1, 1, 2461 HAL_PIXEL_FORMAT_RGBX_8888); 2462 if (err != NO_ERROR) { 2463 ALOGE("error pushing blank frames: set_buffers_geometry failed: %s (%d)", 2464 strerror(-err), -err); 2465 goto error; 2466 } 2467 2468 err = native_window_set_usage(mNativeWindow.get(), 2469 GRALLOC_USAGE_SW_WRITE_OFTEN); 2470 if (err != NO_ERROR) { 2471 ALOGE("error pushing blank frames: set_usage failed: %s (%d)", 2472 strerror(-err), -err); 2473 goto error; 2474 } 2475 2476 err = mNativeWindow->query(mNativeWindow.get(), 2477 NATIVE_WINDOW_MIN_UNDEQUEUED_BUFFERS, &minUndequeuedBufs); 2478 if (err != NO_ERROR) { 2479 ALOGE("error pushing blank frames: MIN_UNDEQUEUED_BUFFERS query " 2480 "failed: %s (%d)", strerror(-err), -err); 2481 goto error; 2482 } 2483 2484 numBufs = minUndequeuedBufs + 1; 2485 err = native_window_set_buffer_count(mNativeWindow.get(), numBufs); 2486 if (err != NO_ERROR) { 2487 ALOGE("error pushing blank frames: set_buffer_count failed: %s (%d)", 2488 strerror(-err), -err); 2489 goto error; 2490 } 2491 2492 // We push numBufs + 1 buffers to ensure that we've drawn into the same 2493 // buffer twice. This should guarantee that the buffer has been displayed 2494 // on the screen and then been replaced, so an previous video frames are 2495 // guaranteed NOT to be currently displayed. 2496 for (int i = 0; i < numBufs + 1; i++) { 2497 int fenceFd = -1; 2498 err = native_window_dequeue_buffer_and_wait(mNativeWindow.get(), &anb); 2499 if (err != NO_ERROR) { 2500 ALOGE("error pushing blank frames: dequeueBuffer failed: %s (%d)", 2501 strerror(-err), -err); 2502 goto error; 2503 } 2504 2505 sp<GraphicBuffer> buf(new GraphicBuffer(anb, false)); 2506 2507 // Fill the buffer with the a 1x1 checkerboard pattern ;) 2508 uint32_t* img = NULL; 2509 err = buf->lock(GRALLOC_USAGE_SW_WRITE_OFTEN, (void**)(&img)); 2510 if (err != NO_ERROR) { 2511 ALOGE("error pushing blank frames: lock failed: %s (%d)", 2512 strerror(-err), -err); 2513 goto error; 2514 } 2515 2516 *img = 0; 2517 2518 err = buf->unlock(); 2519 if (err != NO_ERROR) { 2520 ALOGE("error pushing blank frames: unlock failed: %s (%d)", 2521 strerror(-err), -err); 2522 goto error; 2523 } 2524 2525 err = mNativeWindow->queueBuffer(mNativeWindow.get(), 2526 buf->getNativeBuffer(), -1); 2527 if (err != NO_ERROR) { 2528 ALOGE("error pushing blank frames: queueBuffer failed: %s (%d)", 2529 strerror(-err), -err); 2530 goto error; 2531 } 2532 2533 anb = NULL; 2534 } 2535 2536error: 2537 2538 if (err != NO_ERROR) { 2539 // Clean up after an error. 2540 if (anb != NULL) { 2541 mNativeWindow->cancelBuffer(mNativeWindow.get(), anb, -1); 2542 } 2543 2544 native_window_api_disconnect(mNativeWindow.get(), 2545 NATIVE_WINDOW_API_CPU); 2546 native_window_api_connect(mNativeWindow.get(), 2547 NATIVE_WINDOW_API_MEDIA); 2548 2549 return err; 2550 } else { 2551 // Clean up after success. 2552 err = native_window_api_disconnect(mNativeWindow.get(), 2553 NATIVE_WINDOW_API_CPU); 2554 if (err != NO_ERROR) { 2555 ALOGE("error pushing blank frames: api_disconnect failed: %s (%d)", 2556 strerror(-err), -err); 2557 return err; 2558 } 2559 2560 err = native_window_api_connect(mNativeWindow.get(), 2561 NATIVE_WINDOW_API_MEDIA); 2562 if (err != NO_ERROR) { 2563 ALOGE("error pushing blank frames: api_connect failed: %s (%d)", 2564 strerror(-err), -err); 2565 return err; 2566 } 2567 2568 return NO_ERROR; 2569 } 2570} 2571 2572//////////////////////////////////////////////////////////////////////////////// 2573 2574ACodec::PortDescription::PortDescription() { 2575} 2576 2577status_t ACodec::requestIDRFrame() { 2578 if (!mIsEncoder) { 2579 return ERROR_UNSUPPORTED; 2580 } 2581 2582 OMX_CONFIG_INTRAREFRESHVOPTYPE params; 2583 InitOMXParams(¶ms); 2584 2585 params.nPortIndex = kPortIndexOutput; 2586 params.IntraRefreshVOP = OMX_TRUE; 2587 2588 return mOMX->setConfig( 2589 mNode, 2590 OMX_IndexConfigVideoIntraVOPRefresh, 2591 ¶ms, 2592 sizeof(params)); 2593} 2594 2595void ACodec::PortDescription::addBuffer( 2596 IOMX::buffer_id id, const sp<ABuffer> &buffer) { 2597 mBufferIDs.push_back(id); 2598 mBuffers.push_back(buffer); 2599} 2600 2601size_t ACodec::PortDescription::countBuffers() { 2602 return mBufferIDs.size(); 2603} 2604 2605IOMX::buffer_id ACodec::PortDescription::bufferIDAt(size_t index) const { 2606 return mBufferIDs.itemAt(index); 2607} 2608 2609sp<ABuffer> ACodec::PortDescription::bufferAt(size_t index) const { 2610 return mBuffers.itemAt(index); 2611} 2612 2613//////////////////////////////////////////////////////////////////////////////// 2614 2615ACodec::BaseState::BaseState(ACodec *codec, const sp<AState> &parentState) 2616 : AState(parentState), 2617 mCodec(codec) { 2618} 2619 2620ACodec::BaseState::PortMode ACodec::BaseState::getPortMode(OMX_U32 portIndex) { 2621 return KEEP_BUFFERS; 2622} 2623 2624bool ACodec::BaseState::onMessageReceived(const sp<AMessage> &msg) { 2625 switch (msg->what()) { 2626 case kWhatInputBufferFilled: 2627 { 2628 onInputBufferFilled(msg); 2629 break; 2630 } 2631 2632 case kWhatOutputBufferDrained: 2633 { 2634 onOutputBufferDrained(msg); 2635 break; 2636 } 2637 2638 case ACodec::kWhatOMXMessage: 2639 { 2640 return onOMXMessage(msg); 2641 } 2642 2643 case ACodec::kWhatCreateInputSurface: 2644 case ACodec::kWhatSignalEndOfInputStream: 2645 { 2646 ALOGE("Message 0x%x was not handled", msg->what()); 2647 mCodec->signalError(OMX_ErrorUndefined, INVALID_OPERATION); 2648 return true; 2649 } 2650 2651 case ACodec::kWhatOMXDied: 2652 { 2653 ALOGE("OMX/mediaserver died, signalling error!"); 2654 mCodec->signalError(OMX_ErrorResourcesLost, DEAD_OBJECT); 2655 break; 2656 } 2657 2658 default: 2659 return false; 2660 } 2661 2662 return true; 2663} 2664 2665bool ACodec::BaseState::onOMXMessage(const sp<AMessage> &msg) { 2666 int32_t type; 2667 CHECK(msg->findInt32("type", &type)); 2668 2669 IOMX::node_id nodeID; 2670 CHECK(msg->findPointer("node", &nodeID)); 2671 CHECK_EQ(nodeID, mCodec->mNode); 2672 2673 switch (type) { 2674 case omx_message::EVENT: 2675 { 2676 int32_t event, data1, data2; 2677 CHECK(msg->findInt32("event", &event)); 2678 CHECK(msg->findInt32("data1", &data1)); 2679 CHECK(msg->findInt32("data2", &data2)); 2680 2681 if (event == OMX_EventCmdComplete 2682 && data1 == OMX_CommandFlush 2683 && data2 == (int32_t)OMX_ALL) { 2684 // Use of this notification is not consistent across 2685 // implementations. We'll drop this notification and rely 2686 // on flush-complete notifications on the individual port 2687 // indices instead. 2688 2689 return true; 2690 } 2691 2692 return onOMXEvent( 2693 static_cast<OMX_EVENTTYPE>(event), 2694 static_cast<OMX_U32>(data1), 2695 static_cast<OMX_U32>(data2)); 2696 } 2697 2698 case omx_message::EMPTY_BUFFER_DONE: 2699 { 2700 IOMX::buffer_id bufferID; 2701 CHECK(msg->findPointer("buffer", &bufferID)); 2702 2703 return onOMXEmptyBufferDone(bufferID); 2704 } 2705 2706 case omx_message::FILL_BUFFER_DONE: 2707 { 2708 IOMX::buffer_id bufferID; 2709 CHECK(msg->findPointer("buffer", &bufferID)); 2710 2711 int32_t rangeOffset, rangeLength, flags; 2712 int64_t timeUs; 2713 void *platformPrivate; 2714 void *dataPtr; 2715 2716 CHECK(msg->findInt32("range_offset", &rangeOffset)); 2717 CHECK(msg->findInt32("range_length", &rangeLength)); 2718 CHECK(msg->findInt32("flags", &flags)); 2719 CHECK(msg->findInt64("timestamp", &timeUs)); 2720 CHECK(msg->findPointer("platform_private", &platformPrivate)); 2721 CHECK(msg->findPointer("data_ptr", &dataPtr)); 2722 2723 return onOMXFillBufferDone( 2724 bufferID, 2725 (size_t)rangeOffset, (size_t)rangeLength, 2726 (OMX_U32)flags, 2727 timeUs, 2728 platformPrivate, 2729 dataPtr); 2730 } 2731 2732 default: 2733 TRESPASS(); 2734 break; 2735 } 2736} 2737 2738bool ACodec::BaseState::onOMXEvent( 2739 OMX_EVENTTYPE event, OMX_U32 data1, OMX_U32 data2) { 2740 if (event != OMX_EventError) { 2741 ALOGV("[%s] EVENT(%d, 0x%08lx, 0x%08lx)", 2742 mCodec->mComponentName.c_str(), event, data1, data2); 2743 2744 return false; 2745 } 2746 2747 ALOGE("[%s] ERROR(0x%08lx)", mCodec->mComponentName.c_str(), data1); 2748 2749 mCodec->signalError((OMX_ERRORTYPE)data1); 2750 2751 return true; 2752} 2753 2754bool ACodec::BaseState::onOMXEmptyBufferDone(IOMX::buffer_id bufferID) { 2755 ALOGV("[%s] onOMXEmptyBufferDone %p", 2756 mCodec->mComponentName.c_str(), bufferID); 2757 2758 BufferInfo *info = 2759 mCodec->findBufferByID(kPortIndexInput, bufferID); 2760 2761 CHECK_EQ((int)info->mStatus, (int)BufferInfo::OWNED_BY_COMPONENT); 2762 info->mStatus = BufferInfo::OWNED_BY_US; 2763 2764 const sp<AMessage> &bufferMeta = info->mData->meta(); 2765 void *mediaBuffer; 2766 if (bufferMeta->findPointer("mediaBuffer", &mediaBuffer) 2767 && mediaBuffer != NULL) { 2768 // We're in "store-metadata-in-buffers" mode, the underlying 2769 // OMX component had access to data that's implicitly refcounted 2770 // by this "mediaBuffer" object. Now that the OMX component has 2771 // told us that it's done with the input buffer, we can decrement 2772 // the mediaBuffer's reference count. 2773 2774 ALOGV("releasing mbuf %p", mediaBuffer); 2775 2776 ((MediaBuffer *)mediaBuffer)->release(); 2777 mediaBuffer = NULL; 2778 2779 bufferMeta->setPointer("mediaBuffer", NULL); 2780 } 2781 2782 PortMode mode = getPortMode(kPortIndexInput); 2783 2784 switch (mode) { 2785 case KEEP_BUFFERS: 2786 break; 2787 2788 case RESUBMIT_BUFFERS: 2789 postFillThisBuffer(info); 2790 break; 2791 2792 default: 2793 { 2794 CHECK_EQ((int)mode, (int)FREE_BUFFERS); 2795 TRESPASS(); // Not currently used 2796 break; 2797 } 2798 } 2799 2800 return true; 2801} 2802 2803void ACodec::BaseState::postFillThisBuffer(BufferInfo *info) { 2804 if (mCodec->mPortEOS[kPortIndexInput]) { 2805 return; 2806 } 2807 2808 CHECK_EQ((int)info->mStatus, (int)BufferInfo::OWNED_BY_US); 2809 2810 sp<AMessage> notify = mCodec->mNotify->dup(); 2811 notify->setInt32("what", ACodec::kWhatFillThisBuffer); 2812 notify->setPointer("buffer-id", info->mBufferID); 2813 2814 info->mData->meta()->clear(); 2815 notify->setBuffer("buffer", info->mData); 2816 2817 sp<AMessage> reply = new AMessage(kWhatInputBufferFilled, mCodec->id()); 2818 reply->setPointer("buffer-id", info->mBufferID); 2819 2820 notify->setMessage("reply", reply); 2821 2822 notify->post(); 2823 2824 info->mStatus = BufferInfo::OWNED_BY_UPSTREAM; 2825} 2826 2827void ACodec::BaseState::onInputBufferFilled(const sp<AMessage> &msg) { 2828 IOMX::buffer_id bufferID; 2829 CHECK(msg->findPointer("buffer-id", &bufferID)); 2830 2831 sp<ABuffer> buffer; 2832 int32_t err = OK; 2833 bool eos = false; 2834 2835 if (!msg->findBuffer("buffer", &buffer)) { 2836 CHECK(msg->findInt32("err", &err)); 2837 2838 ALOGV("[%s] saw error %d instead of an input buffer", 2839 mCodec->mComponentName.c_str(), err); 2840 2841 buffer.clear(); 2842 2843 eos = true; 2844 } 2845 2846 int32_t tmp; 2847 if (buffer != NULL && buffer->meta()->findInt32("eos", &tmp) && tmp) { 2848 eos = true; 2849 err = ERROR_END_OF_STREAM; 2850 } 2851 2852 BufferInfo *info = mCodec->findBufferByID(kPortIndexInput, bufferID); 2853 CHECK_EQ((int)info->mStatus, (int)BufferInfo::OWNED_BY_UPSTREAM); 2854 2855 info->mStatus = BufferInfo::OWNED_BY_US; 2856 2857 PortMode mode = getPortMode(kPortIndexInput); 2858 2859 switch (mode) { 2860 case KEEP_BUFFERS: 2861 { 2862 if (eos) { 2863 if (!mCodec->mPortEOS[kPortIndexInput]) { 2864 mCodec->mPortEOS[kPortIndexInput] = true; 2865 mCodec->mInputEOSResult = err; 2866 } 2867 } 2868 break; 2869 } 2870 2871 case RESUBMIT_BUFFERS: 2872 { 2873 if (buffer != NULL && !mCodec->mPortEOS[kPortIndexInput]) { 2874 int64_t timeUs; 2875 CHECK(buffer->meta()->findInt64("timeUs", &timeUs)); 2876 2877 OMX_U32 flags = OMX_BUFFERFLAG_ENDOFFRAME; 2878 2879 int32_t isCSD; 2880 if (buffer->meta()->findInt32("csd", &isCSD) && isCSD != 0) { 2881 flags |= OMX_BUFFERFLAG_CODECCONFIG; 2882 } 2883 2884 if (eos) { 2885 flags |= OMX_BUFFERFLAG_EOS; 2886 } 2887 2888 if (buffer != info->mData) { 2889 ALOGV("[%s] Needs to copy input data for buffer %p. (%p != %p)", 2890 mCodec->mComponentName.c_str(), 2891 bufferID, 2892 buffer.get(), info->mData.get()); 2893 2894 CHECK_LE(buffer->size(), info->mData->capacity()); 2895 memcpy(info->mData->data(), buffer->data(), buffer->size()); 2896 } 2897 2898 if (flags & OMX_BUFFERFLAG_CODECCONFIG) { 2899 ALOGV("[%s] calling emptyBuffer %p w/ codec specific data", 2900 mCodec->mComponentName.c_str(), bufferID); 2901 } else if (flags & OMX_BUFFERFLAG_EOS) { 2902 ALOGV("[%s] calling emptyBuffer %p w/ EOS", 2903 mCodec->mComponentName.c_str(), bufferID); 2904 } else { 2905#if TRACK_BUFFER_TIMING 2906 ALOGI("[%s] calling emptyBuffer %p w/ time %lld us", 2907 mCodec->mComponentName.c_str(), bufferID, timeUs); 2908#else 2909 ALOGV("[%s] calling emptyBuffer %p w/ time %lld us", 2910 mCodec->mComponentName.c_str(), bufferID, timeUs); 2911#endif 2912 } 2913 2914#if TRACK_BUFFER_TIMING 2915 ACodec::BufferStats stats; 2916 stats.mEmptyBufferTimeUs = ALooper::GetNowUs(); 2917 stats.mFillBufferDoneTimeUs = -1ll; 2918 mCodec->mBufferStats.add(timeUs, stats); 2919#endif 2920 2921 CHECK_EQ(mCodec->mOMX->emptyBuffer( 2922 mCodec->mNode, 2923 bufferID, 2924 0, 2925 buffer->size(), 2926 flags, 2927 timeUs), 2928 (status_t)OK); 2929 2930 info->mStatus = BufferInfo::OWNED_BY_COMPONENT; 2931 2932 if (!eos) { 2933 getMoreInputDataIfPossible(); 2934 } else { 2935 ALOGV("[%s] Signalled EOS on the input port", 2936 mCodec->mComponentName.c_str()); 2937 2938 mCodec->mPortEOS[kPortIndexInput] = true; 2939 mCodec->mInputEOSResult = err; 2940 } 2941 } else if (!mCodec->mPortEOS[kPortIndexInput]) { 2942 if (err != ERROR_END_OF_STREAM) { 2943 ALOGV("[%s] Signalling EOS on the input port " 2944 "due to error %d", 2945 mCodec->mComponentName.c_str(), err); 2946 } else { 2947 ALOGV("[%s] Signalling EOS on the input port", 2948 mCodec->mComponentName.c_str()); 2949 } 2950 2951 ALOGV("[%s] calling emptyBuffer %p signalling EOS", 2952 mCodec->mComponentName.c_str(), bufferID); 2953 2954 CHECK_EQ(mCodec->mOMX->emptyBuffer( 2955 mCodec->mNode, 2956 bufferID, 2957 0, 2958 0, 2959 OMX_BUFFERFLAG_EOS, 2960 0), 2961 (status_t)OK); 2962 2963 info->mStatus = BufferInfo::OWNED_BY_COMPONENT; 2964 2965 mCodec->mPortEOS[kPortIndexInput] = true; 2966 mCodec->mInputEOSResult = err; 2967 } 2968 break; 2969 2970 default: 2971 CHECK_EQ((int)mode, (int)FREE_BUFFERS); 2972 break; 2973 } 2974 } 2975} 2976 2977void ACodec::BaseState::getMoreInputDataIfPossible() { 2978 if (mCodec->mPortEOS[kPortIndexInput]) { 2979 return; 2980 } 2981 2982 BufferInfo *eligible = NULL; 2983 2984 for (size_t i = 0; i < mCodec->mBuffers[kPortIndexInput].size(); ++i) { 2985 BufferInfo *info = &mCodec->mBuffers[kPortIndexInput].editItemAt(i); 2986 2987#if 0 2988 if (info->mStatus == BufferInfo::OWNED_BY_UPSTREAM) { 2989 // There's already a "read" pending. 2990 return; 2991 } 2992#endif 2993 2994 if (info->mStatus == BufferInfo::OWNED_BY_US) { 2995 eligible = info; 2996 } 2997 } 2998 2999 if (eligible == NULL) { 3000 return; 3001 } 3002 3003 postFillThisBuffer(eligible); 3004} 3005 3006bool ACodec::BaseState::onOMXFillBufferDone( 3007 IOMX::buffer_id bufferID, 3008 size_t rangeOffset, size_t rangeLength, 3009 OMX_U32 flags, 3010 int64_t timeUs, 3011 void *platformPrivate, 3012 void *dataPtr) { 3013 ALOGV("[%s] onOMXFillBufferDone %p time %lld us, flags = 0x%08lx", 3014 mCodec->mComponentName.c_str(), bufferID, timeUs, flags); 3015 3016 ssize_t index; 3017 3018#if TRACK_BUFFER_TIMING 3019 index = mCodec->mBufferStats.indexOfKey(timeUs); 3020 if (index >= 0) { 3021 ACodec::BufferStats *stats = &mCodec->mBufferStats.editValueAt(index); 3022 stats->mFillBufferDoneTimeUs = ALooper::GetNowUs(); 3023 3024 ALOGI("frame PTS %lld: %lld", 3025 timeUs, 3026 stats->mFillBufferDoneTimeUs - stats->mEmptyBufferTimeUs); 3027 3028 mCodec->mBufferStats.removeItemsAt(index); 3029 stats = NULL; 3030 } 3031#endif 3032 3033 BufferInfo *info = 3034 mCodec->findBufferByID(kPortIndexOutput, bufferID, &index); 3035 3036 CHECK_EQ((int)info->mStatus, (int)BufferInfo::OWNED_BY_COMPONENT); 3037 3038 info->mStatus = BufferInfo::OWNED_BY_US; 3039 3040 PortMode mode = getPortMode(kPortIndexOutput); 3041 3042 switch (mode) { 3043 case KEEP_BUFFERS: 3044 break; 3045 3046 case RESUBMIT_BUFFERS: 3047 { 3048 if (rangeLength == 0 && !(flags & OMX_BUFFERFLAG_EOS)) { 3049 ALOGV("[%s] calling fillBuffer %p", 3050 mCodec->mComponentName.c_str(), info->mBufferID); 3051 3052 CHECK_EQ(mCodec->mOMX->fillBuffer( 3053 mCodec->mNode, info->mBufferID), 3054 (status_t)OK); 3055 3056 info->mStatus = BufferInfo::OWNED_BY_COMPONENT; 3057 break; 3058 } 3059 3060 if (!mCodec->mSentFormat) { 3061 mCodec->sendFormatChange(); 3062 } 3063 3064 info->mData->setRange(rangeOffset, rangeLength); 3065#if 0 3066 if (mCodec->mNativeWindow == NULL) { 3067 if (IsIDR(info->mData)) { 3068 ALOGI("IDR frame"); 3069 } 3070 } 3071#endif 3072 3073 if (mCodec->mSkipCutBuffer != NULL) { 3074 mCodec->mSkipCutBuffer->submit(info->mData); 3075 } 3076 info->mData->meta()->setInt64("timeUs", timeUs); 3077 3078 sp<AMessage> notify = mCodec->mNotify->dup(); 3079 notify->setInt32("what", ACodec::kWhatDrainThisBuffer); 3080 notify->setPointer("buffer-id", info->mBufferID); 3081 notify->setBuffer("buffer", info->mData); 3082 notify->setInt32("flags", flags); 3083 3084 sp<AMessage> reply = 3085 new AMessage(kWhatOutputBufferDrained, mCodec->id()); 3086 3087 reply->setPointer("buffer-id", info->mBufferID); 3088 3089 notify->setMessage("reply", reply); 3090 3091 notify->post(); 3092 3093 info->mStatus = BufferInfo::OWNED_BY_DOWNSTREAM; 3094 3095 if (flags & OMX_BUFFERFLAG_EOS) { 3096 ALOGV("[%s] saw output EOS", mCodec->mComponentName.c_str()); 3097 3098 sp<AMessage> notify = mCodec->mNotify->dup(); 3099 notify->setInt32("what", ACodec::kWhatEOS); 3100 notify->setInt32("err", mCodec->mInputEOSResult); 3101 notify->post(); 3102 3103 mCodec->mPortEOS[kPortIndexOutput] = true; 3104 } 3105 break; 3106 } 3107 3108 default: 3109 { 3110 CHECK_EQ((int)mode, (int)FREE_BUFFERS); 3111 3112 CHECK_EQ((status_t)OK, 3113 mCodec->freeBuffer(kPortIndexOutput, index)); 3114 break; 3115 } 3116 } 3117 3118 return true; 3119} 3120 3121void ACodec::BaseState::onOutputBufferDrained(const sp<AMessage> &msg) { 3122 IOMX::buffer_id bufferID; 3123 CHECK(msg->findPointer("buffer-id", &bufferID)); 3124 3125 ssize_t index; 3126 BufferInfo *info = 3127 mCodec->findBufferByID(kPortIndexOutput, bufferID, &index); 3128 CHECK_EQ((int)info->mStatus, (int)BufferInfo::OWNED_BY_DOWNSTREAM); 3129 3130 int32_t render; 3131 if (mCodec->mNativeWindow != NULL 3132 && msg->findInt32("render", &render) && render != 0) { 3133 // The client wants this buffer to be rendered. 3134 3135 status_t err; 3136 if ((err = mCodec->mNativeWindow->queueBuffer( 3137 mCodec->mNativeWindow.get(), 3138 info->mGraphicBuffer.get(), -1)) == OK) { 3139 info->mStatus = BufferInfo::OWNED_BY_NATIVE_WINDOW; 3140 } else { 3141 mCodec->signalError(OMX_ErrorUndefined, err); 3142 info->mStatus = BufferInfo::OWNED_BY_US; 3143 } 3144 } else { 3145 info->mStatus = BufferInfo::OWNED_BY_US; 3146 } 3147 3148 PortMode mode = getPortMode(kPortIndexOutput); 3149 3150 switch (mode) { 3151 case KEEP_BUFFERS: 3152 { 3153 // XXX fishy, revisit!!! What about the FREE_BUFFERS case below? 3154 3155 if (info->mStatus == BufferInfo::OWNED_BY_NATIVE_WINDOW) { 3156 // We cannot resubmit the buffer we just rendered, dequeue 3157 // the spare instead. 3158 3159 info = mCodec->dequeueBufferFromNativeWindow(); 3160 } 3161 break; 3162 } 3163 3164 case RESUBMIT_BUFFERS: 3165 { 3166 if (!mCodec->mPortEOS[kPortIndexOutput]) { 3167 if (info->mStatus == BufferInfo::OWNED_BY_NATIVE_WINDOW) { 3168 // We cannot resubmit the buffer we just rendered, dequeue 3169 // the spare instead. 3170 3171 info = mCodec->dequeueBufferFromNativeWindow(); 3172 } 3173 3174 if (info != NULL) { 3175 ALOGV("[%s] calling fillBuffer %p", 3176 mCodec->mComponentName.c_str(), info->mBufferID); 3177 3178 CHECK_EQ(mCodec->mOMX->fillBuffer(mCodec->mNode, info->mBufferID), 3179 (status_t)OK); 3180 3181 info->mStatus = BufferInfo::OWNED_BY_COMPONENT; 3182 } 3183 } 3184 break; 3185 } 3186 3187 default: 3188 { 3189 CHECK_EQ((int)mode, (int)FREE_BUFFERS); 3190 3191 CHECK_EQ((status_t)OK, 3192 mCodec->freeBuffer(kPortIndexOutput, index)); 3193 break; 3194 } 3195 } 3196} 3197 3198//////////////////////////////////////////////////////////////////////////////// 3199 3200ACodec::UninitializedState::UninitializedState(ACodec *codec) 3201 : BaseState(codec) { 3202} 3203 3204void ACodec::UninitializedState::stateEntered() { 3205 ALOGV("Now uninitialized"); 3206 3207 if (mDeathNotifier != NULL) { 3208 mCodec->mOMX->asBinder()->unlinkToDeath(mDeathNotifier); 3209 mDeathNotifier.clear(); 3210 } 3211 3212 mCodec->mNativeWindow.clear(); 3213 mCodec->mNode = NULL; 3214 mCodec->mOMX.clear(); 3215 mCodec->mQuirks = 0; 3216 mCodec->mFlags = 0; 3217 mCodec->mComponentName.clear(); 3218} 3219 3220bool ACodec::UninitializedState::onMessageReceived(const sp<AMessage> &msg) { 3221 bool handled = false; 3222 3223 switch (msg->what()) { 3224 case ACodec::kWhatSetup: 3225 { 3226 onSetup(msg); 3227 3228 handled = true; 3229 break; 3230 } 3231 3232 case ACodec::kWhatAllocateComponent: 3233 { 3234 onAllocateComponent(msg); 3235 handled = true; 3236 break; 3237 } 3238 3239 case ACodec::kWhatShutdown: 3240 { 3241 int32_t keepComponentAllocated; 3242 CHECK(msg->findInt32( 3243 "keepComponentAllocated", &keepComponentAllocated)); 3244 CHECK(!keepComponentAllocated); 3245 3246 sp<AMessage> notify = mCodec->mNotify->dup(); 3247 notify->setInt32("what", ACodec::kWhatShutdownCompleted); 3248 notify->post(); 3249 3250 handled = true; 3251 break; 3252 } 3253 3254 case ACodec::kWhatFlush: 3255 { 3256 sp<AMessage> notify = mCodec->mNotify->dup(); 3257 notify->setInt32("what", ACodec::kWhatFlushCompleted); 3258 notify->post(); 3259 3260 handled = true; 3261 break; 3262 } 3263 3264 default: 3265 return BaseState::onMessageReceived(msg); 3266 } 3267 3268 return handled; 3269} 3270 3271void ACodec::UninitializedState::onSetup( 3272 const sp<AMessage> &msg) { 3273 if (onAllocateComponent(msg) 3274 && mCodec->mLoadedState->onConfigureComponent(msg)) { 3275 mCodec->mLoadedState->onStart(); 3276 } 3277} 3278 3279bool ACodec::UninitializedState::onAllocateComponent(const sp<AMessage> &msg) { 3280 ALOGV("onAllocateComponent"); 3281 3282 CHECK(mCodec->mNode == NULL); 3283 3284 OMXClient client; 3285 CHECK_EQ(client.connect(), (status_t)OK); 3286 3287 sp<IOMX> omx = client.interface(); 3288 3289 sp<AMessage> notify = new AMessage(kWhatOMXDied, mCodec->id()); 3290 3291 mDeathNotifier = new DeathNotifier(notify); 3292 if (omx->asBinder()->linkToDeath(mDeathNotifier) != OK) { 3293 // This was a local binder, if it dies so do we, we won't care 3294 // about any notifications in the afterlife. 3295 mDeathNotifier.clear(); 3296 } 3297 3298 Vector<OMXCodec::CodecNameAndQuirks> matchingCodecs; 3299 3300 AString mime; 3301 3302 AString componentName; 3303 uint32_t quirks = 0; 3304 if (msg->findString("componentName", &componentName)) { 3305 ssize_t index = matchingCodecs.add(); 3306 OMXCodec::CodecNameAndQuirks *entry = &matchingCodecs.editItemAt(index); 3307 entry->mName = String8(componentName.c_str()); 3308 3309 if (!OMXCodec::findCodecQuirks( 3310 componentName.c_str(), &entry->mQuirks)) { 3311 entry->mQuirks = 0; 3312 } 3313 } else { 3314 CHECK(msg->findString("mime", &mime)); 3315 3316 int32_t encoder; 3317 if (!msg->findInt32("encoder", &encoder)) { 3318 encoder = false; 3319 } 3320 3321 OMXCodec::findMatchingCodecs( 3322 mime.c_str(), 3323 encoder, // createEncoder 3324 NULL, // matchComponentName 3325 0, // flags 3326 &matchingCodecs); 3327 } 3328 3329 sp<CodecObserver> observer = new CodecObserver; 3330 IOMX::node_id node = NULL; 3331 3332 for (size_t matchIndex = 0; matchIndex < matchingCodecs.size(); 3333 ++matchIndex) { 3334 componentName = matchingCodecs.itemAt(matchIndex).mName.string(); 3335 quirks = matchingCodecs.itemAt(matchIndex).mQuirks; 3336 3337 pid_t tid = androidGetTid(); 3338 int prevPriority = androidGetThreadPriority(tid); 3339 androidSetThreadPriority(tid, ANDROID_PRIORITY_FOREGROUND); 3340 status_t err = omx->allocateNode(componentName.c_str(), observer, &node); 3341 androidSetThreadPriority(tid, prevPriority); 3342 3343 if (err == OK) { 3344 break; 3345 } 3346 3347 node = NULL; 3348 } 3349 3350 if (node == NULL) { 3351 if (!mime.empty()) { 3352 ALOGE("Unable to instantiate a decoder for type '%s'.", 3353 mime.c_str()); 3354 } else { 3355 ALOGE("Unable to instantiate decoder '%s'.", componentName.c_str()); 3356 } 3357 3358 mCodec->signalError(OMX_ErrorComponentNotFound); 3359 return false; 3360 } 3361 3362 notify = new AMessage(kWhatOMXMessage, mCodec->id()); 3363 observer->setNotificationMessage(notify); 3364 3365 mCodec->mComponentName = componentName; 3366 mCodec->mFlags = 0; 3367 3368 if (componentName.endsWith(".secure")) { 3369 mCodec->mFlags |= kFlagIsSecure; 3370 } 3371 3372 mCodec->mQuirks = quirks; 3373 mCodec->mOMX = omx; 3374 mCodec->mNode = node; 3375 3376 { 3377 sp<AMessage> notify = mCodec->mNotify->dup(); 3378 notify->setInt32("what", ACodec::kWhatComponentAllocated); 3379 notify->setString("componentName", mCodec->mComponentName.c_str()); 3380 notify->post(); 3381 } 3382 3383 mCodec->changeState(mCodec->mLoadedState); 3384 3385 return true; 3386} 3387 3388//////////////////////////////////////////////////////////////////////////////// 3389 3390ACodec::LoadedState::LoadedState(ACodec *codec) 3391 : BaseState(codec) { 3392} 3393 3394void ACodec::LoadedState::stateEntered() { 3395 ALOGV("[%s] Now Loaded", mCodec->mComponentName.c_str()); 3396 3397 mCodec->mPortEOS[kPortIndexInput] = 3398 mCodec->mPortEOS[kPortIndexOutput] = false; 3399 3400 mCodec->mInputEOSResult = OK; 3401 3402 if (mCodec->mShutdownInProgress) { 3403 bool keepComponentAllocated = mCodec->mKeepComponentAllocated; 3404 3405 mCodec->mShutdownInProgress = false; 3406 mCodec->mKeepComponentAllocated = false; 3407 3408 onShutdown(keepComponentAllocated); 3409 } 3410} 3411 3412void ACodec::LoadedState::onShutdown(bool keepComponentAllocated) { 3413 if (!keepComponentAllocated) { 3414 CHECK_EQ(mCodec->mOMX->freeNode(mCodec->mNode), (status_t)OK); 3415 3416 mCodec->changeState(mCodec->mUninitializedState); 3417 } 3418 3419 sp<AMessage> notify = mCodec->mNotify->dup(); 3420 notify->setInt32("what", ACodec::kWhatShutdownCompleted); 3421 notify->post(); 3422} 3423 3424bool ACodec::LoadedState::onMessageReceived(const sp<AMessage> &msg) { 3425 bool handled = false; 3426 3427 switch (msg->what()) { 3428 case ACodec::kWhatConfigureComponent: 3429 { 3430 onConfigureComponent(msg); 3431 handled = true; 3432 break; 3433 } 3434 3435 case ACodec::kWhatCreateInputSurface: 3436 { 3437 onCreateInputSurface(msg); 3438 handled = true; 3439 break; 3440 } 3441 3442 case ACodec::kWhatStart: 3443 { 3444 onStart(); 3445 handled = true; 3446 break; 3447 } 3448 3449 case ACodec::kWhatShutdown: 3450 { 3451 int32_t keepComponentAllocated; 3452 CHECK(msg->findInt32( 3453 "keepComponentAllocated", &keepComponentAllocated)); 3454 3455 onShutdown(keepComponentAllocated); 3456 3457 handled = true; 3458 break; 3459 } 3460 3461 case ACodec::kWhatFlush: 3462 { 3463 sp<AMessage> notify = mCodec->mNotify->dup(); 3464 notify->setInt32("what", ACodec::kWhatFlushCompleted); 3465 notify->post(); 3466 3467 handled = true; 3468 break; 3469 } 3470 3471 default: 3472 return BaseState::onMessageReceived(msg); 3473 } 3474 3475 return handled; 3476} 3477 3478bool ACodec::LoadedState::onConfigureComponent( 3479 const sp<AMessage> &msg) { 3480 ALOGV("onConfigureComponent"); 3481 3482 CHECK(mCodec->mNode != NULL); 3483 3484 AString mime; 3485 CHECK(msg->findString("mime", &mime)); 3486 3487 status_t err = mCodec->configureCodec(mime.c_str(), msg); 3488 3489 if (err != OK) { 3490 ALOGE("[%s] configureCodec returning error %d", 3491 mCodec->mComponentName.c_str(), err); 3492 3493 mCodec->signalError(OMX_ErrorUndefined, err); 3494 return false; 3495 } 3496 3497 sp<RefBase> obj; 3498 if (msg->findObject("native-window", &obj) 3499 && strncmp("OMX.google.", mCodec->mComponentName.c_str(), 11)) { 3500 sp<NativeWindowWrapper> nativeWindow( 3501 static_cast<NativeWindowWrapper *>(obj.get())); 3502 CHECK(nativeWindow != NULL); 3503 mCodec->mNativeWindow = nativeWindow->getNativeWindow(); 3504 3505 native_window_set_scaling_mode( 3506 mCodec->mNativeWindow.get(), 3507 NATIVE_WINDOW_SCALING_MODE_SCALE_TO_WINDOW); 3508 } 3509 CHECK_EQ((status_t)OK, mCodec->initNativeWindow()); 3510 3511 { 3512 sp<AMessage> notify = mCodec->mNotify->dup(); 3513 notify->setInt32("what", ACodec::kWhatComponentConfigured); 3514 notify->post(); 3515 } 3516 3517 return true; 3518} 3519 3520void ACodec::LoadedState::onCreateInputSurface( 3521 const sp<AMessage> &msg) { 3522 ALOGV("onCreateInputSurface"); 3523 3524 sp<AMessage> notify = mCodec->mNotify->dup(); 3525 notify->setInt32("what", ACodec::kWhatInputSurfaceCreated); 3526 3527 sp<IGraphicBufferProducer> bufferProducer; 3528 status_t err; 3529 3530 err = mCodec->mOMX->createInputSurface(mCodec->mNode, kPortIndexInput, 3531 &bufferProducer); 3532 if (err == OK) { 3533 notify->setObject("input-surface", 3534 new BufferProducerWrapper(bufferProducer)); 3535 } else { 3536 // Can't use mCodec->signalError() here -- MediaCodec won't forward 3537 // the error through because it's in the "configured" state. We 3538 // send a kWhatInputSurfaceCreated with an error value instead. 3539 ALOGE("[%s] onCreateInputSurface returning error %d", 3540 mCodec->mComponentName.c_str(), err); 3541 notify->setInt32("err", err); 3542 } 3543 notify->post(); 3544} 3545 3546void ACodec::LoadedState::onStart() { 3547 ALOGV("onStart"); 3548 3549 CHECK_EQ(mCodec->mOMX->sendCommand( 3550 mCodec->mNode, OMX_CommandStateSet, OMX_StateIdle), 3551 (status_t)OK); 3552 3553 mCodec->changeState(mCodec->mLoadedToIdleState); 3554} 3555 3556//////////////////////////////////////////////////////////////////////////////// 3557 3558ACodec::LoadedToIdleState::LoadedToIdleState(ACodec *codec) 3559 : BaseState(codec) { 3560} 3561 3562void ACodec::LoadedToIdleState::stateEntered() { 3563 ALOGV("[%s] Now Loaded->Idle", mCodec->mComponentName.c_str()); 3564 3565 status_t err; 3566 if ((err = allocateBuffers()) != OK) { 3567 ALOGE("Failed to allocate buffers after transitioning to IDLE state " 3568 "(error 0x%08x)", 3569 err); 3570 3571 mCodec->signalError(OMX_ErrorUndefined, err); 3572 3573 mCodec->changeState(mCodec->mLoadedState); 3574 } 3575} 3576 3577status_t ACodec::LoadedToIdleState::allocateBuffers() { 3578 status_t err = mCodec->allocateBuffersOnPort(kPortIndexInput); 3579 3580 if (err != OK) { 3581 return err; 3582 } 3583 3584 return mCodec->allocateBuffersOnPort(kPortIndexOutput); 3585} 3586 3587bool ACodec::LoadedToIdleState::onMessageReceived(const sp<AMessage> &msg) { 3588 switch (msg->what()) { 3589 case kWhatShutdown: 3590 { 3591 mCodec->deferMessage(msg); 3592 return true; 3593 } 3594 3595 case kWhatSignalEndOfInputStream: 3596 { 3597 mCodec->onSignalEndOfInputStream(); 3598 return true; 3599 } 3600 3601 case kWhatResume: 3602 { 3603 // We'll be active soon enough. 3604 return true; 3605 } 3606 3607 case kWhatFlush: 3608 { 3609 // We haven't even started yet, so we're flushed alright... 3610 sp<AMessage> notify = mCodec->mNotify->dup(); 3611 notify->setInt32("what", ACodec::kWhatFlushCompleted); 3612 notify->post(); 3613 return true; 3614 } 3615 3616 default: 3617 return BaseState::onMessageReceived(msg); 3618 } 3619} 3620 3621bool ACodec::LoadedToIdleState::onOMXEvent( 3622 OMX_EVENTTYPE event, OMX_U32 data1, OMX_U32 data2) { 3623 switch (event) { 3624 case OMX_EventCmdComplete: 3625 { 3626 CHECK_EQ(data1, (OMX_U32)OMX_CommandStateSet); 3627 CHECK_EQ(data2, (OMX_U32)OMX_StateIdle); 3628 3629 CHECK_EQ(mCodec->mOMX->sendCommand( 3630 mCodec->mNode, OMX_CommandStateSet, OMX_StateExecuting), 3631 (status_t)OK); 3632 3633 mCodec->changeState(mCodec->mIdleToExecutingState); 3634 3635 return true; 3636 } 3637 3638 default: 3639 return BaseState::onOMXEvent(event, data1, data2); 3640 } 3641} 3642 3643//////////////////////////////////////////////////////////////////////////////// 3644 3645ACodec::IdleToExecutingState::IdleToExecutingState(ACodec *codec) 3646 : BaseState(codec) { 3647} 3648 3649void ACodec::IdleToExecutingState::stateEntered() { 3650 ALOGV("[%s] Now Idle->Executing", mCodec->mComponentName.c_str()); 3651} 3652 3653bool ACodec::IdleToExecutingState::onMessageReceived(const sp<AMessage> &msg) { 3654 switch (msg->what()) { 3655 case kWhatShutdown: 3656 { 3657 mCodec->deferMessage(msg); 3658 return true; 3659 } 3660 3661 case kWhatResume: 3662 { 3663 // We'll be active soon enough. 3664 return true; 3665 } 3666 3667 case kWhatFlush: 3668 { 3669 // We haven't even started yet, so we're flushed alright... 3670 sp<AMessage> notify = mCodec->mNotify->dup(); 3671 notify->setInt32("what", ACodec::kWhatFlushCompleted); 3672 notify->post(); 3673 3674 return true; 3675 } 3676 3677 case kWhatSignalEndOfInputStream: 3678 { 3679 mCodec->onSignalEndOfInputStream(); 3680 return true; 3681 } 3682 3683 default: 3684 return BaseState::onMessageReceived(msg); 3685 } 3686} 3687 3688bool ACodec::IdleToExecutingState::onOMXEvent( 3689 OMX_EVENTTYPE event, OMX_U32 data1, OMX_U32 data2) { 3690 switch (event) { 3691 case OMX_EventCmdComplete: 3692 { 3693 CHECK_EQ(data1, (OMX_U32)OMX_CommandStateSet); 3694 CHECK_EQ(data2, (OMX_U32)OMX_StateExecuting); 3695 3696 mCodec->mExecutingState->resume(); 3697 mCodec->changeState(mCodec->mExecutingState); 3698 3699 return true; 3700 } 3701 3702 default: 3703 return BaseState::onOMXEvent(event, data1, data2); 3704 } 3705} 3706 3707//////////////////////////////////////////////////////////////////////////////// 3708 3709ACodec::ExecutingState::ExecutingState(ACodec *codec) 3710 : BaseState(codec), 3711 mActive(false) { 3712} 3713 3714ACodec::BaseState::PortMode ACodec::ExecutingState::getPortMode( 3715 OMX_U32 portIndex) { 3716 return RESUBMIT_BUFFERS; 3717} 3718 3719void ACodec::ExecutingState::submitOutputBuffers() { 3720 for (size_t i = 0; i < mCodec->mBuffers[kPortIndexOutput].size(); ++i) { 3721 BufferInfo *info = &mCodec->mBuffers[kPortIndexOutput].editItemAt(i); 3722 3723 if (mCodec->mNativeWindow != NULL) { 3724 CHECK(info->mStatus == BufferInfo::OWNED_BY_US 3725 || info->mStatus == BufferInfo::OWNED_BY_NATIVE_WINDOW); 3726 3727 if (info->mStatus == BufferInfo::OWNED_BY_NATIVE_WINDOW) { 3728 continue; 3729 } 3730 } else { 3731 CHECK_EQ((int)info->mStatus, (int)BufferInfo::OWNED_BY_US); 3732 } 3733 3734 ALOGV("[%s] calling fillBuffer %p", 3735 mCodec->mComponentName.c_str(), info->mBufferID); 3736 3737 CHECK_EQ(mCodec->mOMX->fillBuffer(mCodec->mNode, info->mBufferID), 3738 (status_t)OK); 3739 3740 info->mStatus = BufferInfo::OWNED_BY_COMPONENT; 3741 } 3742} 3743 3744void ACodec::ExecutingState::resume() { 3745 if (mActive) { 3746 ALOGV("[%s] We're already active, no need to resume.", 3747 mCodec->mComponentName.c_str()); 3748 3749 return; 3750 } 3751 3752 submitOutputBuffers(); 3753 3754 // Post the first input buffer. 3755 CHECK_GT(mCodec->mBuffers[kPortIndexInput].size(), 0u); 3756 BufferInfo *info = &mCodec->mBuffers[kPortIndexInput].editItemAt(0); 3757 3758 postFillThisBuffer(info); 3759 3760 mActive = true; 3761} 3762 3763void ACodec::ExecutingState::stateEntered() { 3764 ALOGV("[%s] Now Executing", mCodec->mComponentName.c_str()); 3765 3766 mCodec->processDeferredMessages(); 3767} 3768 3769bool ACodec::ExecutingState::onMessageReceived(const sp<AMessage> &msg) { 3770 bool handled = false; 3771 3772 switch (msg->what()) { 3773 case kWhatShutdown: 3774 { 3775 int32_t keepComponentAllocated; 3776 CHECK(msg->findInt32( 3777 "keepComponentAllocated", &keepComponentAllocated)); 3778 3779 mCodec->mShutdownInProgress = true; 3780 mCodec->mKeepComponentAllocated = keepComponentAllocated; 3781 3782 mActive = false; 3783 3784 CHECK_EQ(mCodec->mOMX->sendCommand( 3785 mCodec->mNode, OMX_CommandStateSet, OMX_StateIdle), 3786 (status_t)OK); 3787 3788 mCodec->changeState(mCodec->mExecutingToIdleState); 3789 3790 handled = true; 3791 break; 3792 } 3793 3794 case kWhatFlush: 3795 { 3796 ALOGV("[%s] ExecutingState flushing now " 3797 "(codec owns %d/%d input, %d/%d output).", 3798 mCodec->mComponentName.c_str(), 3799 mCodec->countBuffersOwnedByComponent(kPortIndexInput), 3800 mCodec->mBuffers[kPortIndexInput].size(), 3801 mCodec->countBuffersOwnedByComponent(kPortIndexOutput), 3802 mCodec->mBuffers[kPortIndexOutput].size()); 3803 3804 mActive = false; 3805 3806 CHECK_EQ(mCodec->mOMX->sendCommand( 3807 mCodec->mNode, OMX_CommandFlush, OMX_ALL), 3808 (status_t)OK); 3809 3810 mCodec->changeState(mCodec->mFlushingState); 3811 handled = true; 3812 break; 3813 } 3814 3815 case kWhatResume: 3816 { 3817 resume(); 3818 3819 handled = true; 3820 break; 3821 } 3822 3823 case kWhatRequestIDRFrame: 3824 { 3825 status_t err = mCodec->requestIDRFrame(); 3826 if (err != OK) { 3827 ALOGW("Requesting an IDR frame failed."); 3828 } 3829 3830 handled = true; 3831 break; 3832 } 3833 3834 case kWhatSetParameters: 3835 { 3836 sp<AMessage> params; 3837 CHECK(msg->findMessage("params", ¶ms)); 3838 3839 status_t err = mCodec->setParameters(params); 3840 3841 sp<AMessage> reply; 3842 if (msg->findMessage("reply", &reply)) { 3843 reply->setInt32("err", err); 3844 reply->post(); 3845 } 3846 3847 handled = true; 3848 break; 3849 } 3850 3851 case ACodec::kWhatSignalEndOfInputStream: 3852 { 3853 mCodec->onSignalEndOfInputStream(); 3854 handled = true; 3855 break; 3856 } 3857 3858 default: 3859 handled = BaseState::onMessageReceived(msg); 3860 break; 3861 } 3862 3863 return handled; 3864} 3865 3866status_t ACodec::setParameters(const sp<AMessage> ¶ms) { 3867 int32_t videoBitrate; 3868 if (params->findInt32("videoBitrate", &videoBitrate)) { 3869 OMX_VIDEO_CONFIG_BITRATETYPE configParams; 3870 InitOMXParams(&configParams); 3871 configParams.nPortIndex = kPortIndexOutput; 3872 configParams.nEncodeBitrate = videoBitrate; 3873 3874 status_t err = mOMX->setConfig( 3875 mNode, 3876 OMX_IndexConfigVideoBitrate, 3877 &configParams, 3878 sizeof(configParams)); 3879 3880 if (err != OK) { 3881 ALOGE("setConfig(OMX_IndexConfigVideoBitrate, %d) failed w/ err %d", 3882 videoBitrate, err); 3883 3884 return err; 3885 } 3886 } 3887 3888 return OK; 3889} 3890 3891void ACodec::onSignalEndOfInputStream() { 3892 sp<AMessage> notify = mNotify->dup(); 3893 notify->setInt32("what", ACodec::kWhatSignaledInputEOS); 3894 3895 status_t err = mOMX->signalEndOfInputStream(mNode); 3896 if (err != OK) { 3897 notify->setInt32("err", err); 3898 } 3899 notify->post(); 3900} 3901 3902bool ACodec::ExecutingState::onOMXEvent( 3903 OMX_EVENTTYPE event, OMX_U32 data1, OMX_U32 data2) { 3904 switch (event) { 3905 case OMX_EventPortSettingsChanged: 3906 { 3907 CHECK_EQ(data1, (OMX_U32)kPortIndexOutput); 3908 3909 if (data2 == 0 || data2 == OMX_IndexParamPortDefinition) { 3910 CHECK_EQ(mCodec->mOMX->sendCommand( 3911 mCodec->mNode, 3912 OMX_CommandPortDisable, kPortIndexOutput), 3913 (status_t)OK); 3914 3915 mCodec->freeOutputBuffersNotOwnedByComponent(); 3916 3917 mCodec->changeState(mCodec->mOutputPortSettingsChangedState); 3918 } else if (data2 == OMX_IndexConfigCommonOutputCrop) { 3919 mCodec->mSentFormat = false; 3920 } else { 3921 ALOGV("[%s] OMX_EventPortSettingsChanged 0x%08lx", 3922 mCodec->mComponentName.c_str(), data2); 3923 } 3924 3925 return true; 3926 } 3927 3928 case OMX_EventBufferFlag: 3929 { 3930 return true; 3931 } 3932 3933 default: 3934 return BaseState::onOMXEvent(event, data1, data2); 3935 } 3936} 3937 3938//////////////////////////////////////////////////////////////////////////////// 3939 3940ACodec::OutputPortSettingsChangedState::OutputPortSettingsChangedState( 3941 ACodec *codec) 3942 : BaseState(codec) { 3943} 3944 3945ACodec::BaseState::PortMode ACodec::OutputPortSettingsChangedState::getPortMode( 3946 OMX_U32 portIndex) { 3947 if (portIndex == kPortIndexOutput) { 3948 return FREE_BUFFERS; 3949 } 3950 3951 CHECK_EQ(portIndex, (OMX_U32)kPortIndexInput); 3952 3953 return RESUBMIT_BUFFERS; 3954} 3955 3956bool ACodec::OutputPortSettingsChangedState::onMessageReceived( 3957 const sp<AMessage> &msg) { 3958 bool handled = false; 3959 3960 switch (msg->what()) { 3961 case kWhatFlush: 3962 case kWhatShutdown: 3963 case kWhatResume: 3964 { 3965 if (msg->what() == kWhatResume) { 3966 ALOGV("[%s] Deferring resume", mCodec->mComponentName.c_str()); 3967 } 3968 3969 mCodec->deferMessage(msg); 3970 handled = true; 3971 break; 3972 } 3973 3974 default: 3975 handled = BaseState::onMessageReceived(msg); 3976 break; 3977 } 3978 3979 return handled; 3980} 3981 3982void ACodec::OutputPortSettingsChangedState::stateEntered() { 3983 ALOGV("[%s] Now handling output port settings change", 3984 mCodec->mComponentName.c_str()); 3985} 3986 3987bool ACodec::OutputPortSettingsChangedState::onOMXEvent( 3988 OMX_EVENTTYPE event, OMX_U32 data1, OMX_U32 data2) { 3989 switch (event) { 3990 case OMX_EventCmdComplete: 3991 { 3992 if (data1 == (OMX_U32)OMX_CommandPortDisable) { 3993 CHECK_EQ(data2, (OMX_U32)kPortIndexOutput); 3994 3995 ALOGV("[%s] Output port now disabled.", 3996 mCodec->mComponentName.c_str()); 3997 3998 CHECK(mCodec->mBuffers[kPortIndexOutput].isEmpty()); 3999 mCodec->mDealer[kPortIndexOutput].clear(); 4000 4001 CHECK_EQ(mCodec->mOMX->sendCommand( 4002 mCodec->mNode, OMX_CommandPortEnable, kPortIndexOutput), 4003 (status_t)OK); 4004 4005 status_t err; 4006 if ((err = mCodec->allocateBuffersOnPort( 4007 kPortIndexOutput)) != OK) { 4008 ALOGE("Failed to allocate output port buffers after " 4009 "port reconfiguration (error 0x%08x)", 4010 err); 4011 4012 mCodec->signalError(OMX_ErrorUndefined, err); 4013 4014 // This is technically not correct, but appears to be 4015 // the only way to free the component instance. 4016 // Controlled transitioning from excecuting->idle 4017 // and idle->loaded seem impossible probably because 4018 // the output port never finishes re-enabling. 4019 mCodec->mShutdownInProgress = true; 4020 mCodec->mKeepComponentAllocated = false; 4021 mCodec->changeState(mCodec->mLoadedState); 4022 } 4023 4024 return true; 4025 } else if (data1 == (OMX_U32)OMX_CommandPortEnable) { 4026 CHECK_EQ(data2, (OMX_U32)kPortIndexOutput); 4027 4028 mCodec->mSentFormat = false; 4029 4030 ALOGV("[%s] Output port now reenabled.", 4031 mCodec->mComponentName.c_str()); 4032 4033 if (mCodec->mExecutingState->active()) { 4034 mCodec->mExecutingState->submitOutputBuffers(); 4035 } 4036 4037 mCodec->changeState(mCodec->mExecutingState); 4038 4039 return true; 4040 } 4041 4042 return false; 4043 } 4044 4045 default: 4046 return false; 4047 } 4048} 4049 4050//////////////////////////////////////////////////////////////////////////////// 4051 4052ACodec::ExecutingToIdleState::ExecutingToIdleState(ACodec *codec) 4053 : BaseState(codec), 4054 mComponentNowIdle(false) { 4055} 4056 4057bool ACodec::ExecutingToIdleState::onMessageReceived(const sp<AMessage> &msg) { 4058 bool handled = false; 4059 4060 switch (msg->what()) { 4061 case kWhatFlush: 4062 { 4063 // Don't send me a flush request if you previously wanted me 4064 // to shutdown. 4065 TRESPASS(); 4066 break; 4067 } 4068 4069 case kWhatShutdown: 4070 { 4071 // We're already doing that... 4072 4073 handled = true; 4074 break; 4075 } 4076 4077 default: 4078 handled = BaseState::onMessageReceived(msg); 4079 break; 4080 } 4081 4082 return handled; 4083} 4084 4085void ACodec::ExecutingToIdleState::stateEntered() { 4086 ALOGV("[%s] Now Executing->Idle", mCodec->mComponentName.c_str()); 4087 4088 mComponentNowIdle = false; 4089 mCodec->mSentFormat = false; 4090} 4091 4092bool ACodec::ExecutingToIdleState::onOMXEvent( 4093 OMX_EVENTTYPE event, OMX_U32 data1, OMX_U32 data2) { 4094 switch (event) { 4095 case OMX_EventCmdComplete: 4096 { 4097 CHECK_EQ(data1, (OMX_U32)OMX_CommandStateSet); 4098 CHECK_EQ(data2, (OMX_U32)OMX_StateIdle); 4099 4100 mComponentNowIdle = true; 4101 4102 changeStateIfWeOwnAllBuffers(); 4103 4104 return true; 4105 } 4106 4107 case OMX_EventPortSettingsChanged: 4108 case OMX_EventBufferFlag: 4109 { 4110 // We're shutting down and don't care about this anymore. 4111 return true; 4112 } 4113 4114 default: 4115 return BaseState::onOMXEvent(event, data1, data2); 4116 } 4117} 4118 4119void ACodec::ExecutingToIdleState::changeStateIfWeOwnAllBuffers() { 4120 if (mComponentNowIdle && mCodec->allYourBuffersAreBelongToUs()) { 4121 CHECK_EQ(mCodec->mOMX->sendCommand( 4122 mCodec->mNode, OMX_CommandStateSet, OMX_StateLoaded), 4123 (status_t)OK); 4124 4125 CHECK_EQ(mCodec->freeBuffersOnPort(kPortIndexInput), (status_t)OK); 4126 CHECK_EQ(mCodec->freeBuffersOnPort(kPortIndexOutput), (status_t)OK); 4127 4128 if (mCodec->mFlags & kFlagIsSecure && mCodec->mNativeWindow != NULL) { 4129 // We push enough 1x1 blank buffers to ensure that one of 4130 // them has made it to the display. This allows the OMX 4131 // component teardown to zero out any protected buffers 4132 // without the risk of scanning out one of those buffers. 4133 mCodec->pushBlankBuffersToNativeWindow(); 4134 } 4135 4136 mCodec->changeState(mCodec->mIdleToLoadedState); 4137 } 4138} 4139 4140void ACodec::ExecutingToIdleState::onInputBufferFilled( 4141 const sp<AMessage> &msg) { 4142 BaseState::onInputBufferFilled(msg); 4143 4144 changeStateIfWeOwnAllBuffers(); 4145} 4146 4147void ACodec::ExecutingToIdleState::onOutputBufferDrained( 4148 const sp<AMessage> &msg) { 4149 BaseState::onOutputBufferDrained(msg); 4150 4151 changeStateIfWeOwnAllBuffers(); 4152} 4153 4154//////////////////////////////////////////////////////////////////////////////// 4155 4156ACodec::IdleToLoadedState::IdleToLoadedState(ACodec *codec) 4157 : BaseState(codec) { 4158} 4159 4160bool ACodec::IdleToLoadedState::onMessageReceived(const sp<AMessage> &msg) { 4161 bool handled = false; 4162 4163 switch (msg->what()) { 4164 case kWhatShutdown: 4165 { 4166 // We're already doing that... 4167 4168 handled = true; 4169 break; 4170 } 4171 4172 case kWhatFlush: 4173 { 4174 // Don't send me a flush request if you previously wanted me 4175 // to shutdown. 4176 TRESPASS(); 4177 break; 4178 } 4179 4180 default: 4181 handled = BaseState::onMessageReceived(msg); 4182 break; 4183 } 4184 4185 return handled; 4186} 4187 4188void ACodec::IdleToLoadedState::stateEntered() { 4189 ALOGV("[%s] Now Idle->Loaded", mCodec->mComponentName.c_str()); 4190} 4191 4192bool ACodec::IdleToLoadedState::onOMXEvent( 4193 OMX_EVENTTYPE event, OMX_U32 data1, OMX_U32 data2) { 4194 switch (event) { 4195 case OMX_EventCmdComplete: 4196 { 4197 CHECK_EQ(data1, (OMX_U32)OMX_CommandStateSet); 4198 CHECK_EQ(data2, (OMX_U32)OMX_StateLoaded); 4199 4200 mCodec->changeState(mCodec->mLoadedState); 4201 4202 return true; 4203 } 4204 4205 default: 4206 return BaseState::onOMXEvent(event, data1, data2); 4207 } 4208} 4209 4210//////////////////////////////////////////////////////////////////////////////// 4211 4212ACodec::FlushingState::FlushingState(ACodec *codec) 4213 : BaseState(codec) { 4214} 4215 4216void ACodec::FlushingState::stateEntered() { 4217 ALOGV("[%s] Now Flushing", mCodec->mComponentName.c_str()); 4218 4219 mFlushComplete[kPortIndexInput] = mFlushComplete[kPortIndexOutput] = false; 4220} 4221 4222bool ACodec::FlushingState::onMessageReceived(const sp<AMessage> &msg) { 4223 bool handled = false; 4224 4225 switch (msg->what()) { 4226 case kWhatShutdown: 4227 { 4228 mCodec->deferMessage(msg); 4229 break; 4230 } 4231 4232 case kWhatFlush: 4233 { 4234 // We're already doing this right now. 4235 handled = true; 4236 break; 4237 } 4238 4239 default: 4240 handled = BaseState::onMessageReceived(msg); 4241 break; 4242 } 4243 4244 return handled; 4245} 4246 4247bool ACodec::FlushingState::onOMXEvent( 4248 OMX_EVENTTYPE event, OMX_U32 data1, OMX_U32 data2) { 4249 ALOGV("[%s] FlushingState onOMXEvent(%d,%ld)", 4250 mCodec->mComponentName.c_str(), event, data1); 4251 4252 switch (event) { 4253 case OMX_EventCmdComplete: 4254 { 4255 CHECK_EQ(data1, (OMX_U32)OMX_CommandFlush); 4256 4257 if (data2 == kPortIndexInput || data2 == kPortIndexOutput) { 4258 CHECK(!mFlushComplete[data2]); 4259 mFlushComplete[data2] = true; 4260 4261 if (mFlushComplete[kPortIndexInput] 4262 && mFlushComplete[kPortIndexOutput]) { 4263 changeStateIfWeOwnAllBuffers(); 4264 } 4265 } else { 4266 CHECK_EQ(data2, OMX_ALL); 4267 CHECK(mFlushComplete[kPortIndexInput]); 4268 CHECK(mFlushComplete[kPortIndexOutput]); 4269 4270 changeStateIfWeOwnAllBuffers(); 4271 } 4272 4273 return true; 4274 } 4275 4276 case OMX_EventPortSettingsChanged: 4277 { 4278 sp<AMessage> msg = new AMessage(kWhatOMXMessage, mCodec->id()); 4279 msg->setInt32("type", omx_message::EVENT); 4280 msg->setPointer("node", mCodec->mNode); 4281 msg->setInt32("event", event); 4282 msg->setInt32("data1", data1); 4283 msg->setInt32("data2", data2); 4284 4285 ALOGV("[%s] Deferring OMX_EventPortSettingsChanged", 4286 mCodec->mComponentName.c_str()); 4287 4288 mCodec->deferMessage(msg); 4289 4290 return true; 4291 } 4292 4293 default: 4294 return BaseState::onOMXEvent(event, data1, data2); 4295 } 4296 4297 return true; 4298} 4299 4300void ACodec::FlushingState::onOutputBufferDrained(const sp<AMessage> &msg) { 4301 BaseState::onOutputBufferDrained(msg); 4302 4303 changeStateIfWeOwnAllBuffers(); 4304} 4305 4306void ACodec::FlushingState::onInputBufferFilled(const sp<AMessage> &msg) { 4307 BaseState::onInputBufferFilled(msg); 4308 4309 changeStateIfWeOwnAllBuffers(); 4310} 4311 4312void ACodec::FlushingState::changeStateIfWeOwnAllBuffers() { 4313 if (mFlushComplete[kPortIndexInput] 4314 && mFlushComplete[kPortIndexOutput] 4315 && mCodec->allYourBuffersAreBelongToUs()) { 4316 // We now own all buffers except possibly those still queued with 4317 // the native window for rendering. Let's get those back as well. 4318 mCodec->waitUntilAllPossibleNativeWindowBuffersAreReturnedToUs(); 4319 4320 sp<AMessage> notify = mCodec->mNotify->dup(); 4321 notify->setInt32("what", ACodec::kWhatFlushCompleted); 4322 notify->post(); 4323 4324 mCodec->mPortEOS[kPortIndexInput] = 4325 mCodec->mPortEOS[kPortIndexOutput] = false; 4326 4327 mCodec->mInputEOSResult = OK; 4328 4329 if (mCodec->mSkipCutBuffer != NULL) { 4330 mCodec->mSkipCutBuffer->clear(); 4331 } 4332 4333 mCodec->changeState(mCodec->mExecutingState); 4334 } 4335} 4336 4337} // namespace android 4338