MediaCodec.cpp revision a944197b97b4e64ffb3abe91218d1db06ea9d7de
1/* 2 * Copyright 2012, 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 "MediaCodec" 19#include <inttypes.h> 20 21#include "include/avc_utils.h" 22#include "include/SoftwareRenderer.h" 23 24#include <binder/IMemory.h> 25#include <binder/IPCThreadState.h> 26#include <binder/IServiceManager.h> 27#include <binder/MemoryDealer.h> 28#include <gui/BufferQueue.h> 29#include <gui/Surface.h> 30#include <media/ICrypto.h> 31#include <media/IOMX.h> 32#include <media/IResourceManagerService.h> 33#include <media/stagefright/foundation/ABuffer.h> 34#include <media/stagefright/foundation/ADebug.h> 35#include <media/stagefright/foundation/AMessage.h> 36#include <media/stagefright/foundation/AString.h> 37#include <media/stagefright/foundation/hexdump.h> 38#include <media/stagefright/ACodec.h> 39#include <media/stagefright/BufferProducerWrapper.h> 40#include <media/stagefright/MediaCodec.h> 41#include <media/stagefright/MediaCodecList.h> 42#include <media/stagefright/MediaDefs.h> 43#include <media/stagefright/MediaErrors.h> 44#include <media/stagefright/MediaFilter.h> 45#include <media/stagefright/MetaData.h> 46#include <media/stagefright/OMXClient.h> 47#include <media/stagefright/PersistentSurface.h> 48#include <media/stagefright/SurfaceUtils.h> 49#include <mediautils/BatteryNotifier.h> 50#include <private/android_filesystem_config.h> 51#include <utils/Log.h> 52#include <utils/Singleton.h> 53 54namespace android { 55 56static int64_t getId(const sp<IResourceManagerClient> &client) { 57 return (int64_t) client.get(); 58} 59 60static bool isResourceError(status_t err) { 61 return (err == NO_MEMORY); 62} 63 64static const int kMaxRetry = 2; 65static const int kMaxReclaimWaitTimeInUs = 500000; // 0.5s 66 67struct ResourceManagerClient : public BnResourceManagerClient { 68 explicit ResourceManagerClient(MediaCodec* codec) : mMediaCodec(codec) {} 69 70 virtual bool reclaimResource() { 71 sp<MediaCodec> codec = mMediaCodec.promote(); 72 if (codec == NULL) { 73 // codec is already gone. 74 return true; 75 } 76 status_t err = codec->reclaim(); 77 if (err == WOULD_BLOCK) { 78 ALOGD("Wait for the client to release codec."); 79 usleep(kMaxReclaimWaitTimeInUs); 80 ALOGD("Try to reclaim again."); 81 err = codec->reclaim(true /* force */); 82 } 83 if (err != OK) { 84 ALOGW("ResourceManagerClient failed to release codec with err %d", err); 85 } 86 return (err == OK); 87 } 88 89 virtual String8 getName() { 90 String8 ret; 91 sp<MediaCodec> codec = mMediaCodec.promote(); 92 if (codec == NULL) { 93 // codec is already gone. 94 return ret; 95 } 96 97 AString name; 98 if (codec->getName(&name) == OK) { 99 ret.setTo(name.c_str()); 100 } 101 return ret; 102 } 103 104protected: 105 virtual ~ResourceManagerClient() {} 106 107private: 108 wp<MediaCodec> mMediaCodec; 109 110 DISALLOW_EVIL_CONSTRUCTORS(ResourceManagerClient); 111}; 112 113MediaCodec::ResourceManagerServiceProxy::ResourceManagerServiceProxy(pid_t pid) 114 : mPid(pid) { 115 if (mPid == MediaCodec::kNoPid) { 116 mPid = IPCThreadState::self()->getCallingPid(); 117 } 118} 119 120MediaCodec::ResourceManagerServiceProxy::~ResourceManagerServiceProxy() { 121 if (mService != NULL) { 122 IInterface::asBinder(mService)->unlinkToDeath(this); 123 } 124} 125 126void MediaCodec::ResourceManagerServiceProxy::init() { 127 sp<IServiceManager> sm = defaultServiceManager(); 128 sp<IBinder> binder = sm->getService(String16("media.resource_manager")); 129 mService = interface_cast<IResourceManagerService>(binder); 130 if (mService == NULL) { 131 ALOGE("Failed to get ResourceManagerService"); 132 return; 133 } 134 IInterface::asBinder(mService)->linkToDeath(this); 135} 136 137void MediaCodec::ResourceManagerServiceProxy::binderDied(const wp<IBinder>& /*who*/) { 138 ALOGW("ResourceManagerService died."); 139 Mutex::Autolock _l(mLock); 140 mService.clear(); 141} 142 143void MediaCodec::ResourceManagerServiceProxy::addResource( 144 int64_t clientId, 145 const sp<IResourceManagerClient> &client, 146 const Vector<MediaResource> &resources) { 147 Mutex::Autolock _l(mLock); 148 if (mService == NULL) { 149 return; 150 } 151 mService->addResource(mPid, clientId, client, resources); 152} 153 154void MediaCodec::ResourceManagerServiceProxy::removeResource(int64_t clientId) { 155 Mutex::Autolock _l(mLock); 156 if (mService == NULL) { 157 return; 158 } 159 mService->removeResource(mPid, clientId); 160} 161 162bool MediaCodec::ResourceManagerServiceProxy::reclaimResource( 163 const Vector<MediaResource> &resources) { 164 Mutex::Autolock _l(mLock); 165 if (mService == NULL) { 166 return false; 167 } 168 return mService->reclaimResource(mPid, resources); 169} 170 171// static 172sp<MediaCodec> MediaCodec::CreateByType( 173 const sp<ALooper> &looper, const AString &mime, bool encoder, status_t *err, pid_t pid) { 174 sp<MediaCodec> codec = new MediaCodec(looper, pid); 175 176 const status_t ret = codec->init(mime, true /* nameIsType */, encoder); 177 if (err != NULL) { 178 *err = ret; 179 } 180 return ret == OK ? codec : NULL; // NULL deallocates codec. 181} 182 183// static 184sp<MediaCodec> MediaCodec::CreateByComponentName( 185 const sp<ALooper> &looper, const AString &name, status_t *err, pid_t pid) { 186 sp<MediaCodec> codec = new MediaCodec(looper, pid); 187 188 const status_t ret = codec->init(name, false /* nameIsType */, false /* encoder */); 189 if (err != NULL) { 190 *err = ret; 191 } 192 return ret == OK ? codec : NULL; // NULL deallocates codec. 193} 194 195// static 196status_t MediaCodec::QueryCapabilities( 197 const AString &name, const AString &mime, bool isEncoder, 198 sp<MediaCodecInfo::Capabilities> *caps /* nonnull */) { 199 // TRICKY: this method is used by MediaCodecList/Info during its 200 // initialization. As such, we cannot create a MediaCodec instance 201 // because that requires an initialized MediaCodecList. 202 203 sp<CodecBase> codec = GetCodecBase(name); 204 if (codec == NULL) { 205 return NAME_NOT_FOUND; 206 } 207 208 return codec->queryCapabilities(name, mime, isEncoder, caps); 209} 210 211// static 212sp<PersistentSurface> MediaCodec::CreatePersistentInputSurface() { 213 OMXClient client; 214 CHECK_EQ(client.connect(), (status_t)OK); 215 sp<IOMX> omx = client.interface(); 216 217 const sp<IMediaCodecList> mediaCodecList = MediaCodecList::getInstance(); 218 if (mediaCodecList == NULL) { 219 ALOGE("Failed to obtain MediaCodecList!"); 220 return NULL; // if called from Java should raise IOException 221 } 222 223 AString tmp; 224 sp<AMessage> globalSettings = mediaCodecList->getGlobalSettings(); 225 if (globalSettings == NULL || !globalSettings->findString( 226 kMaxEncoderInputBuffers, &tmp)) { 227 ALOGE("Failed to get encoder input buffer count!"); 228 return NULL; 229 } 230 231 int32_t bufferCount = strtol(tmp.c_str(), NULL, 10); 232 if (bufferCount <= 0 233 || bufferCount > BufferQueue::MAX_MAX_ACQUIRED_BUFFERS) { 234 ALOGE("Encoder input buffer count is invalid!"); 235 return NULL; 236 } 237 238 sp<IGraphicBufferProducer> bufferProducer; 239 sp<IGraphicBufferConsumer> bufferConsumer; 240 241 status_t err = omx->createPersistentInputSurface( 242 &bufferProducer, &bufferConsumer); 243 244 if (err != OK) { 245 ALOGE("Failed to create persistent input surface."); 246 return NULL; 247 } 248 249 err = bufferConsumer->setMaxAcquiredBufferCount(bufferCount); 250 251 if (err != NO_ERROR) { 252 ALOGE("Unable to set BQ max acquired buffer count to %u: %d", 253 bufferCount, err); 254 return NULL; 255 } 256 257 return new PersistentSurface(bufferProducer, bufferConsumer); 258} 259 260MediaCodec::MediaCodec(const sp<ALooper> &looper, pid_t pid) 261 : mState(UNINITIALIZED), 262 mReleasedByResourceManager(false), 263 mLooper(looper), 264 mCodec(NULL), 265 mReplyID(0), 266 mFlags(0), 267 mStickyError(OK), 268 mSoftRenderer(NULL), 269 mResourceManagerClient(new ResourceManagerClient(this)), 270 mResourceManagerService(new ResourceManagerServiceProxy(pid)), 271 mBatteryStatNotified(false), 272 mIsVideo(false), 273 mVideoWidth(0), 274 mVideoHeight(0), 275 mRotationDegrees(0), 276 mDequeueInputTimeoutGeneration(0), 277 mDequeueInputReplyID(0), 278 mDequeueOutputTimeoutGeneration(0), 279 mDequeueOutputReplyID(0), 280 mHaveInputSurface(false), 281 mHavePendingInputBuffers(false) { 282} 283 284MediaCodec::~MediaCodec() { 285 CHECK_EQ(mState, UNINITIALIZED); 286 mResourceManagerService->removeResource(getId(mResourceManagerClient)); 287} 288 289// static 290status_t MediaCodec::PostAndAwaitResponse( 291 const sp<AMessage> &msg, sp<AMessage> *response) { 292 status_t err = msg->postAndAwaitResponse(response); 293 294 if (err != OK) { 295 return err; 296 } 297 298 if (!(*response)->findInt32("err", &err)) { 299 err = OK; 300 } 301 302 return err; 303} 304 305void MediaCodec::PostReplyWithError(const sp<AReplyToken> &replyID, int32_t err) { 306 int32_t finalErr = err; 307 if (mReleasedByResourceManager) { 308 // override the err code if MediaCodec has been released by ResourceManager. 309 finalErr = DEAD_OBJECT; 310 } 311 312 sp<AMessage> response = new AMessage; 313 response->setInt32("err", finalErr); 314 response->postReply(replyID); 315} 316 317//static 318sp<CodecBase> MediaCodec::GetCodecBase(const AString &name, bool nameIsType) { 319 // at this time only ACodec specifies a mime type. 320 if (nameIsType || name.startsWithIgnoreCase("omx.")) { 321 return new ACodec; 322 } else if (name.startsWithIgnoreCase("android.filter.")) { 323 return new MediaFilter; 324 } else { 325 return NULL; 326 } 327} 328 329status_t MediaCodec::init(const AString &name, bool nameIsType, bool encoder) { 330 mResourceManagerService->init(); 331 332 // save init parameters for reset 333 mInitName = name; 334 mInitNameIsType = nameIsType; 335 mInitIsEncoder = encoder; 336 337 // Current video decoders do not return from OMX_FillThisBuffer 338 // quickly, violating the OpenMAX specs, until that is remedied 339 // we need to invest in an extra looper to free the main event 340 // queue. 341 342 mCodec = GetCodecBase(name, nameIsType); 343 if (mCodec == NULL) { 344 return NAME_NOT_FOUND; 345 } 346 347 bool secureCodec = false; 348 if (nameIsType && !strncasecmp(name.c_str(), "video/", 6)) { 349 mIsVideo = true; 350 } else { 351 AString tmp = name; 352 if (tmp.endsWith(".secure")) { 353 secureCodec = true; 354 tmp.erase(tmp.size() - 7, 7); 355 } 356 const sp<IMediaCodecList> mcl = MediaCodecList::getInstance(); 357 if (mcl == NULL) { 358 mCodec = NULL; // remove the codec. 359 return NO_INIT; // if called from Java should raise IOException 360 } 361 ssize_t codecIdx = mcl->findCodecByName(tmp.c_str()); 362 if (codecIdx >= 0) { 363 const sp<MediaCodecInfo> info = mcl->getCodecInfo(codecIdx); 364 Vector<AString> mimes; 365 info->getSupportedMimes(&mimes); 366 for (size_t i = 0; i < mimes.size(); i++) { 367 if (mimes[i].startsWith("video/")) { 368 mIsVideo = true; 369 break; 370 } 371 } 372 } 373 } 374 375 if (mIsVideo) { 376 // video codec needs dedicated looper 377 if (mCodecLooper == NULL) { 378 mCodecLooper = new ALooper; 379 mCodecLooper->setName("CodecLooper"); 380 mCodecLooper->start(false, false, ANDROID_PRIORITY_AUDIO); 381 } 382 383 mCodecLooper->registerHandler(mCodec); 384 } else { 385 mLooper->registerHandler(mCodec); 386 } 387 388 mLooper->registerHandler(this); 389 390 mCodec->setNotificationMessage(new AMessage(kWhatCodecNotify, this)); 391 392 sp<AMessage> msg = new AMessage(kWhatInit, this); 393 msg->setString("name", name); 394 msg->setInt32("nameIsType", nameIsType); 395 396 if (nameIsType) { 397 msg->setInt32("encoder", encoder); 398 } 399 400 status_t err; 401 Vector<MediaResource> resources; 402 MediaResource::Type type = 403 secureCodec ? MediaResource::kSecureCodec : MediaResource::kNonSecureCodec; 404 MediaResource::SubType subtype = 405 mIsVideo ? MediaResource::kVideoCodec : MediaResource::kAudioCodec; 406 resources.push_back(MediaResource(type, subtype, 1)); 407 for (int i = 0; i <= kMaxRetry; ++i) { 408 if (i > 0) { 409 // Don't try to reclaim resource for the first time. 410 if (!mResourceManagerService->reclaimResource(resources)) { 411 break; 412 } 413 } 414 415 sp<AMessage> response; 416 err = PostAndAwaitResponse(msg, &response); 417 if (!isResourceError(err)) { 418 break; 419 } 420 } 421 return err; 422} 423 424status_t MediaCodec::setCallback(const sp<AMessage> &callback) { 425 sp<AMessage> msg = new AMessage(kWhatSetCallback, this); 426 msg->setMessage("callback", callback); 427 428 sp<AMessage> response; 429 return PostAndAwaitResponse(msg, &response); 430} 431 432status_t MediaCodec::setOnFrameRenderedNotification(const sp<AMessage> ¬ify) { 433 sp<AMessage> msg = new AMessage(kWhatSetNotification, this); 434 msg->setMessage("on-frame-rendered", notify); 435 return msg->post(); 436} 437 438status_t MediaCodec::configure( 439 const sp<AMessage> &format, 440 const sp<Surface> &surface, 441 const sp<ICrypto> &crypto, 442 uint32_t flags) { 443 sp<AMessage> msg = new AMessage(kWhatConfigure, this); 444 445 if (mIsVideo) { 446 format->findInt32("width", &mVideoWidth); 447 format->findInt32("height", &mVideoHeight); 448 if (!format->findInt32("rotation-degrees", &mRotationDegrees)) { 449 mRotationDegrees = 0; 450 } 451 452 // Prevent possible integer overflow in downstream code. 453 if (mInitIsEncoder 454 && (uint64_t)mVideoWidth * mVideoHeight > (uint64_t)INT32_MAX / 4) { 455 ALOGE("buffer size is too big, width=%d, height=%d", mVideoWidth, mVideoHeight); 456 return BAD_VALUE; 457 } 458 } 459 460 msg->setMessage("format", format); 461 msg->setInt32("flags", flags); 462 msg->setObject("surface", surface); 463 464 if (crypto != NULL) { 465 msg->setPointer("crypto", crypto.get()); 466 } 467 468 // save msg for reset 469 mConfigureMsg = msg; 470 471 status_t err; 472 Vector<MediaResource> resources; 473 MediaResource::Type type = (mFlags & kFlagIsSecure) ? 474 MediaResource::kSecureCodec : MediaResource::kNonSecureCodec; 475 MediaResource::SubType subtype = 476 mIsVideo ? MediaResource::kVideoCodec : MediaResource::kAudioCodec; 477 resources.push_back(MediaResource(type, subtype, 1)); 478 // Don't know the buffer size at this point, but it's fine to use 1 because 479 // the reclaimResource call doesn't consider the requester's buffer size for now. 480 resources.push_back(MediaResource(MediaResource::kGraphicMemory, 1)); 481 for (int i = 0; i <= kMaxRetry; ++i) { 482 if (i > 0) { 483 // Don't try to reclaim resource for the first time. 484 if (!mResourceManagerService->reclaimResource(resources)) { 485 break; 486 } 487 } 488 489 sp<AMessage> response; 490 err = PostAndAwaitResponse(msg, &response); 491 if (err != OK && err != INVALID_OPERATION) { 492 // MediaCodec now set state to UNINITIALIZED upon any fatal error. 493 // To maintain backward-compatibility, do a reset() to put codec 494 // back into INITIALIZED state. 495 // But don't reset if the err is INVALID_OPERATION, which means 496 // the configure failure is due to wrong state. 497 498 ALOGE("configure failed with err 0x%08x, resetting...", err); 499 reset(); 500 } 501 if (!isResourceError(err)) { 502 break; 503 } 504 } 505 return err; 506} 507 508status_t MediaCodec::setInputSurface( 509 const sp<PersistentSurface> &surface) { 510 sp<AMessage> msg = new AMessage(kWhatSetInputSurface, this); 511 msg->setObject("input-surface", surface.get()); 512 513 sp<AMessage> response; 514 return PostAndAwaitResponse(msg, &response); 515} 516 517status_t MediaCodec::setSurface(const sp<Surface> &surface) { 518 sp<AMessage> msg = new AMessage(kWhatSetSurface, this); 519 msg->setObject("surface", surface); 520 521 sp<AMessage> response; 522 return PostAndAwaitResponse(msg, &response); 523} 524 525status_t MediaCodec::createInputSurface( 526 sp<IGraphicBufferProducer>* bufferProducer) { 527 sp<AMessage> msg = new AMessage(kWhatCreateInputSurface, this); 528 529 sp<AMessage> response; 530 status_t err = PostAndAwaitResponse(msg, &response); 531 if (err == NO_ERROR) { 532 // unwrap the sp<IGraphicBufferProducer> 533 sp<RefBase> obj; 534 bool found = response->findObject("input-surface", &obj); 535 CHECK(found); 536 sp<BufferProducerWrapper> wrapper( 537 static_cast<BufferProducerWrapper*>(obj.get())); 538 *bufferProducer = wrapper->getBufferProducer(); 539 } else { 540 ALOGW("createInputSurface failed, err=%d", err); 541 } 542 return err; 543} 544 545uint64_t MediaCodec::getGraphicBufferSize() { 546 if (!mIsVideo) { 547 return 0; 548 } 549 550 uint64_t size = 0; 551 size_t portNum = sizeof(mPortBuffers) / sizeof((mPortBuffers)[0]); 552 for (size_t i = 0; i < portNum; ++i) { 553 // TODO: this is just an estimation, we should get the real buffer size from ACodec. 554 size += mPortBuffers[i].size() * mVideoWidth * mVideoHeight * 3 / 2; 555 } 556 return size; 557} 558 559void MediaCodec::addResource( 560 MediaResource::Type type, MediaResource::SubType subtype, uint64_t value) { 561 Vector<MediaResource> resources; 562 resources.push_back(MediaResource(type, subtype, value)); 563 mResourceManagerService->addResource( 564 getId(mResourceManagerClient), mResourceManagerClient, resources); 565} 566 567status_t MediaCodec::start() { 568 sp<AMessage> msg = new AMessage(kWhatStart, this); 569 570 status_t err; 571 Vector<MediaResource> resources; 572 MediaResource::Type type = (mFlags & kFlagIsSecure) ? 573 MediaResource::kSecureCodec : MediaResource::kNonSecureCodec; 574 MediaResource::SubType subtype = 575 mIsVideo ? MediaResource::kVideoCodec : MediaResource::kAudioCodec; 576 resources.push_back(MediaResource(type, subtype, 1)); 577 // Don't know the buffer size at this point, but it's fine to use 1 because 578 // the reclaimResource call doesn't consider the requester's buffer size for now. 579 resources.push_back(MediaResource(MediaResource::kGraphicMemory, 1)); 580 for (int i = 0; i <= kMaxRetry; ++i) { 581 if (i > 0) { 582 // Don't try to reclaim resource for the first time. 583 if (!mResourceManagerService->reclaimResource(resources)) { 584 break; 585 } 586 // Recover codec from previous error before retry start. 587 err = reset(); 588 if (err != OK) { 589 ALOGE("retrying start: failed to reset codec"); 590 break; 591 } 592 sp<AMessage> response; 593 err = PostAndAwaitResponse(mConfigureMsg, &response); 594 if (err != OK) { 595 ALOGE("retrying start: failed to configure codec"); 596 break; 597 } 598 } 599 600 sp<AMessage> response; 601 err = PostAndAwaitResponse(msg, &response); 602 if (!isResourceError(err)) { 603 break; 604 } 605 } 606 return err; 607} 608 609status_t MediaCodec::stop() { 610 sp<AMessage> msg = new AMessage(kWhatStop, this); 611 612 sp<AMessage> response; 613 return PostAndAwaitResponse(msg, &response); 614} 615 616bool MediaCodec::hasPendingBuffer(int portIndex) { 617 const Vector<BufferInfo> &buffers = mPortBuffers[portIndex]; 618 for (size_t i = 0; i < buffers.size(); ++i) { 619 const BufferInfo &info = buffers.itemAt(i); 620 if (info.mOwnedByClient) { 621 return true; 622 } 623 } 624 return false; 625} 626 627bool MediaCodec::hasPendingBuffer() { 628 return hasPendingBuffer(kPortIndexInput) || hasPendingBuffer(kPortIndexOutput); 629} 630 631status_t MediaCodec::reclaim(bool force) { 632 ALOGD("MediaCodec::reclaim(%p) %s", this, mInitName.c_str()); 633 sp<AMessage> msg = new AMessage(kWhatRelease, this); 634 msg->setInt32("reclaimed", 1); 635 msg->setInt32("force", force ? 1 : 0); 636 637 sp<AMessage> response; 638 status_t ret = PostAndAwaitResponse(msg, &response); 639 if (ret == -ENOENT) { 640 ALOGD("MediaCodec looper is gone, skip reclaim"); 641 ret = OK; 642 } 643 return ret; 644} 645 646status_t MediaCodec::release() { 647 sp<AMessage> msg = new AMessage(kWhatRelease, this); 648 649 sp<AMessage> response; 650 return PostAndAwaitResponse(msg, &response); 651} 652 653status_t MediaCodec::reset() { 654 /* When external-facing MediaCodec object is created, 655 it is already initialized. Thus, reset is essentially 656 release() followed by init(), plus clearing the state */ 657 658 status_t err = release(); 659 660 // unregister handlers 661 if (mCodec != NULL) { 662 if (mCodecLooper != NULL) { 663 mCodecLooper->unregisterHandler(mCodec->id()); 664 } else { 665 mLooper->unregisterHandler(mCodec->id()); 666 } 667 mCodec = NULL; 668 } 669 mLooper->unregisterHandler(id()); 670 671 mFlags = 0; // clear all flags 672 mStickyError = OK; 673 674 // reset state not reset by setState(UNINITIALIZED) 675 mReplyID = 0; 676 mDequeueInputReplyID = 0; 677 mDequeueOutputReplyID = 0; 678 mDequeueInputTimeoutGeneration = 0; 679 mDequeueOutputTimeoutGeneration = 0; 680 mHaveInputSurface = false; 681 682 if (err == OK) { 683 err = init(mInitName, mInitNameIsType, mInitIsEncoder); 684 } 685 return err; 686} 687 688status_t MediaCodec::queueInputBuffer( 689 size_t index, 690 size_t offset, 691 size_t size, 692 int64_t presentationTimeUs, 693 uint32_t flags, 694 AString *errorDetailMsg) { 695 if (errorDetailMsg != NULL) { 696 errorDetailMsg->clear(); 697 } 698 699 sp<AMessage> msg = new AMessage(kWhatQueueInputBuffer, this); 700 msg->setSize("index", index); 701 msg->setSize("offset", offset); 702 msg->setSize("size", size); 703 msg->setInt64("timeUs", presentationTimeUs); 704 msg->setInt32("flags", flags); 705 msg->setPointer("errorDetailMsg", errorDetailMsg); 706 707 sp<AMessage> response; 708 return PostAndAwaitResponse(msg, &response); 709} 710 711status_t MediaCodec::queueSecureInputBuffer( 712 size_t index, 713 size_t offset, 714 const CryptoPlugin::SubSample *subSamples, 715 size_t numSubSamples, 716 const uint8_t key[16], 717 const uint8_t iv[16], 718 CryptoPlugin::Mode mode, 719 const CryptoPlugin::Pattern &pattern, 720 int64_t presentationTimeUs, 721 uint32_t flags, 722 AString *errorDetailMsg) { 723 if (errorDetailMsg != NULL) { 724 errorDetailMsg->clear(); 725 } 726 727 sp<AMessage> msg = new AMessage(kWhatQueueInputBuffer, this); 728 msg->setSize("index", index); 729 msg->setSize("offset", offset); 730 msg->setPointer("subSamples", (void *)subSamples); 731 msg->setSize("numSubSamples", numSubSamples); 732 msg->setPointer("key", (void *)key); 733 msg->setPointer("iv", (void *)iv); 734 msg->setInt32("mode", mode); 735 msg->setInt32("encryptBlocks", pattern.mEncryptBlocks); 736 msg->setInt32("skipBlocks", pattern.mSkipBlocks); 737 msg->setInt64("timeUs", presentationTimeUs); 738 msg->setInt32("flags", flags); 739 msg->setPointer("errorDetailMsg", errorDetailMsg); 740 741 sp<AMessage> response; 742 status_t err = PostAndAwaitResponse(msg, &response); 743 744 return err; 745} 746 747status_t MediaCodec::dequeueInputBuffer(size_t *index, int64_t timeoutUs) { 748 sp<AMessage> msg = new AMessage(kWhatDequeueInputBuffer, this); 749 msg->setInt64("timeoutUs", timeoutUs); 750 751 sp<AMessage> response; 752 status_t err; 753 if ((err = PostAndAwaitResponse(msg, &response)) != OK) { 754 return err; 755 } 756 757 CHECK(response->findSize("index", index)); 758 759 return OK; 760} 761 762status_t MediaCodec::dequeueOutputBuffer( 763 size_t *index, 764 size_t *offset, 765 size_t *size, 766 int64_t *presentationTimeUs, 767 uint32_t *flags, 768 int64_t timeoutUs) { 769 sp<AMessage> msg = new AMessage(kWhatDequeueOutputBuffer, this); 770 msg->setInt64("timeoutUs", timeoutUs); 771 772 sp<AMessage> response; 773 status_t err; 774 if ((err = PostAndAwaitResponse(msg, &response)) != OK) { 775 return err; 776 } 777 778 CHECK(response->findSize("index", index)); 779 CHECK(response->findSize("offset", offset)); 780 CHECK(response->findSize("size", size)); 781 CHECK(response->findInt64("timeUs", presentationTimeUs)); 782 CHECK(response->findInt32("flags", (int32_t *)flags)); 783 784 return OK; 785} 786 787status_t MediaCodec::renderOutputBufferAndRelease(size_t index) { 788 sp<AMessage> msg = new AMessage(kWhatReleaseOutputBuffer, this); 789 msg->setSize("index", index); 790 msg->setInt32("render", true); 791 792 sp<AMessage> response; 793 return PostAndAwaitResponse(msg, &response); 794} 795 796status_t MediaCodec::renderOutputBufferAndRelease(size_t index, int64_t timestampNs) { 797 sp<AMessage> msg = new AMessage(kWhatReleaseOutputBuffer, this); 798 msg->setSize("index", index); 799 msg->setInt32("render", true); 800 msg->setInt64("timestampNs", timestampNs); 801 802 sp<AMessage> response; 803 return PostAndAwaitResponse(msg, &response); 804} 805 806status_t MediaCodec::releaseOutputBuffer(size_t index) { 807 sp<AMessage> msg = new AMessage(kWhatReleaseOutputBuffer, this); 808 msg->setSize("index", index); 809 810 sp<AMessage> response; 811 return PostAndAwaitResponse(msg, &response); 812} 813 814status_t MediaCodec::signalEndOfInputStream() { 815 sp<AMessage> msg = new AMessage(kWhatSignalEndOfInputStream, this); 816 817 sp<AMessage> response; 818 return PostAndAwaitResponse(msg, &response); 819} 820 821status_t MediaCodec::getOutputFormat(sp<AMessage> *format) const { 822 sp<AMessage> msg = new AMessage(kWhatGetOutputFormat, this); 823 824 sp<AMessage> response; 825 status_t err; 826 if ((err = PostAndAwaitResponse(msg, &response)) != OK) { 827 return err; 828 } 829 830 CHECK(response->findMessage("format", format)); 831 832 return OK; 833} 834 835status_t MediaCodec::getInputFormat(sp<AMessage> *format) const { 836 sp<AMessage> msg = new AMessage(kWhatGetInputFormat, this); 837 838 sp<AMessage> response; 839 status_t err; 840 if ((err = PostAndAwaitResponse(msg, &response)) != OK) { 841 return err; 842 } 843 844 CHECK(response->findMessage("format", format)); 845 846 return OK; 847} 848 849status_t MediaCodec::getName(AString *name) const { 850 sp<AMessage> msg = new AMessage(kWhatGetName, this); 851 852 sp<AMessage> response; 853 status_t err; 854 if ((err = PostAndAwaitResponse(msg, &response)) != OK) { 855 return err; 856 } 857 858 CHECK(response->findString("name", name)); 859 860 return OK; 861} 862 863status_t MediaCodec::getWidevineLegacyBuffers(Vector<sp<ABuffer> > *buffers) const { 864 sp<AMessage> msg = new AMessage(kWhatGetBuffers, this); 865 msg->setInt32("portIndex", kPortIndexInput); 866 msg->setPointer("buffers", buffers); 867 msg->setInt32("widevine", true); 868 869 sp<AMessage> response; 870 return PostAndAwaitResponse(msg, &response); 871} 872 873status_t MediaCodec::getInputBuffers(Vector<sp<ABuffer> > *buffers) const { 874 sp<AMessage> msg = new AMessage(kWhatGetBuffers, this); 875 msg->setInt32("portIndex", kPortIndexInput); 876 msg->setPointer("buffers", buffers); 877 878 sp<AMessage> response; 879 return PostAndAwaitResponse(msg, &response); 880} 881 882status_t MediaCodec::getOutputBuffers(Vector<sp<ABuffer> > *buffers) const { 883 sp<AMessage> msg = new AMessage(kWhatGetBuffers, this); 884 msg->setInt32("portIndex", kPortIndexOutput); 885 msg->setPointer("buffers", buffers); 886 887 sp<AMessage> response; 888 return PostAndAwaitResponse(msg, &response); 889} 890 891status_t MediaCodec::getOutputBuffer(size_t index, sp<ABuffer> *buffer) { 892 sp<AMessage> format; 893 return getBufferAndFormat(kPortIndexOutput, index, buffer, &format); 894} 895 896status_t MediaCodec::getOutputFormat(size_t index, sp<AMessage> *format) { 897 sp<ABuffer> buffer; 898 return getBufferAndFormat(kPortIndexOutput, index, &buffer, format); 899} 900 901status_t MediaCodec::getInputBuffer(size_t index, sp<ABuffer> *buffer) { 902 sp<AMessage> format; 903 return getBufferAndFormat(kPortIndexInput, index, buffer, &format); 904} 905 906bool MediaCodec::isExecuting() const { 907 return mState == STARTED || mState == FLUSHED; 908} 909 910status_t MediaCodec::getBufferAndFormat( 911 size_t portIndex, size_t index, 912 sp<ABuffer> *buffer, sp<AMessage> *format) { 913 // use mutex instead of a context switch 914 if (mReleasedByResourceManager) { 915 ALOGE("getBufferAndFormat - resource already released"); 916 return DEAD_OBJECT; 917 } 918 919 if (buffer == NULL) { 920 ALOGE("getBufferAndFormat - null ABuffer"); 921 return INVALID_OPERATION; 922 } 923 924 if (format == NULL) { 925 ALOGE("getBufferAndFormat - null AMessage"); 926 return INVALID_OPERATION; 927 } 928 929 buffer->clear(); 930 format->clear(); 931 932 if (!isExecuting()) { 933 ALOGE("getBufferAndFormat - not executing"); 934 return INVALID_OPERATION; 935 } 936 937 // we do not want mPortBuffers to change during this section 938 // we also don't want mOwnedByClient to change during this 939 Mutex::Autolock al(mBufferLock); 940 941 Vector<BufferInfo> *buffers = &mPortBuffers[portIndex]; 942 if (index >= buffers->size()) { 943 ALOGE("getBufferAndFormat - trying to get buffer with " 944 "bad index (index=%zu buffer_size=%zu)", index, buffers->size()); 945 return INVALID_OPERATION; 946 } 947 948 const BufferInfo &info = buffers->itemAt(index); 949 if (!info.mOwnedByClient) { 950 ALOGE("getBufferAndFormat - invalid operation " 951 "(the index %zu is not owned by client)", index); 952 return INVALID_OPERATION; 953 } 954 955 // by the time buffers array is initialized, crypto is set 956 *buffer = (portIndex == kPortIndexInput && mCrypto != NULL) ? 957 info.mEncryptedData : 958 info.mData; 959 960 *format = info.mFormat; 961 962 return OK; 963} 964 965status_t MediaCodec::flush() { 966 sp<AMessage> msg = new AMessage(kWhatFlush, this); 967 968 sp<AMessage> response; 969 return PostAndAwaitResponse(msg, &response); 970} 971 972status_t MediaCodec::requestIDRFrame() { 973 (new AMessage(kWhatRequestIDRFrame, this))->post(); 974 975 return OK; 976} 977 978void MediaCodec::requestActivityNotification(const sp<AMessage> ¬ify) { 979 sp<AMessage> msg = new AMessage(kWhatRequestActivityNotification, this); 980 msg->setMessage("notify", notify); 981 msg->post(); 982} 983 984//////////////////////////////////////////////////////////////////////////////// 985 986void MediaCodec::cancelPendingDequeueOperations() { 987 if (mFlags & kFlagDequeueInputPending) { 988 PostReplyWithError(mDequeueInputReplyID, INVALID_OPERATION); 989 990 ++mDequeueInputTimeoutGeneration; 991 mDequeueInputReplyID = 0; 992 mFlags &= ~kFlagDequeueInputPending; 993 } 994 995 if (mFlags & kFlagDequeueOutputPending) { 996 PostReplyWithError(mDequeueOutputReplyID, INVALID_OPERATION); 997 998 ++mDequeueOutputTimeoutGeneration; 999 mDequeueOutputReplyID = 0; 1000 mFlags &= ~kFlagDequeueOutputPending; 1001 } 1002} 1003 1004bool MediaCodec::handleDequeueInputBuffer(const sp<AReplyToken> &replyID, bool newRequest) { 1005 if (!isExecuting() || (mFlags & kFlagIsAsync) 1006 || (newRequest && (mFlags & kFlagDequeueInputPending))) { 1007 PostReplyWithError(replyID, INVALID_OPERATION); 1008 return true; 1009 } else if (mFlags & kFlagStickyError) { 1010 PostReplyWithError(replyID, getStickyError()); 1011 return true; 1012 } 1013 1014 ssize_t index = dequeuePortBuffer(kPortIndexInput); 1015 1016 if (index < 0) { 1017 CHECK_EQ(index, -EAGAIN); 1018 return false; 1019 } 1020 1021 sp<AMessage> response = new AMessage; 1022 response->setSize("index", index); 1023 response->postReply(replyID); 1024 1025 return true; 1026} 1027 1028bool MediaCodec::handleDequeueOutputBuffer(const sp<AReplyToken> &replyID, bool newRequest) { 1029 if (!isExecuting() || (mFlags & kFlagIsAsync) 1030 || (newRequest && (mFlags & kFlagDequeueOutputPending))) { 1031 PostReplyWithError(replyID, INVALID_OPERATION); 1032 } else if (mFlags & kFlagStickyError) { 1033 PostReplyWithError(replyID, getStickyError()); 1034 } else if (mFlags & kFlagOutputBuffersChanged) { 1035 PostReplyWithError(replyID, INFO_OUTPUT_BUFFERS_CHANGED); 1036 mFlags &= ~kFlagOutputBuffersChanged; 1037 } else if (mFlags & kFlagOutputFormatChanged) { 1038 PostReplyWithError(replyID, INFO_FORMAT_CHANGED); 1039 mFlags &= ~kFlagOutputFormatChanged; 1040 } else { 1041 sp<AMessage> response = new AMessage; 1042 ssize_t index = dequeuePortBuffer(kPortIndexOutput); 1043 1044 if (index < 0) { 1045 CHECK_EQ(index, -EAGAIN); 1046 return false; 1047 } 1048 1049 const sp<ABuffer> &buffer = 1050 mPortBuffers[kPortIndexOutput].itemAt(index).mData; 1051 1052 response->setSize("index", index); 1053 response->setSize("offset", buffer->offset()); 1054 response->setSize("size", buffer->size()); 1055 1056 int64_t timeUs; 1057 CHECK(buffer->meta()->findInt64("timeUs", &timeUs)); 1058 1059 response->setInt64("timeUs", timeUs); 1060 1061 int32_t omxFlags; 1062 CHECK(buffer->meta()->findInt32("omxFlags", &omxFlags)); 1063 1064 uint32_t flags = 0; 1065 if (omxFlags & OMX_BUFFERFLAG_SYNCFRAME) { 1066 flags |= BUFFER_FLAG_SYNCFRAME; 1067 } 1068 if (omxFlags & OMX_BUFFERFLAG_CODECCONFIG) { 1069 flags |= BUFFER_FLAG_CODECCONFIG; 1070 } 1071 if (omxFlags & OMX_BUFFERFLAG_EOS) { 1072 flags |= BUFFER_FLAG_EOS; 1073 } 1074 1075 response->setInt32("flags", flags); 1076 response->postReply(replyID); 1077 } 1078 1079 return true; 1080} 1081 1082void MediaCodec::onMessageReceived(const sp<AMessage> &msg) { 1083 switch (msg->what()) { 1084 case kWhatCodecNotify: 1085 { 1086 int32_t what; 1087 CHECK(msg->findInt32("what", &what)); 1088 1089 switch (what) { 1090 case CodecBase::kWhatError: 1091 { 1092 int32_t err, actionCode; 1093 CHECK(msg->findInt32("err", &err)); 1094 CHECK(msg->findInt32("actionCode", &actionCode)); 1095 1096 ALOGE("Codec reported err %#x, actionCode %d, while in state %d", 1097 err, actionCode, mState); 1098 if (err == DEAD_OBJECT) { 1099 mFlags |= kFlagSawMediaServerDie; 1100 mFlags &= ~kFlagIsComponentAllocated; 1101 } 1102 1103 bool sendErrorResponse = true; 1104 1105 switch (mState) { 1106 case INITIALIZING: 1107 { 1108 setState(UNINITIALIZED); 1109 break; 1110 } 1111 1112 case CONFIGURING: 1113 { 1114 setState(actionCode == ACTION_CODE_FATAL ? 1115 UNINITIALIZED : INITIALIZED); 1116 break; 1117 } 1118 1119 case STARTING: 1120 { 1121 setState(actionCode == ACTION_CODE_FATAL ? 1122 UNINITIALIZED : CONFIGURED); 1123 break; 1124 } 1125 1126 case STOPPING: 1127 case RELEASING: 1128 { 1129 // Ignore the error, assuming we'll still get 1130 // the shutdown complete notification. 1131 1132 sendErrorResponse = false; 1133 1134 if (mFlags & kFlagSawMediaServerDie) { 1135 // MediaServer died, there definitely won't 1136 // be a shutdown complete notification after 1137 // all. 1138 1139 // note that we're directly going from 1140 // STOPPING->UNINITIALIZED, instead of the 1141 // usual STOPPING->INITIALIZED state. 1142 setState(UNINITIALIZED); 1143 if (mState == RELEASING) { 1144 mComponentName.clear(); 1145 } 1146 (new AMessage)->postReply(mReplyID); 1147 } 1148 break; 1149 } 1150 1151 case FLUSHING: 1152 { 1153 if (actionCode == ACTION_CODE_FATAL) { 1154 setState(UNINITIALIZED); 1155 } else { 1156 setState( 1157 (mFlags & kFlagIsAsync) ? FLUSHED : STARTED); 1158 } 1159 break; 1160 } 1161 1162 case FLUSHED: 1163 case STARTED: 1164 { 1165 sendErrorResponse = false; 1166 1167 setStickyError(err); 1168 postActivityNotificationIfPossible(); 1169 1170 cancelPendingDequeueOperations(); 1171 1172 if (mFlags & kFlagIsAsync) { 1173 onError(err, actionCode); 1174 } 1175 switch (actionCode) { 1176 case ACTION_CODE_TRANSIENT: 1177 break; 1178 case ACTION_CODE_RECOVERABLE: 1179 setState(INITIALIZED); 1180 break; 1181 default: 1182 setState(UNINITIALIZED); 1183 break; 1184 } 1185 break; 1186 } 1187 1188 default: 1189 { 1190 sendErrorResponse = false; 1191 1192 setStickyError(err); 1193 postActivityNotificationIfPossible(); 1194 1195 // actionCode in an uninitialized state is always fatal. 1196 if (mState == UNINITIALIZED) { 1197 actionCode = ACTION_CODE_FATAL; 1198 } 1199 if (mFlags & kFlagIsAsync) { 1200 onError(err, actionCode); 1201 } 1202 switch (actionCode) { 1203 case ACTION_CODE_TRANSIENT: 1204 break; 1205 case ACTION_CODE_RECOVERABLE: 1206 setState(INITIALIZED); 1207 break; 1208 default: 1209 setState(UNINITIALIZED); 1210 break; 1211 } 1212 break; 1213 } 1214 } 1215 1216 if (sendErrorResponse) { 1217 PostReplyWithError(mReplyID, err); 1218 } 1219 break; 1220 } 1221 1222 case CodecBase::kWhatComponentAllocated: 1223 { 1224 CHECK_EQ(mState, INITIALIZING); 1225 setState(INITIALIZED); 1226 mFlags |= kFlagIsComponentAllocated; 1227 1228 CHECK(msg->findString("componentName", &mComponentName)); 1229 1230 if (mComponentName.startsWith("OMX.google.")) { 1231 mFlags |= kFlagUsesSoftwareRenderer; 1232 } else { 1233 mFlags &= ~kFlagUsesSoftwareRenderer; 1234 } 1235 1236 MediaResource::Type resourceType; 1237 if (mComponentName.endsWith(".secure")) { 1238 mFlags |= kFlagIsSecure; 1239 resourceType = MediaResource::kSecureCodec; 1240 } else { 1241 mFlags &= ~kFlagIsSecure; 1242 resourceType = MediaResource::kNonSecureCodec; 1243 } 1244 1245 if (mIsVideo) { 1246 // audio codec is currently ignored. 1247 addResource(resourceType, MediaResource::kVideoCodec, 1); 1248 } 1249 1250 (new AMessage)->postReply(mReplyID); 1251 break; 1252 } 1253 1254 case CodecBase::kWhatComponentConfigured: 1255 { 1256 if (mState == UNINITIALIZED || mState == INITIALIZED) { 1257 // In case a kWhatError message came in and replied with error, 1258 // we log a warning and ignore. 1259 ALOGW("configure interrupted by error, current state %d", mState); 1260 break; 1261 } 1262 CHECK_EQ(mState, CONFIGURING); 1263 1264 // reset input surface flag 1265 mHaveInputSurface = false; 1266 1267 CHECK(msg->findMessage("input-format", &mInputFormat)); 1268 CHECK(msg->findMessage("output-format", &mOutputFormat)); 1269 ALOGV("[%s] configured as input format: %s, output format: %s", 1270 mComponentName.c_str(), 1271 mInputFormat->debugString(4).c_str(), 1272 mOutputFormat->debugString(4).c_str()); 1273 int32_t usingSwRenderer; 1274 if (mOutputFormat->findInt32("using-sw-renderer", &usingSwRenderer) 1275 && usingSwRenderer) { 1276 mFlags |= kFlagUsesSoftwareRenderer; 1277 } 1278 setState(CONFIGURED); 1279 (new AMessage)->postReply(mReplyID); 1280 break; 1281 } 1282 1283 case CodecBase::kWhatInputSurfaceCreated: 1284 { 1285 // response to initiateCreateInputSurface() 1286 status_t err = NO_ERROR; 1287 sp<AMessage> response = new AMessage; 1288 if (!msg->findInt32("err", &err)) { 1289 sp<RefBase> obj; 1290 msg->findObject("input-surface", &obj); 1291 CHECK(msg->findMessage("input-format", &mInputFormat)); 1292 CHECK(msg->findMessage("output-format", &mOutputFormat)); 1293 ALOGV("[%s] input surface created as input format: %s, output format: %s", 1294 mComponentName.c_str(), 1295 mInputFormat->debugString(4).c_str(), 1296 mOutputFormat->debugString(4).c_str()); 1297 CHECK(obj != NULL); 1298 response->setObject("input-surface", obj); 1299 mHaveInputSurface = true; 1300 } else { 1301 response->setInt32("err", err); 1302 } 1303 response->postReply(mReplyID); 1304 break; 1305 } 1306 1307 case CodecBase::kWhatInputSurfaceAccepted: 1308 { 1309 // response to initiateSetInputSurface() 1310 status_t err = NO_ERROR; 1311 sp<AMessage> response = new AMessage(); 1312 if (!msg->findInt32("err", &err)) { 1313 mHaveInputSurface = true; 1314 } else { 1315 response->setInt32("err", err); 1316 } 1317 response->postReply(mReplyID); 1318 break; 1319 } 1320 1321 case CodecBase::kWhatSignaledInputEOS: 1322 { 1323 // response to signalEndOfInputStream() 1324 sp<AMessage> response = new AMessage; 1325 status_t err; 1326 if (msg->findInt32("err", &err)) { 1327 response->setInt32("err", err); 1328 } 1329 response->postReply(mReplyID); 1330 break; 1331 } 1332 1333 1334 case CodecBase::kWhatBuffersAllocated: 1335 { 1336 Mutex::Autolock al(mBufferLock); 1337 int32_t portIndex; 1338 CHECK(msg->findInt32("portIndex", &portIndex)); 1339 1340 ALOGV("%s buffers allocated", 1341 portIndex == kPortIndexInput ? "input" : "output"); 1342 1343 CHECK(portIndex == kPortIndexInput 1344 || portIndex == kPortIndexOutput); 1345 1346 mPortBuffers[portIndex].clear(); 1347 1348 Vector<BufferInfo> *buffers = &mPortBuffers[portIndex]; 1349 1350 sp<RefBase> obj; 1351 CHECK(msg->findObject("portDesc", &obj)); 1352 1353 sp<CodecBase::PortDescription> portDesc = 1354 static_cast<CodecBase::PortDescription *>(obj.get()); 1355 1356 size_t numBuffers = portDesc->countBuffers(); 1357 1358 size_t totalSize = 0; 1359 for (size_t i = 0; i < numBuffers; ++i) { 1360 if (portIndex == kPortIndexInput && mCrypto != NULL) { 1361 totalSize += portDesc->bufferAt(i)->capacity(); 1362 } 1363 } 1364 1365 if (totalSize) { 1366 mDealer = new MemoryDealer(totalSize, "MediaCodec"); 1367 } 1368 1369 for (size_t i = 0; i < numBuffers; ++i) { 1370 BufferInfo info; 1371 info.mBufferID = portDesc->bufferIDAt(i); 1372 info.mOwnedByClient = false; 1373 info.mData = portDesc->bufferAt(i); 1374 info.mNativeHandle = portDesc->handleAt(i); 1375 info.mMemRef = portDesc->memRefAt(i); 1376 1377 if (portIndex == kPortIndexInput && mCrypto != NULL) { 1378 sp<IMemory> mem = mDealer->allocate(info.mData->capacity()); 1379 info.mEncryptedData = 1380 new ABuffer(mem->pointer(), info.mData->capacity()); 1381 info.mSharedEncryptedBuffer = mem; 1382 } 1383 1384 buffers->push_back(info); 1385 } 1386 1387 if (portIndex == kPortIndexOutput) { 1388 if (mState == STARTING) { 1389 // We're always allocating output buffers after 1390 // allocating input buffers, so this is a good 1391 // indication that now all buffers are allocated. 1392 if (mIsVideo) { 1393 addResource( 1394 MediaResource::kGraphicMemory, 1395 MediaResource::kUnspecifiedSubType, 1396 getGraphicBufferSize()); 1397 } 1398 setState(STARTED); 1399 (new AMessage)->postReply(mReplyID); 1400 } else { 1401 mFlags |= kFlagOutputBuffersChanged; 1402 postActivityNotificationIfPossible(); 1403 } 1404 } 1405 break; 1406 } 1407 1408 case CodecBase::kWhatOutputFormatChanged: 1409 { 1410 CHECK(msg->findMessage("format", &mOutputFormat)); 1411 1412 ALOGV("[%s] output format changed to: %s", 1413 mComponentName.c_str(), mOutputFormat->debugString(4).c_str()); 1414 1415 if (mSoftRenderer == NULL && 1416 mSurface != NULL && 1417 (mFlags & kFlagUsesSoftwareRenderer)) { 1418 AString mime; 1419 CHECK(mOutputFormat->findString("mime", &mime)); 1420 1421 // TODO: propagate color aspects to software renderer to allow better 1422 // color conversion to RGB. For now, just mark dataspace for YUV 1423 // rendering. 1424 int32_t dataSpace; 1425 if (mOutputFormat->findInt32("android._dataspace", &dataSpace)) { 1426 ALOGD("[%s] setting dataspace on output surface to #%x", 1427 mComponentName.c_str(), dataSpace); 1428 int err = native_window_set_buffers_data_space( 1429 mSurface.get(), (android_dataspace)dataSpace); 1430 ALOGW_IF(err != 0, "failed to set dataspace on surface (%d)", err); 1431 } 1432 1433 if (mime.startsWithIgnoreCase("video/")) { 1434 mSoftRenderer = new SoftwareRenderer(mSurface, mRotationDegrees); 1435 } 1436 } 1437 1438 if (mFlags & kFlagIsEncoder) { 1439 // Before we announce the format change we should 1440 // collect codec specific data and amend the output 1441 // format as necessary. 1442 mFlags |= kFlagGatherCodecSpecificData; 1443 } else if (mFlags & kFlagIsAsync) { 1444 onOutputFormatChanged(); 1445 } else { 1446 mFlags |= kFlagOutputFormatChanged; 1447 postActivityNotificationIfPossible(); 1448 } 1449 1450 // Notify mCrypto of video resolution changes 1451 if (mCrypto != NULL) { 1452 int32_t left, top, right, bottom, width, height; 1453 if (mOutputFormat->findRect("crop", &left, &top, &right, &bottom)) { 1454 mCrypto->notifyResolution(right - left + 1, bottom - top + 1); 1455 } else if (mOutputFormat->findInt32("width", &width) 1456 && mOutputFormat->findInt32("height", &height)) { 1457 mCrypto->notifyResolution(width, height); 1458 } 1459 } 1460 1461 break; 1462 } 1463 1464 case CodecBase::kWhatOutputFramesRendered: 1465 { 1466 // ignore these in all states except running, and check that we have a 1467 // notification set 1468 if (mState == STARTED && mOnFrameRenderedNotification != NULL) { 1469 sp<AMessage> notify = mOnFrameRenderedNotification->dup(); 1470 notify->setMessage("data", msg); 1471 notify->post(); 1472 } 1473 break; 1474 } 1475 1476 case CodecBase::kWhatFillThisBuffer: 1477 { 1478 /* size_t index = */updateBuffers(kPortIndexInput, msg); 1479 1480 if (mState == FLUSHING 1481 || mState == STOPPING 1482 || mState == RELEASING) { 1483 returnBuffersToCodecOnPort(kPortIndexInput); 1484 break; 1485 } 1486 1487 if (!mCSD.empty()) { 1488 ssize_t index = dequeuePortBuffer(kPortIndexInput); 1489 CHECK_GE(index, 0); 1490 1491 // If codec specific data had been specified as 1492 // part of the format in the call to configure and 1493 // if there's more csd left, we submit it here 1494 // clients only get access to input buffers once 1495 // this data has been exhausted. 1496 1497 status_t err = queueCSDInputBuffer(index); 1498 1499 if (err != OK) { 1500 ALOGE("queueCSDInputBuffer failed w/ error %d", 1501 err); 1502 1503 setStickyError(err); 1504 postActivityNotificationIfPossible(); 1505 1506 cancelPendingDequeueOperations(); 1507 } 1508 break; 1509 } 1510 1511 if (mFlags & kFlagIsAsync) { 1512 if (!mHaveInputSurface) { 1513 if (mState == FLUSHED) { 1514 mHavePendingInputBuffers = true; 1515 } else { 1516 onInputBufferAvailable(); 1517 } 1518 } 1519 } else if (mFlags & kFlagDequeueInputPending) { 1520 CHECK(handleDequeueInputBuffer(mDequeueInputReplyID)); 1521 1522 ++mDequeueInputTimeoutGeneration; 1523 mFlags &= ~kFlagDequeueInputPending; 1524 mDequeueInputReplyID = 0; 1525 } else { 1526 postActivityNotificationIfPossible(); 1527 } 1528 break; 1529 } 1530 1531 case CodecBase::kWhatDrainThisBuffer: 1532 { 1533 /* size_t index = */updateBuffers(kPortIndexOutput, msg); 1534 1535 if (mState == FLUSHING 1536 || mState == STOPPING 1537 || mState == RELEASING) { 1538 returnBuffersToCodecOnPort(kPortIndexOutput); 1539 break; 1540 } 1541 1542 sp<ABuffer> buffer; 1543 CHECK(msg->findBuffer("buffer", &buffer)); 1544 1545 int32_t omxFlags; 1546 CHECK(msg->findInt32("flags", &omxFlags)); 1547 1548 buffer->meta()->setInt32("omxFlags", omxFlags); 1549 1550 if (mFlags & kFlagGatherCodecSpecificData) { 1551 // This is the very first output buffer after a 1552 // format change was signalled, it'll either contain 1553 // the one piece of codec specific data we can expect 1554 // or there won't be codec specific data. 1555 if (omxFlags & OMX_BUFFERFLAG_CODECCONFIG) { 1556 status_t err = 1557 amendOutputFormatWithCodecSpecificData(buffer); 1558 1559 if (err != OK) { 1560 ALOGE("Codec spit out malformed codec " 1561 "specific data!"); 1562 } 1563 } 1564 1565 mFlags &= ~kFlagGatherCodecSpecificData; 1566 if (mFlags & kFlagIsAsync) { 1567 onOutputFormatChanged(); 1568 } else { 1569 mFlags |= kFlagOutputFormatChanged; 1570 } 1571 } 1572 1573 if (mFlags & kFlagIsAsync) { 1574 onOutputBufferAvailable(); 1575 } else if (mFlags & kFlagDequeueOutputPending) { 1576 CHECK(handleDequeueOutputBuffer(mDequeueOutputReplyID)); 1577 1578 ++mDequeueOutputTimeoutGeneration; 1579 mFlags &= ~kFlagDequeueOutputPending; 1580 mDequeueOutputReplyID = 0; 1581 } else { 1582 postActivityNotificationIfPossible(); 1583 } 1584 1585 break; 1586 } 1587 1588 case CodecBase::kWhatEOS: 1589 { 1590 // We already notify the client of this by using the 1591 // corresponding flag in "onOutputBufferReady". 1592 break; 1593 } 1594 1595 case CodecBase::kWhatShutdownCompleted: 1596 { 1597 if (mState == STOPPING) { 1598 setState(INITIALIZED); 1599 } else { 1600 CHECK_EQ(mState, RELEASING); 1601 setState(UNINITIALIZED); 1602 mComponentName.clear(); 1603 } 1604 mFlags &= ~kFlagIsComponentAllocated; 1605 1606 mResourceManagerService->removeResource(getId(mResourceManagerClient)); 1607 1608 (new AMessage)->postReply(mReplyID); 1609 break; 1610 } 1611 1612 case CodecBase::kWhatFlushCompleted: 1613 { 1614 if (mState != FLUSHING) { 1615 ALOGW("received FlushCompleted message in state %d", 1616 mState); 1617 break; 1618 } 1619 1620 if (mFlags & kFlagIsAsync) { 1621 setState(FLUSHED); 1622 } else { 1623 setState(STARTED); 1624 mCodec->signalResume(); 1625 } 1626 1627 (new AMessage)->postReply(mReplyID); 1628 break; 1629 } 1630 1631 default: 1632 TRESPASS(); 1633 } 1634 break; 1635 } 1636 1637 case kWhatInit: 1638 { 1639 sp<AReplyToken> replyID; 1640 CHECK(msg->senderAwaitsResponse(&replyID)); 1641 1642 if (mState != UNINITIALIZED) { 1643 PostReplyWithError(replyID, INVALID_OPERATION); 1644 break; 1645 } 1646 1647 mReplyID = replyID; 1648 setState(INITIALIZING); 1649 1650 AString name; 1651 CHECK(msg->findString("name", &name)); 1652 1653 int32_t nameIsType; 1654 int32_t encoder = false; 1655 CHECK(msg->findInt32("nameIsType", &nameIsType)); 1656 if (nameIsType) { 1657 CHECK(msg->findInt32("encoder", &encoder)); 1658 } 1659 1660 sp<AMessage> format = new AMessage; 1661 1662 if (nameIsType) { 1663 format->setString("mime", name.c_str()); 1664 format->setInt32("encoder", encoder); 1665 } else { 1666 format->setString("componentName", name.c_str()); 1667 } 1668 1669 mCodec->initiateAllocateComponent(format); 1670 break; 1671 } 1672 1673 case kWhatSetNotification: 1674 { 1675 sp<AMessage> notify; 1676 if (msg->findMessage("on-frame-rendered", ¬ify)) { 1677 mOnFrameRenderedNotification = notify; 1678 } 1679 break; 1680 } 1681 1682 case kWhatSetCallback: 1683 { 1684 sp<AReplyToken> replyID; 1685 CHECK(msg->senderAwaitsResponse(&replyID)); 1686 1687 if (mState == UNINITIALIZED 1688 || mState == INITIALIZING 1689 || isExecuting()) { 1690 // callback can't be set after codec is executing, 1691 // or before it's initialized (as the callback 1692 // will be cleared when it goes to INITIALIZED) 1693 PostReplyWithError(replyID, INVALID_OPERATION); 1694 break; 1695 } 1696 1697 sp<AMessage> callback; 1698 CHECK(msg->findMessage("callback", &callback)); 1699 1700 mCallback = callback; 1701 1702 if (mCallback != NULL) { 1703 ALOGI("MediaCodec will operate in async mode"); 1704 mFlags |= kFlagIsAsync; 1705 } else { 1706 mFlags &= ~kFlagIsAsync; 1707 } 1708 1709 sp<AMessage> response = new AMessage; 1710 response->postReply(replyID); 1711 break; 1712 } 1713 1714 case kWhatConfigure: 1715 { 1716 sp<AReplyToken> replyID; 1717 CHECK(msg->senderAwaitsResponse(&replyID)); 1718 1719 if (mState != INITIALIZED) { 1720 PostReplyWithError(replyID, INVALID_OPERATION); 1721 break; 1722 } 1723 1724 sp<RefBase> obj; 1725 CHECK(msg->findObject("surface", &obj)); 1726 1727 sp<AMessage> format; 1728 CHECK(msg->findMessage("format", &format)); 1729 1730 int32_t push; 1731 if (msg->findInt32("push-blank-buffers-on-shutdown", &push) && push != 0) { 1732 mFlags |= kFlagPushBlankBuffersOnShutdown; 1733 } 1734 1735 if (obj != NULL) { 1736 format->setObject("native-window", obj); 1737 status_t err = handleSetSurface(static_cast<Surface *>(obj.get())); 1738 if (err != OK) { 1739 PostReplyWithError(replyID, err); 1740 break; 1741 } 1742 } else { 1743 handleSetSurface(NULL); 1744 } 1745 1746 mReplyID = replyID; 1747 setState(CONFIGURING); 1748 1749 void *crypto; 1750 if (!msg->findPointer("crypto", &crypto)) { 1751 crypto = NULL; 1752 } 1753 1754 mCrypto = static_cast<ICrypto *>(crypto); 1755 1756 uint32_t flags; 1757 CHECK(msg->findInt32("flags", (int32_t *)&flags)); 1758 1759 if (flags & CONFIGURE_FLAG_ENCODE) { 1760 format->setInt32("encoder", true); 1761 mFlags |= kFlagIsEncoder; 1762 } 1763 1764 extractCSD(format); 1765 1766 mCodec->initiateConfigureComponent(format); 1767 break; 1768 } 1769 1770 case kWhatSetSurface: 1771 { 1772 sp<AReplyToken> replyID; 1773 CHECK(msg->senderAwaitsResponse(&replyID)); 1774 1775 status_t err = OK; 1776 sp<Surface> surface; 1777 1778 switch (mState) { 1779 case CONFIGURED: 1780 case STARTED: 1781 case FLUSHED: 1782 { 1783 sp<RefBase> obj; 1784 (void)msg->findObject("surface", &obj); 1785 sp<Surface> surface = static_cast<Surface *>(obj.get()); 1786 if (mSurface == NULL) { 1787 // do not support setting surface if it was not set 1788 err = INVALID_OPERATION; 1789 } else if (obj == NULL) { 1790 // do not support unsetting surface 1791 err = BAD_VALUE; 1792 } else { 1793 err = connectToSurface(surface); 1794 if (err == ALREADY_EXISTS) { 1795 // reconnecting to same surface 1796 err = OK; 1797 } else { 1798 if (err == OK) { 1799 if (mFlags & kFlagUsesSoftwareRenderer) { 1800 if (mSoftRenderer != NULL 1801 && (mFlags & kFlagPushBlankBuffersOnShutdown)) { 1802 pushBlankBuffersToNativeWindow(mSurface.get()); 1803 } 1804 mSoftRenderer = new SoftwareRenderer(surface); 1805 // TODO: check if this was successful 1806 } else { 1807 err = mCodec->setSurface(surface); 1808 } 1809 } 1810 if (err == OK) { 1811 (void)disconnectFromSurface(); 1812 mSurface = surface; 1813 } 1814 } 1815 } 1816 break; 1817 } 1818 1819 default: 1820 err = INVALID_OPERATION; 1821 break; 1822 } 1823 1824 PostReplyWithError(replyID, err); 1825 break; 1826 } 1827 1828 case kWhatCreateInputSurface: 1829 case kWhatSetInputSurface: 1830 { 1831 sp<AReplyToken> replyID; 1832 CHECK(msg->senderAwaitsResponse(&replyID)); 1833 1834 // Must be configured, but can't have been started yet. 1835 if (mState != CONFIGURED) { 1836 PostReplyWithError(replyID, INVALID_OPERATION); 1837 break; 1838 } 1839 1840 mReplyID = replyID; 1841 if (msg->what() == kWhatCreateInputSurface) { 1842 mCodec->initiateCreateInputSurface(); 1843 } else { 1844 sp<RefBase> obj; 1845 CHECK(msg->findObject("input-surface", &obj)); 1846 1847 mCodec->initiateSetInputSurface( 1848 static_cast<PersistentSurface *>(obj.get())); 1849 } 1850 break; 1851 } 1852 case kWhatStart: 1853 { 1854 sp<AReplyToken> replyID; 1855 CHECK(msg->senderAwaitsResponse(&replyID)); 1856 1857 if (mState == FLUSHED) { 1858 setState(STARTED); 1859 if (mHavePendingInputBuffers) { 1860 onInputBufferAvailable(); 1861 mHavePendingInputBuffers = false; 1862 } 1863 mCodec->signalResume(); 1864 PostReplyWithError(replyID, OK); 1865 break; 1866 } else if (mState != CONFIGURED) { 1867 PostReplyWithError(replyID, INVALID_OPERATION); 1868 break; 1869 } 1870 1871 mReplyID = replyID; 1872 setState(STARTING); 1873 1874 mCodec->initiateStart(); 1875 break; 1876 } 1877 1878 case kWhatStop: 1879 case kWhatRelease: 1880 { 1881 State targetState = 1882 (msg->what() == kWhatStop) ? INITIALIZED : UNINITIALIZED; 1883 1884 sp<AReplyToken> replyID; 1885 CHECK(msg->senderAwaitsResponse(&replyID)); 1886 1887 // already stopped/released 1888 if (mState == UNINITIALIZED && mReleasedByResourceManager) { 1889 sp<AMessage> response = new AMessage; 1890 response->setInt32("err", OK); 1891 response->postReply(replyID); 1892 break; 1893 } 1894 1895 int32_t reclaimed = 0; 1896 msg->findInt32("reclaimed", &reclaimed); 1897 if (reclaimed) { 1898 mReleasedByResourceManager = true; 1899 1900 int32_t force = 0; 1901 msg->findInt32("force", &force); 1902 if (!force && hasPendingBuffer()) { 1903 ALOGW("Can't reclaim codec right now due to pending buffers."); 1904 1905 // return WOULD_BLOCK to ask resource manager to retry later. 1906 sp<AMessage> response = new AMessage; 1907 response->setInt32("err", WOULD_BLOCK); 1908 response->postReply(replyID); 1909 1910 // notify the async client 1911 if (mFlags & kFlagIsAsync) { 1912 onError(DEAD_OBJECT, ACTION_CODE_FATAL); 1913 } 1914 break; 1915 } 1916 } 1917 1918 if (!((mFlags & kFlagIsComponentAllocated) && targetState == UNINITIALIZED) // See 1 1919 && mState != INITIALIZED 1920 && mState != CONFIGURED && !isExecuting()) { 1921 // 1) Permit release to shut down the component if allocated. 1922 // 1923 // 2) We may be in "UNINITIALIZED" state already and 1924 // also shutdown the encoder/decoder without the 1925 // client being aware of this if media server died while 1926 // we were being stopped. The client would assume that 1927 // after stop() returned, it would be safe to call release() 1928 // and it should be in this case, no harm to allow a release() 1929 // if we're already uninitialized. 1930 sp<AMessage> response = new AMessage; 1931 // TODO: we shouldn't throw an exception for stop/release. Change this to wait until 1932 // the previous stop/release completes and then reply with OK. 1933 status_t err = mState == targetState ? OK : INVALID_OPERATION; 1934 response->setInt32("err", err); 1935 if (err == OK && targetState == UNINITIALIZED) { 1936 mComponentName.clear(); 1937 } 1938 response->postReply(replyID); 1939 break; 1940 } 1941 1942 if (mFlags & kFlagSawMediaServerDie) { 1943 // It's dead, Jim. Don't expect initiateShutdown to yield 1944 // any useful results now... 1945 setState(UNINITIALIZED); 1946 if (targetState == UNINITIALIZED) { 1947 mComponentName.clear(); 1948 } 1949 (new AMessage)->postReply(replyID); 1950 break; 1951 } 1952 1953 mReplyID = replyID; 1954 setState(msg->what() == kWhatStop ? STOPPING : RELEASING); 1955 1956 mCodec->initiateShutdown( 1957 msg->what() == kWhatStop /* keepComponentAllocated */); 1958 1959 returnBuffersToCodec(reclaimed); 1960 1961 if (mSoftRenderer != NULL && (mFlags & kFlagPushBlankBuffersOnShutdown)) { 1962 pushBlankBuffersToNativeWindow(mSurface.get()); 1963 } 1964 break; 1965 } 1966 1967 case kWhatDequeueInputBuffer: 1968 { 1969 sp<AReplyToken> replyID; 1970 CHECK(msg->senderAwaitsResponse(&replyID)); 1971 1972 if (mFlags & kFlagIsAsync) { 1973 ALOGE("dequeueOutputBuffer can't be used in async mode"); 1974 PostReplyWithError(replyID, INVALID_OPERATION); 1975 break; 1976 } 1977 1978 if (mHaveInputSurface) { 1979 ALOGE("dequeueInputBuffer can't be used with input surface"); 1980 PostReplyWithError(replyID, INVALID_OPERATION); 1981 break; 1982 } 1983 1984 if (handleDequeueInputBuffer(replyID, true /* new request */)) { 1985 break; 1986 } 1987 1988 int64_t timeoutUs; 1989 CHECK(msg->findInt64("timeoutUs", &timeoutUs)); 1990 1991 if (timeoutUs == 0ll) { 1992 PostReplyWithError(replyID, -EAGAIN); 1993 break; 1994 } 1995 1996 mFlags |= kFlagDequeueInputPending; 1997 mDequeueInputReplyID = replyID; 1998 1999 if (timeoutUs > 0ll) { 2000 sp<AMessage> timeoutMsg = 2001 new AMessage(kWhatDequeueInputTimedOut, this); 2002 timeoutMsg->setInt32( 2003 "generation", ++mDequeueInputTimeoutGeneration); 2004 timeoutMsg->post(timeoutUs); 2005 } 2006 break; 2007 } 2008 2009 case kWhatDequeueInputTimedOut: 2010 { 2011 int32_t generation; 2012 CHECK(msg->findInt32("generation", &generation)); 2013 2014 if (generation != mDequeueInputTimeoutGeneration) { 2015 // Obsolete 2016 break; 2017 } 2018 2019 CHECK(mFlags & kFlagDequeueInputPending); 2020 2021 PostReplyWithError(mDequeueInputReplyID, -EAGAIN); 2022 2023 mFlags &= ~kFlagDequeueInputPending; 2024 mDequeueInputReplyID = 0; 2025 break; 2026 } 2027 2028 case kWhatQueueInputBuffer: 2029 { 2030 sp<AReplyToken> replyID; 2031 CHECK(msg->senderAwaitsResponse(&replyID)); 2032 2033 if (!isExecuting()) { 2034 PostReplyWithError(replyID, INVALID_OPERATION); 2035 break; 2036 } else if (mFlags & kFlagStickyError) { 2037 PostReplyWithError(replyID, getStickyError()); 2038 break; 2039 } 2040 2041 status_t err = onQueueInputBuffer(msg); 2042 2043 PostReplyWithError(replyID, err); 2044 break; 2045 } 2046 2047 case kWhatDequeueOutputBuffer: 2048 { 2049 sp<AReplyToken> replyID; 2050 CHECK(msg->senderAwaitsResponse(&replyID)); 2051 2052 if (mFlags & kFlagIsAsync) { 2053 ALOGE("dequeueOutputBuffer can't be used in async mode"); 2054 PostReplyWithError(replyID, INVALID_OPERATION); 2055 break; 2056 } 2057 2058 if (handleDequeueOutputBuffer(replyID, true /* new request */)) { 2059 break; 2060 } 2061 2062 int64_t timeoutUs; 2063 CHECK(msg->findInt64("timeoutUs", &timeoutUs)); 2064 2065 if (timeoutUs == 0ll) { 2066 PostReplyWithError(replyID, -EAGAIN); 2067 break; 2068 } 2069 2070 mFlags |= kFlagDequeueOutputPending; 2071 mDequeueOutputReplyID = replyID; 2072 2073 if (timeoutUs > 0ll) { 2074 sp<AMessage> timeoutMsg = 2075 new AMessage(kWhatDequeueOutputTimedOut, this); 2076 timeoutMsg->setInt32( 2077 "generation", ++mDequeueOutputTimeoutGeneration); 2078 timeoutMsg->post(timeoutUs); 2079 } 2080 break; 2081 } 2082 2083 case kWhatDequeueOutputTimedOut: 2084 { 2085 int32_t generation; 2086 CHECK(msg->findInt32("generation", &generation)); 2087 2088 if (generation != mDequeueOutputTimeoutGeneration) { 2089 // Obsolete 2090 break; 2091 } 2092 2093 CHECK(mFlags & kFlagDequeueOutputPending); 2094 2095 PostReplyWithError(mDequeueOutputReplyID, -EAGAIN); 2096 2097 mFlags &= ~kFlagDequeueOutputPending; 2098 mDequeueOutputReplyID = 0; 2099 break; 2100 } 2101 2102 case kWhatReleaseOutputBuffer: 2103 { 2104 sp<AReplyToken> replyID; 2105 CHECK(msg->senderAwaitsResponse(&replyID)); 2106 2107 if (!isExecuting()) { 2108 PostReplyWithError(replyID, INVALID_OPERATION); 2109 break; 2110 } else if (mFlags & kFlagStickyError) { 2111 PostReplyWithError(replyID, getStickyError()); 2112 break; 2113 } 2114 2115 status_t err = onReleaseOutputBuffer(msg); 2116 2117 PostReplyWithError(replyID, err); 2118 break; 2119 } 2120 2121 case kWhatSignalEndOfInputStream: 2122 { 2123 sp<AReplyToken> replyID; 2124 CHECK(msg->senderAwaitsResponse(&replyID)); 2125 2126 if (!isExecuting()) { 2127 PostReplyWithError(replyID, INVALID_OPERATION); 2128 break; 2129 } else if (mFlags & kFlagStickyError) { 2130 PostReplyWithError(replyID, getStickyError()); 2131 break; 2132 } 2133 2134 mReplyID = replyID; 2135 mCodec->signalEndOfInputStream(); 2136 break; 2137 } 2138 2139 case kWhatGetBuffers: 2140 { 2141 sp<AReplyToken> replyID; 2142 CHECK(msg->senderAwaitsResponse(&replyID)); 2143 // Unfortunately widevine legacy source requires knowing all of the 2144 // codec input buffers, so we have to provide them even in async mode. 2145 int32_t widevine = 0; 2146 msg->findInt32("widevine", &widevine); 2147 2148 if (!isExecuting() || ((mFlags & kFlagIsAsync) && !widevine)) { 2149 PostReplyWithError(replyID, INVALID_OPERATION); 2150 break; 2151 } else if (mFlags & kFlagStickyError) { 2152 PostReplyWithError(replyID, getStickyError()); 2153 break; 2154 } 2155 2156 int32_t portIndex; 2157 CHECK(msg->findInt32("portIndex", &portIndex)); 2158 2159 Vector<sp<ABuffer> > *dstBuffers; 2160 CHECK(msg->findPointer("buffers", (void **)&dstBuffers)); 2161 2162 dstBuffers->clear(); 2163 const Vector<BufferInfo> &srcBuffers = mPortBuffers[portIndex]; 2164 2165 for (size_t i = 0; i < srcBuffers.size(); ++i) { 2166 const BufferInfo &info = srcBuffers.itemAt(i); 2167 2168 dstBuffers->push_back( 2169 (portIndex == kPortIndexInput && mCrypto != NULL) 2170 ? info.mEncryptedData : info.mData); 2171 } 2172 2173 (new AMessage)->postReply(replyID); 2174 break; 2175 } 2176 2177 case kWhatFlush: 2178 { 2179 sp<AReplyToken> replyID; 2180 CHECK(msg->senderAwaitsResponse(&replyID)); 2181 2182 if (!isExecuting()) { 2183 PostReplyWithError(replyID, INVALID_OPERATION); 2184 break; 2185 } else if (mFlags & kFlagStickyError) { 2186 PostReplyWithError(replyID, getStickyError()); 2187 break; 2188 } 2189 2190 mReplyID = replyID; 2191 // TODO: skip flushing if already FLUSHED 2192 setState(FLUSHING); 2193 2194 mCodec->signalFlush(); 2195 returnBuffersToCodec(); 2196 break; 2197 } 2198 2199 case kWhatGetInputFormat: 2200 case kWhatGetOutputFormat: 2201 { 2202 sp<AMessage> format = 2203 (msg->what() == kWhatGetOutputFormat ? mOutputFormat : mInputFormat); 2204 2205 sp<AReplyToken> replyID; 2206 CHECK(msg->senderAwaitsResponse(&replyID)); 2207 2208 if ((mState != CONFIGURED && mState != STARTING && 2209 mState != STARTED && mState != FLUSHING && 2210 mState != FLUSHED) 2211 || format == NULL) { 2212 PostReplyWithError(replyID, INVALID_OPERATION); 2213 break; 2214 } else if (mFlags & kFlagStickyError) { 2215 PostReplyWithError(replyID, getStickyError()); 2216 break; 2217 } 2218 2219 sp<AMessage> response = new AMessage; 2220 response->setMessage("format", format); 2221 response->postReply(replyID); 2222 break; 2223 } 2224 2225 case kWhatRequestIDRFrame: 2226 { 2227 mCodec->signalRequestIDRFrame(); 2228 break; 2229 } 2230 2231 case kWhatRequestActivityNotification: 2232 { 2233 CHECK(mActivityNotify == NULL); 2234 CHECK(msg->findMessage("notify", &mActivityNotify)); 2235 2236 postActivityNotificationIfPossible(); 2237 break; 2238 } 2239 2240 case kWhatGetName: 2241 { 2242 sp<AReplyToken> replyID; 2243 CHECK(msg->senderAwaitsResponse(&replyID)); 2244 2245 if (mComponentName.empty()) { 2246 PostReplyWithError(replyID, INVALID_OPERATION); 2247 break; 2248 } 2249 2250 sp<AMessage> response = new AMessage; 2251 response->setString("name", mComponentName.c_str()); 2252 response->postReply(replyID); 2253 break; 2254 } 2255 2256 case kWhatSetParameters: 2257 { 2258 sp<AReplyToken> replyID; 2259 CHECK(msg->senderAwaitsResponse(&replyID)); 2260 2261 sp<AMessage> params; 2262 CHECK(msg->findMessage("params", ¶ms)); 2263 2264 status_t err = onSetParameters(params); 2265 2266 PostReplyWithError(replyID, err); 2267 break; 2268 } 2269 2270 default: 2271 TRESPASS(); 2272 } 2273} 2274 2275void MediaCodec::extractCSD(const sp<AMessage> &format) { 2276 mCSD.clear(); 2277 2278 size_t i = 0; 2279 for (;;) { 2280 sp<ABuffer> csd; 2281 if (!format->findBuffer(AStringPrintf("csd-%u", i).c_str(), &csd)) { 2282 break; 2283 } 2284 if (csd->size() == 0) { 2285 ALOGW("csd-%zu size is 0", i); 2286 } 2287 2288 mCSD.push_back(csd); 2289 ++i; 2290 } 2291 2292 ALOGV("Found %zu pieces of codec specific data.", mCSD.size()); 2293} 2294 2295status_t MediaCodec::queueCSDInputBuffer(size_t bufferIndex) { 2296 CHECK(!mCSD.empty()); 2297 2298 const BufferInfo *info = 2299 &mPortBuffers[kPortIndexInput].itemAt(bufferIndex); 2300 2301 sp<ABuffer> csd = *mCSD.begin(); 2302 mCSD.erase(mCSD.begin()); 2303 2304 const sp<ABuffer> &codecInputData = 2305 (mCrypto != NULL) ? info->mEncryptedData : info->mData; 2306 2307 if (csd->size() > codecInputData->capacity()) { 2308 return -EINVAL; 2309 } 2310 2311 memcpy(codecInputData->data(), csd->data(), csd->size()); 2312 2313 AString errorDetailMsg; 2314 2315 sp<AMessage> msg = new AMessage(kWhatQueueInputBuffer, this); 2316 msg->setSize("index", bufferIndex); 2317 msg->setSize("offset", 0); 2318 msg->setSize("size", csd->size()); 2319 msg->setInt64("timeUs", 0ll); 2320 msg->setInt32("flags", BUFFER_FLAG_CODECCONFIG); 2321 msg->setPointer("errorDetailMsg", &errorDetailMsg); 2322 2323 return onQueueInputBuffer(msg); 2324} 2325 2326void MediaCodec::setState(State newState) { 2327 if (newState == INITIALIZED || newState == UNINITIALIZED) { 2328 delete mSoftRenderer; 2329 mSoftRenderer = NULL; 2330 2331 mCrypto.clear(); 2332 handleSetSurface(NULL); 2333 2334 mInputFormat.clear(); 2335 mOutputFormat.clear(); 2336 mFlags &= ~kFlagOutputFormatChanged; 2337 mFlags &= ~kFlagOutputBuffersChanged; 2338 mFlags &= ~kFlagStickyError; 2339 mFlags &= ~kFlagIsEncoder; 2340 mFlags &= ~kFlagGatherCodecSpecificData; 2341 mFlags &= ~kFlagIsAsync; 2342 mStickyError = OK; 2343 2344 mActivityNotify.clear(); 2345 mCallback.clear(); 2346 } 2347 2348 if (newState == UNINITIALIZED) { 2349 // return any straggling buffers, e.g. if we got here on an error 2350 returnBuffersToCodec(); 2351 2352 // The component is gone, mediaserver's probably back up already 2353 // but should definitely be back up should we try to instantiate 2354 // another component.. and the cycle continues. 2355 mFlags &= ~kFlagSawMediaServerDie; 2356 } 2357 2358 mState = newState; 2359 2360 cancelPendingDequeueOperations(); 2361 2362 updateBatteryStat(); 2363} 2364 2365void MediaCodec::returnBuffersToCodec(bool isReclaim) { 2366 returnBuffersToCodecOnPort(kPortIndexInput, isReclaim); 2367 returnBuffersToCodecOnPort(kPortIndexOutput, isReclaim); 2368} 2369 2370void MediaCodec::returnBuffersToCodecOnPort(int32_t portIndex, bool isReclaim) { 2371 CHECK(portIndex == kPortIndexInput || portIndex == kPortIndexOutput); 2372 Mutex::Autolock al(mBufferLock); 2373 2374 Vector<BufferInfo> *buffers = &mPortBuffers[portIndex]; 2375 2376 for (size_t i = 0; i < buffers->size(); ++i) { 2377 BufferInfo *info = &buffers->editItemAt(i); 2378 2379 if (info->mNotify != NULL) { 2380 sp<AMessage> msg = info->mNotify; 2381 info->mNotify = NULL; 2382 if (isReclaim && info->mOwnedByClient) { 2383 ALOGD("port %d buffer %zu still owned by client when codec is reclaimed", 2384 portIndex, i); 2385 } else { 2386 info->mMemRef = NULL; 2387 info->mOwnedByClient = false; 2388 } 2389 2390 if (portIndex == kPortIndexInput) { 2391 /* no error, just returning buffers */ 2392 msg->setInt32("err", OK); 2393 } 2394 msg->post(); 2395 } 2396 } 2397 2398 mAvailPortBuffers[portIndex].clear(); 2399} 2400 2401size_t MediaCodec::updateBuffers( 2402 int32_t portIndex, const sp<AMessage> &msg) { 2403 CHECK(portIndex == kPortIndexInput || portIndex == kPortIndexOutput); 2404 2405 uint32_t bufferID; 2406 CHECK(msg->findInt32("buffer-id", (int32_t*)&bufferID)); 2407 2408 Vector<BufferInfo> *buffers = &mPortBuffers[portIndex]; 2409 2410 for (size_t i = 0; i < buffers->size(); ++i) { 2411 BufferInfo *info = &buffers->editItemAt(i); 2412 2413 if (info->mBufferID == bufferID) { 2414 CHECK(info->mNotify == NULL); 2415 CHECK(msg->findMessage("reply", &info->mNotify)); 2416 2417 info->mFormat = 2418 (portIndex == kPortIndexInput) ? mInputFormat : mOutputFormat; 2419 mAvailPortBuffers[portIndex].push_back(i); 2420 2421 return i; 2422 } 2423 } 2424 2425 TRESPASS(); 2426 2427 return 0; 2428} 2429 2430status_t MediaCodec::onQueueInputBuffer(const sp<AMessage> &msg) { 2431 size_t index; 2432 size_t offset; 2433 size_t size; 2434 int64_t timeUs; 2435 uint32_t flags; 2436 CHECK(msg->findSize("index", &index)); 2437 CHECK(msg->findSize("offset", &offset)); 2438 CHECK(msg->findInt64("timeUs", &timeUs)); 2439 CHECK(msg->findInt32("flags", (int32_t *)&flags)); 2440 2441 const CryptoPlugin::SubSample *subSamples; 2442 size_t numSubSamples; 2443 const uint8_t *key; 2444 const uint8_t *iv; 2445 CryptoPlugin::Mode mode = CryptoPlugin::kMode_Unencrypted; 2446 2447 // We allow the simpler queueInputBuffer API to be used even in 2448 // secure mode, by fabricating a single unencrypted subSample. 2449 CryptoPlugin::SubSample ss; 2450 CryptoPlugin::Pattern pattern; 2451 2452 if (msg->findSize("size", &size)) { 2453 if (mCrypto != NULL) { 2454 ss.mNumBytesOfClearData = size; 2455 ss.mNumBytesOfEncryptedData = 0; 2456 2457 subSamples = &ss; 2458 numSubSamples = 1; 2459 key = NULL; 2460 iv = NULL; 2461 pattern.mEncryptBlocks = 0; 2462 pattern.mSkipBlocks = 0; 2463 } 2464 } else { 2465 if (mCrypto == NULL) { 2466 return -EINVAL; 2467 } 2468 2469 CHECK(msg->findPointer("subSamples", (void **)&subSamples)); 2470 CHECK(msg->findSize("numSubSamples", &numSubSamples)); 2471 CHECK(msg->findPointer("key", (void **)&key)); 2472 CHECK(msg->findPointer("iv", (void **)&iv)); 2473 CHECK(msg->findInt32("encryptBlocks", (int32_t *)&pattern.mEncryptBlocks)); 2474 CHECK(msg->findInt32("skipBlocks", (int32_t *)&pattern.mSkipBlocks)); 2475 2476 int32_t tmp; 2477 CHECK(msg->findInt32("mode", &tmp)); 2478 2479 mode = (CryptoPlugin::Mode)tmp; 2480 2481 size = 0; 2482 for (size_t i = 0; i < numSubSamples; ++i) { 2483 size += subSamples[i].mNumBytesOfClearData; 2484 size += subSamples[i].mNumBytesOfEncryptedData; 2485 } 2486 } 2487 2488 if (index >= mPortBuffers[kPortIndexInput].size()) { 2489 return -ERANGE; 2490 } 2491 2492 BufferInfo *info = &mPortBuffers[kPortIndexInput].editItemAt(index); 2493 2494 if (info->mNotify == NULL || !info->mOwnedByClient) { 2495 return -EACCES; 2496 } 2497 2498 if (offset + size > info->mData->capacity()) { 2499 return -EINVAL; 2500 } 2501 2502 sp<AMessage> reply = info->mNotify; 2503 info->mData->setRange(offset, size); 2504 info->mData->meta()->setInt64("timeUs", timeUs); 2505 2506 if (flags & BUFFER_FLAG_EOS) { 2507 info->mData->meta()->setInt32("eos", true); 2508 } 2509 2510 if (flags & BUFFER_FLAG_CODECCONFIG) { 2511 info->mData->meta()->setInt32("csd", true); 2512 } 2513 2514 if (mCrypto != NULL) { 2515 if (size > info->mEncryptedData->capacity()) { 2516 return -ERANGE; 2517 } 2518 2519 AString *errorDetailMsg; 2520 CHECK(msg->findPointer("errorDetailMsg", (void **)&errorDetailMsg)); 2521 2522 void *dst_pointer = info->mData->base(); 2523 ICrypto::DestinationType dst_type = ICrypto::kDestinationTypeOpaqueHandle; 2524 2525 if (info->mNativeHandle != NULL) { 2526 dst_pointer = (void *)info->mNativeHandle->handle(); 2527 dst_type = ICrypto::kDestinationTypeNativeHandle; 2528 } else if ((mFlags & kFlagIsSecure) == 0) { 2529 dst_type = ICrypto::kDestinationTypeVmPointer; 2530 } 2531 2532 ssize_t result = mCrypto->decrypt( 2533 dst_type, 2534 key, 2535 iv, 2536 mode, 2537 pattern, 2538 info->mSharedEncryptedBuffer, 2539 offset, 2540 subSamples, 2541 numSubSamples, 2542 dst_pointer, 2543 errorDetailMsg); 2544 2545 if (result < 0) { 2546 return result; 2547 } 2548 2549 info->mData->setRange(0, result); 2550 } 2551 2552 // synchronization boundary for getBufferAndFormat 2553 { 2554 Mutex::Autolock al(mBufferLock); 2555 info->mOwnedByClient = false; 2556 } 2557 reply->setBuffer("buffer", info->mData); 2558 reply->post(); 2559 2560 info->mNotify = NULL; 2561 2562 return OK; 2563} 2564 2565//static 2566size_t MediaCodec::CreateFramesRenderedMessage( 2567 const std::list<FrameRenderTracker::Info> &done, sp<AMessage> &msg) { 2568 size_t index = 0; 2569 2570 for (std::list<FrameRenderTracker::Info>::const_iterator it = done.cbegin(); 2571 it != done.cend(); ++it) { 2572 if (it->getRenderTimeNs() < 0) { 2573 continue; // dropped frame from tracking 2574 } 2575 msg->setInt64(AStringPrintf("%zu-media-time-us", index).c_str(), it->getMediaTimeUs()); 2576 msg->setInt64(AStringPrintf("%zu-system-nano", index).c_str(), it->getRenderTimeNs()); 2577 ++index; 2578 } 2579 return index; 2580} 2581 2582status_t MediaCodec::onReleaseOutputBuffer(const sp<AMessage> &msg) { 2583 size_t index; 2584 CHECK(msg->findSize("index", &index)); 2585 2586 int32_t render; 2587 if (!msg->findInt32("render", &render)) { 2588 render = 0; 2589 } 2590 2591 if (!isExecuting()) { 2592 return -EINVAL; 2593 } 2594 2595 if (index >= mPortBuffers[kPortIndexOutput].size()) { 2596 return -ERANGE; 2597 } 2598 2599 BufferInfo *info = &mPortBuffers[kPortIndexOutput].editItemAt(index); 2600 2601 if (info->mNotify == NULL || !info->mOwnedByClient) { 2602 return -EACCES; 2603 } 2604 2605 // synchronization boundary for getBufferAndFormat 2606 { 2607 Mutex::Autolock al(mBufferLock); 2608 info->mOwnedByClient = false; 2609 } 2610 2611 if (render && info->mData != NULL && info->mData->size() != 0) { 2612 info->mNotify->setInt32("render", true); 2613 2614 int64_t mediaTimeUs = -1; 2615 info->mData->meta()->findInt64("timeUs", &mediaTimeUs); 2616 2617 int64_t renderTimeNs = 0; 2618 if (!msg->findInt64("timestampNs", &renderTimeNs)) { 2619 // use media timestamp if client did not request a specific render timestamp 2620 ALOGV("using buffer PTS of %lld", (long long)mediaTimeUs); 2621 renderTimeNs = mediaTimeUs * 1000; 2622 } 2623 info->mNotify->setInt64("timestampNs", renderTimeNs); 2624 2625 if (mSoftRenderer != NULL) { 2626 std::list<FrameRenderTracker::Info> doneFrames = mSoftRenderer->render( 2627 info->mData->data(), info->mData->size(), 2628 mediaTimeUs, renderTimeNs, NULL, info->mFormat); 2629 2630 // if we are running, notify rendered frames 2631 if (!doneFrames.empty() && mState == STARTED && mOnFrameRenderedNotification != NULL) { 2632 sp<AMessage> notify = mOnFrameRenderedNotification->dup(); 2633 sp<AMessage> data = new AMessage; 2634 if (CreateFramesRenderedMessage(doneFrames, data)) { 2635 notify->setMessage("data", data); 2636 notify->post(); 2637 } 2638 } 2639 } 2640 } 2641 2642 info->mNotify->post(); 2643 info->mNotify = NULL; 2644 2645 return OK; 2646} 2647 2648ssize_t MediaCodec::dequeuePortBuffer(int32_t portIndex) { 2649 CHECK(portIndex == kPortIndexInput || portIndex == kPortIndexOutput); 2650 2651 List<size_t> *availBuffers = &mAvailPortBuffers[portIndex]; 2652 2653 if (availBuffers->empty()) { 2654 return -EAGAIN; 2655 } 2656 2657 size_t index = *availBuffers->begin(); 2658 availBuffers->erase(availBuffers->begin()); 2659 2660 BufferInfo *info = &mPortBuffers[portIndex].editItemAt(index); 2661 CHECK(!info->mOwnedByClient); 2662 { 2663 Mutex::Autolock al(mBufferLock); 2664 info->mOwnedByClient = true; 2665 2666 // set image-data 2667 if (info->mFormat != NULL) { 2668 sp<ABuffer> imageData; 2669 if (info->mFormat->findBuffer("image-data", &imageData)) { 2670 info->mData->meta()->setBuffer("image-data", imageData); 2671 } 2672 int32_t left, top, right, bottom; 2673 if (info->mFormat->findRect("crop", &left, &top, &right, &bottom)) { 2674 info->mData->meta()->setRect("crop-rect", left, top, right, bottom); 2675 } 2676 } 2677 } 2678 2679 return index; 2680} 2681 2682status_t MediaCodec::connectToSurface(const sp<Surface> &surface) { 2683 status_t err = OK; 2684 if (surface != NULL) { 2685 uint64_t oldId, newId; 2686 if (mSurface != NULL 2687 && surface->getUniqueId(&newId) == NO_ERROR 2688 && mSurface->getUniqueId(&oldId) == NO_ERROR 2689 && newId == oldId) { 2690 ALOGI("[%s] connecting to the same surface. Nothing to do.", mComponentName.c_str()); 2691 return ALREADY_EXISTS; 2692 } 2693 2694 err = native_window_api_connect(surface.get(), NATIVE_WINDOW_API_MEDIA); 2695 if (err == OK) { 2696 // Require a fresh set of buffers after each connect by using a unique generation 2697 // number. Rely on the fact that max supported process id by Linux is 2^22. 2698 // PID is never 0 so we don't have to worry that we use the default generation of 0. 2699 // TODO: come up with a unique scheme if other producers also set the generation number. 2700 static uint32_t mSurfaceGeneration = 0; 2701 uint32_t generation = (getpid() << 10) | (++mSurfaceGeneration & ((1 << 10) - 1)); 2702 surface->setGenerationNumber(generation); 2703 ALOGI("[%s] setting surface generation to %u", mComponentName.c_str(), generation); 2704 2705 // HACK: clear any free buffers. Remove when connect will automatically do this. 2706 // This is needed as the consumer may be holding onto stale frames that it can reattach 2707 // to this surface after disconnect/connect, and those free frames would inherit the new 2708 // generation number. Disconnecting after setting a unique generation prevents this. 2709 native_window_api_disconnect(surface.get(), NATIVE_WINDOW_API_MEDIA); 2710 err = native_window_api_connect(surface.get(), NATIVE_WINDOW_API_MEDIA); 2711 } 2712 2713 if (err != OK) { 2714 ALOGE("native_window_api_connect returned an error: %s (%d)", strerror(-err), err); 2715 } 2716 } 2717 // do not return ALREADY_EXISTS unless surfaces are the same 2718 return err == ALREADY_EXISTS ? BAD_VALUE : err; 2719} 2720 2721status_t MediaCodec::disconnectFromSurface() { 2722 status_t err = OK; 2723 if (mSurface != NULL) { 2724 // Resetting generation is not technically needed, but there is no need to keep it either 2725 mSurface->setGenerationNumber(0); 2726 err = native_window_api_disconnect(mSurface.get(), NATIVE_WINDOW_API_MEDIA); 2727 if (err != OK) { 2728 ALOGW("native_window_api_disconnect returned an error: %s (%d)", strerror(-err), err); 2729 } 2730 // assume disconnected even on error 2731 mSurface.clear(); 2732 } 2733 return err; 2734} 2735 2736status_t MediaCodec::handleSetSurface(const sp<Surface> &surface) { 2737 status_t err = OK; 2738 if (mSurface != NULL) { 2739 (void)disconnectFromSurface(); 2740 } 2741 if (surface != NULL) { 2742 err = connectToSurface(surface); 2743 if (err == OK) { 2744 mSurface = surface; 2745 } 2746 } 2747 return err; 2748} 2749 2750void MediaCodec::onInputBufferAvailable() { 2751 int32_t index; 2752 while ((index = dequeuePortBuffer(kPortIndexInput)) >= 0) { 2753 sp<AMessage> msg = mCallback->dup(); 2754 msg->setInt32("callbackID", CB_INPUT_AVAILABLE); 2755 msg->setInt32("index", index); 2756 msg->post(); 2757 } 2758} 2759 2760void MediaCodec::onOutputBufferAvailable() { 2761 int32_t index; 2762 while ((index = dequeuePortBuffer(kPortIndexOutput)) >= 0) { 2763 const sp<ABuffer> &buffer = 2764 mPortBuffers[kPortIndexOutput].itemAt(index).mData; 2765 sp<AMessage> msg = mCallback->dup(); 2766 msg->setInt32("callbackID", CB_OUTPUT_AVAILABLE); 2767 msg->setInt32("index", index); 2768 msg->setSize("offset", buffer->offset()); 2769 msg->setSize("size", buffer->size()); 2770 2771 int64_t timeUs; 2772 CHECK(buffer->meta()->findInt64("timeUs", &timeUs)); 2773 2774 msg->setInt64("timeUs", timeUs); 2775 2776 int32_t omxFlags; 2777 CHECK(buffer->meta()->findInt32("omxFlags", &omxFlags)); 2778 2779 uint32_t flags = 0; 2780 if (omxFlags & OMX_BUFFERFLAG_SYNCFRAME) { 2781 flags |= BUFFER_FLAG_SYNCFRAME; 2782 } 2783 if (omxFlags & OMX_BUFFERFLAG_CODECCONFIG) { 2784 flags |= BUFFER_FLAG_CODECCONFIG; 2785 } 2786 if (omxFlags & OMX_BUFFERFLAG_EOS) { 2787 flags |= BUFFER_FLAG_EOS; 2788 } 2789 2790 msg->setInt32("flags", flags); 2791 2792 msg->post(); 2793 } 2794} 2795 2796void MediaCodec::onError(status_t err, int32_t actionCode, const char *detail) { 2797 if (mCallback != NULL) { 2798 sp<AMessage> msg = mCallback->dup(); 2799 msg->setInt32("callbackID", CB_ERROR); 2800 msg->setInt32("err", err); 2801 msg->setInt32("actionCode", actionCode); 2802 2803 if (detail != NULL) { 2804 msg->setString("detail", detail); 2805 } 2806 2807 msg->post(); 2808 } 2809} 2810 2811void MediaCodec::onOutputFormatChanged() { 2812 if (mCallback != NULL) { 2813 sp<AMessage> msg = mCallback->dup(); 2814 msg->setInt32("callbackID", CB_OUTPUT_FORMAT_CHANGED); 2815 msg->setMessage("format", mOutputFormat); 2816 msg->post(); 2817 } 2818} 2819 2820 2821void MediaCodec::postActivityNotificationIfPossible() { 2822 if (mActivityNotify == NULL) { 2823 return; 2824 } 2825 2826 bool isErrorOrOutputChanged = 2827 (mFlags & (kFlagStickyError 2828 | kFlagOutputBuffersChanged 2829 | kFlagOutputFormatChanged)); 2830 2831 if (isErrorOrOutputChanged 2832 || !mAvailPortBuffers[kPortIndexInput].empty() 2833 || !mAvailPortBuffers[kPortIndexOutput].empty()) { 2834 mActivityNotify->setInt32("input-buffers", 2835 mAvailPortBuffers[kPortIndexInput].size()); 2836 2837 if (isErrorOrOutputChanged) { 2838 // we want consumer to dequeue as many times as it can 2839 mActivityNotify->setInt32("output-buffers", INT32_MAX); 2840 } else { 2841 mActivityNotify->setInt32("output-buffers", 2842 mAvailPortBuffers[kPortIndexOutput].size()); 2843 } 2844 mActivityNotify->post(); 2845 mActivityNotify.clear(); 2846 } 2847} 2848 2849status_t MediaCodec::setParameters(const sp<AMessage> ¶ms) { 2850 sp<AMessage> msg = new AMessage(kWhatSetParameters, this); 2851 msg->setMessage("params", params); 2852 2853 sp<AMessage> response; 2854 return PostAndAwaitResponse(msg, &response); 2855} 2856 2857status_t MediaCodec::onSetParameters(const sp<AMessage> ¶ms) { 2858 mCodec->signalSetParameters(params); 2859 2860 return OK; 2861} 2862 2863status_t MediaCodec::amendOutputFormatWithCodecSpecificData( 2864 const sp<ABuffer> &buffer) { 2865 AString mime; 2866 CHECK(mOutputFormat->findString("mime", &mime)); 2867 2868 if (!strcasecmp(mime.c_str(), MEDIA_MIMETYPE_VIDEO_AVC)) { 2869 // Codec specific data should be SPS and PPS in a single buffer, 2870 // each prefixed by a startcode (0x00 0x00 0x00 0x01). 2871 // We separate the two and put them into the output format 2872 // under the keys "csd-0" and "csd-1". 2873 2874 unsigned csdIndex = 0; 2875 2876 const uint8_t *data = buffer->data(); 2877 size_t size = buffer->size(); 2878 2879 const uint8_t *nalStart; 2880 size_t nalSize; 2881 while (getNextNALUnit(&data, &size, &nalStart, &nalSize, true) == OK) { 2882 sp<ABuffer> csd = new ABuffer(nalSize + 4); 2883 memcpy(csd->data(), "\x00\x00\x00\x01", 4); 2884 memcpy(csd->data() + 4, nalStart, nalSize); 2885 2886 mOutputFormat->setBuffer( 2887 AStringPrintf("csd-%u", csdIndex).c_str(), csd); 2888 2889 ++csdIndex; 2890 } 2891 2892 if (csdIndex != 2) { 2893 return ERROR_MALFORMED; 2894 } 2895 } else { 2896 // For everything else we just stash the codec specific data into 2897 // the output format as a single piece of csd under "csd-0". 2898 mOutputFormat->setBuffer("csd-0", buffer); 2899 } 2900 2901 return OK; 2902} 2903 2904void MediaCodec::updateBatteryStat() { 2905 if (!mIsVideo) { 2906 return; 2907 } 2908 2909 if (mState == CONFIGURED && !mBatteryStatNotified) { 2910 BatteryNotifier::getInstance().noteStartVideo(); 2911 mBatteryStatNotified = true; 2912 } else if (mState == UNINITIALIZED && mBatteryStatNotified) { 2913 BatteryNotifier::getInstance().noteStopVideo(); 2914 mBatteryStatNotified = false; 2915 } 2916} 2917 2918} // namespace android 2919