MediaCodec.cpp revision 33223c4f97abb78fa8c92e1b8c817546f15d97e1
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/IBatteryStats.h> 25#include <binder/IServiceManager.h> 26#include <gui/Surface.h> 27#include <media/ICrypto.h> 28#include <media/stagefright/foundation/ABuffer.h> 29#include <media/stagefright/foundation/ADebug.h> 30#include <media/stagefright/foundation/AMessage.h> 31#include <media/stagefright/foundation/AString.h> 32#include <media/stagefright/foundation/hexdump.h> 33#include <media/stagefright/ACodec.h> 34#include <media/stagefright/BufferProducerWrapper.h> 35#include <media/stagefright/MediaCodec.h> 36#include <media/stagefright/MediaCodecList.h> 37#include <media/stagefright/MediaDefs.h> 38#include <media/stagefright/MediaErrors.h> 39#include <media/stagefright/MetaData.h> 40#include <media/stagefright/NativeWindowWrapper.h> 41#include <private/android_filesystem_config.h> 42#include <utils/Log.h> 43#include <utils/Singleton.h> 44 45namespace android { 46 47struct MediaCodec::BatteryNotifier : public Singleton<BatteryNotifier> { 48 BatteryNotifier(); 49 50 void noteStartVideo(); 51 void noteStopVideo(); 52 void noteStartAudio(); 53 void noteStopAudio(); 54 55private: 56 int32_t mVideoRefCount; 57 int32_t mAudioRefCount; 58 sp<IBatteryStats> mBatteryStatService; 59}; 60 61ANDROID_SINGLETON_STATIC_INSTANCE(MediaCodec::BatteryNotifier) 62 63MediaCodec::BatteryNotifier::BatteryNotifier() : 64 mVideoRefCount(0), 65 mAudioRefCount(0) { 66 // get battery service 67 const sp<IServiceManager> sm(defaultServiceManager()); 68 if (sm != NULL) { 69 const String16 name("batterystats"); 70 mBatteryStatService = interface_cast<IBatteryStats>(sm->getService(name)); 71 if (mBatteryStatService == NULL) { 72 ALOGE("batterystats service unavailable!"); 73 } 74 } 75} 76 77void MediaCodec::BatteryNotifier::noteStartVideo() { 78 if (mVideoRefCount == 0 && mBatteryStatService != NULL) { 79 mBatteryStatService->noteStartVideo(AID_MEDIA); 80 } 81 mVideoRefCount++; 82} 83 84void MediaCodec::BatteryNotifier::noteStopVideo() { 85 if (mVideoRefCount == 0) { 86 ALOGW("BatteryNotifier::noteStop(): video refcount is broken!"); 87 return; 88 } 89 90 mVideoRefCount--; 91 if (mVideoRefCount == 0 && mBatteryStatService != NULL) { 92 mBatteryStatService->noteStopVideo(AID_MEDIA); 93 } 94} 95 96void MediaCodec::BatteryNotifier::noteStartAudio() { 97 if (mAudioRefCount == 0 && mBatteryStatService != NULL) { 98 mBatteryStatService->noteStartAudio(AID_MEDIA); 99 } 100 mAudioRefCount++; 101} 102 103void MediaCodec::BatteryNotifier::noteStopAudio() { 104 if (mAudioRefCount == 0) { 105 ALOGW("BatteryNotifier::noteStop(): audio refcount is broken!"); 106 return; 107 } 108 109 mAudioRefCount--; 110 if (mAudioRefCount == 0 && mBatteryStatService != NULL) { 111 mBatteryStatService->noteStopAudio(AID_MEDIA); 112 } 113} 114// static 115sp<MediaCodec> MediaCodec::CreateByType( 116 const sp<ALooper> &looper, const char *mime, bool encoder, status_t *err) { 117 sp<MediaCodec> codec = new MediaCodec(looper); 118 119 const status_t ret = codec->init(mime, true /* nameIsType */, encoder); 120 if (err != NULL) { 121 *err = ret; 122 } 123 return ret == OK ? codec : NULL; // NULL deallocates codec. 124} 125 126// static 127sp<MediaCodec> MediaCodec::CreateByComponentName( 128 const sp<ALooper> &looper, const char *name, status_t *err) { 129 sp<MediaCodec> codec = new MediaCodec(looper); 130 131 const status_t ret = codec->init(name, false /* nameIsType */, false /* encoder */); 132 if (err != NULL) { 133 *err = ret; 134 } 135 return ret == OK ? codec : NULL; // NULL deallocates codec. 136} 137 138MediaCodec::MediaCodec(const sp<ALooper> &looper) 139 : mState(UNINITIALIZED), 140 mLooper(looper), 141 mCodec(NULL), 142 mReplyID(0), 143 mFlags(0), 144 mStickyError(OK), 145 mSoftRenderer(NULL), 146 mBatteryStatNotified(false), 147 mIsVideo(false), 148 mDequeueInputTimeoutGeneration(0), 149 mDequeueInputReplyID(0), 150 mDequeueOutputTimeoutGeneration(0), 151 mDequeueOutputReplyID(0), 152 mHaveInputSurface(false) { 153} 154 155MediaCodec::~MediaCodec() { 156 CHECK_EQ(mState, UNINITIALIZED); 157} 158 159// static 160status_t MediaCodec::PostAndAwaitResponse( 161 const sp<AMessage> &msg, sp<AMessage> *response) { 162 status_t err = msg->postAndAwaitResponse(response); 163 164 if (err != OK) { 165 return err; 166 } 167 168 if (!(*response)->findInt32("err", &err)) { 169 err = OK; 170 } 171 172 return err; 173} 174 175// static 176void MediaCodec::PostReplyWithError(int32_t replyID, int32_t err) { 177 sp<AMessage> response = new AMessage; 178 response->setInt32("err", err); 179 response->postReply(replyID); 180} 181 182status_t MediaCodec::init(const AString &name, bool nameIsType, bool encoder) { 183 // save init parameters for reset 184 mInitName = name; 185 mInitNameIsType = nameIsType; 186 mInitIsEncoder = encoder; 187 188 // Current video decoders do not return from OMX_FillThisBuffer 189 // quickly, violating the OpenMAX specs, until that is remedied 190 // we need to invest in an extra looper to free the main event 191 // queue. 192 mCodec = new ACodec; 193 bool needDedicatedLooper = false; 194 if (nameIsType && !strncasecmp(name.c_str(), "video/", 6)) { 195 needDedicatedLooper = true; 196 } else { 197 AString tmp = name; 198 if (tmp.endsWith(".secure")) { 199 tmp.erase(tmp.size() - 7, 7); 200 } 201 const sp<IMediaCodecList> mcl = MediaCodecList::getInstance(); 202 ssize_t codecIdx = mcl->findCodecByName(tmp.c_str()); 203 if (codecIdx >= 0) { 204 const sp<MediaCodecInfo> info = mcl->getCodecInfo(codecIdx); 205 Vector<AString> mimes; 206 info->getSupportedMimes(&mimes); 207 for (size_t i = 0; i < mimes.size(); i++) { 208 if (mimes[i].startsWith("video/")) { 209 needDedicatedLooper = true; 210 break; 211 } 212 } 213 } 214 } 215 216 if (needDedicatedLooper) { 217 if (mCodecLooper == NULL) { 218 mCodecLooper = new ALooper; 219 mCodecLooper->setName("CodecLooper"); 220 mCodecLooper->start(false, false, ANDROID_PRIORITY_AUDIO); 221 } 222 223 mCodecLooper->registerHandler(mCodec); 224 } else { 225 mLooper->registerHandler(mCodec); 226 } 227 228 mLooper->registerHandler(this); 229 230 mCodec->setNotificationMessage(new AMessage(kWhatCodecNotify, id())); 231 232 sp<AMessage> msg = new AMessage(kWhatInit, id()); 233 msg->setString("name", name); 234 msg->setInt32("nameIsType", nameIsType); 235 236 if (nameIsType) { 237 msg->setInt32("encoder", encoder); 238 } 239 240 sp<AMessage> response; 241 return PostAndAwaitResponse(msg, &response); 242} 243 244status_t MediaCodec::setCallback(const sp<AMessage> &callback) { 245 sp<AMessage> msg = new AMessage(kWhatSetCallback, id()); 246 msg->setMessage("callback", callback); 247 248 sp<AMessage> response; 249 return PostAndAwaitResponse(msg, &response); 250} 251 252status_t MediaCodec::configure( 253 const sp<AMessage> &format, 254 const sp<Surface> &nativeWindow, 255 const sp<ICrypto> &crypto, 256 uint32_t flags) { 257 sp<AMessage> msg = new AMessage(kWhatConfigure, id()); 258 259 msg->setMessage("format", format); 260 msg->setInt32("flags", flags); 261 262 if (nativeWindow != NULL) { 263 msg->setObject( 264 "native-window", 265 new NativeWindowWrapper(nativeWindow)); 266 } 267 268 if (crypto != NULL) { 269 msg->setPointer("crypto", crypto.get()); 270 } 271 272 sp<AMessage> response; 273 status_t err = PostAndAwaitResponse(msg, &response); 274 275 if (err != OK && err != INVALID_OPERATION) { 276 // MediaCodec now set state to UNINITIALIZED upon any fatal error. 277 // To maintain backward-compatibility, do a reset() to put codec 278 // back into INITIALIZED state. 279 // But don't reset if the err is INVALID_OPERATION, which means 280 // the configure failure is due to wrong state. 281 282 ALOGE("configure failed with err 0x%08x, resetting...", err); 283 reset(); 284 } 285 286 return err; 287} 288 289status_t MediaCodec::createInputSurface( 290 sp<IGraphicBufferProducer>* bufferProducer) { 291 sp<AMessage> msg = new AMessage(kWhatCreateInputSurface, id()); 292 293 sp<AMessage> response; 294 status_t err = PostAndAwaitResponse(msg, &response); 295 if (err == NO_ERROR) { 296 // unwrap the sp<IGraphicBufferProducer> 297 sp<RefBase> obj; 298 bool found = response->findObject("input-surface", &obj); 299 CHECK(found); 300 sp<BufferProducerWrapper> wrapper( 301 static_cast<BufferProducerWrapper*>(obj.get())); 302 *bufferProducer = wrapper->getBufferProducer(); 303 } else { 304 ALOGW("createInputSurface failed, err=%d", err); 305 } 306 return err; 307} 308 309status_t MediaCodec::start() { 310 sp<AMessage> msg = new AMessage(kWhatStart, id()); 311 312 sp<AMessage> response; 313 return PostAndAwaitResponse(msg, &response); 314} 315 316status_t MediaCodec::stop() { 317 sp<AMessage> msg = new AMessage(kWhatStop, id()); 318 319 sp<AMessage> response; 320 return PostAndAwaitResponse(msg, &response); 321} 322 323status_t MediaCodec::release() { 324 sp<AMessage> msg = new AMessage(kWhatRelease, id()); 325 326 sp<AMessage> response; 327 return PostAndAwaitResponse(msg, &response); 328} 329 330status_t MediaCodec::reset() { 331 /* When external-facing MediaCodec object is created, 332 it is already initialized. Thus, reset is essentially 333 release() followed by init(), plus clearing the state */ 334 335 status_t err = release(); 336 337 // unregister handlers 338 if (mCodec != NULL) { 339 if (mCodecLooper != NULL) { 340 mCodecLooper->unregisterHandler(mCodec->id()); 341 } else { 342 mLooper->unregisterHandler(mCodec->id()); 343 } 344 mCodec = NULL; 345 } 346 mLooper->unregisterHandler(id()); 347 348 mFlags = 0; // clear all flags 349 mStickyError = OK; 350 351 // reset state not reset by setState(UNINITIALIZED) 352 mReplyID = 0; 353 mDequeueInputReplyID = 0; 354 mDequeueOutputReplyID = 0; 355 mDequeueInputTimeoutGeneration = 0; 356 mDequeueOutputTimeoutGeneration = 0; 357 mHaveInputSurface = false; 358 359 if (err == OK) { 360 err = init(mInitName, mInitNameIsType, mInitIsEncoder); 361 } 362 return err; 363} 364 365status_t MediaCodec::queueInputBuffer( 366 size_t index, 367 size_t offset, 368 size_t size, 369 int64_t presentationTimeUs, 370 uint32_t flags, 371 AString *errorDetailMsg) { 372 if (errorDetailMsg != NULL) { 373 errorDetailMsg->clear(); 374 } 375 376 sp<AMessage> msg = new AMessage(kWhatQueueInputBuffer, id()); 377 msg->setSize("index", index); 378 msg->setSize("offset", offset); 379 msg->setSize("size", size); 380 msg->setInt64("timeUs", presentationTimeUs); 381 msg->setInt32("flags", flags); 382 msg->setPointer("errorDetailMsg", errorDetailMsg); 383 384 sp<AMessage> response; 385 return PostAndAwaitResponse(msg, &response); 386} 387 388status_t MediaCodec::queueSecureInputBuffer( 389 size_t index, 390 size_t offset, 391 const CryptoPlugin::SubSample *subSamples, 392 size_t numSubSamples, 393 const uint8_t key[16], 394 const uint8_t iv[16], 395 CryptoPlugin::Mode mode, 396 int64_t presentationTimeUs, 397 uint32_t flags, 398 AString *errorDetailMsg) { 399 if (errorDetailMsg != NULL) { 400 errorDetailMsg->clear(); 401 } 402 403 sp<AMessage> msg = new AMessage(kWhatQueueInputBuffer, id()); 404 msg->setSize("index", index); 405 msg->setSize("offset", offset); 406 msg->setPointer("subSamples", (void *)subSamples); 407 msg->setSize("numSubSamples", numSubSamples); 408 msg->setPointer("key", (void *)key); 409 msg->setPointer("iv", (void *)iv); 410 msg->setInt32("mode", mode); 411 msg->setInt64("timeUs", presentationTimeUs); 412 msg->setInt32("flags", flags); 413 msg->setPointer("errorDetailMsg", errorDetailMsg); 414 415 sp<AMessage> response; 416 status_t err = PostAndAwaitResponse(msg, &response); 417 418 return err; 419} 420 421status_t MediaCodec::dequeueInputBuffer(size_t *index, int64_t timeoutUs) { 422 sp<AMessage> msg = new AMessage(kWhatDequeueInputBuffer, id()); 423 msg->setInt64("timeoutUs", timeoutUs); 424 425 sp<AMessage> response; 426 status_t err; 427 if ((err = PostAndAwaitResponse(msg, &response)) != OK) { 428 return err; 429 } 430 431 CHECK(response->findSize("index", index)); 432 433 return OK; 434} 435 436status_t MediaCodec::dequeueOutputBuffer( 437 size_t *index, 438 size_t *offset, 439 size_t *size, 440 int64_t *presentationTimeUs, 441 uint32_t *flags, 442 int64_t timeoutUs) { 443 sp<AMessage> msg = new AMessage(kWhatDequeueOutputBuffer, id()); 444 msg->setInt64("timeoutUs", timeoutUs); 445 446 sp<AMessage> response; 447 status_t err; 448 if ((err = PostAndAwaitResponse(msg, &response)) != OK) { 449 return err; 450 } 451 452 CHECK(response->findSize("index", index)); 453 CHECK(response->findSize("offset", offset)); 454 CHECK(response->findSize("size", size)); 455 CHECK(response->findInt64("timeUs", presentationTimeUs)); 456 CHECK(response->findInt32("flags", (int32_t *)flags)); 457 458 return OK; 459} 460 461status_t MediaCodec::renderOutputBufferAndRelease(size_t index) { 462 sp<AMessage> msg = new AMessage(kWhatReleaseOutputBuffer, id()); 463 msg->setSize("index", index); 464 msg->setInt32("render", true); 465 466 sp<AMessage> response; 467 return PostAndAwaitResponse(msg, &response); 468} 469 470status_t MediaCodec::renderOutputBufferAndRelease(size_t index, int64_t timestampNs) { 471 sp<AMessage> msg = new AMessage(kWhatReleaseOutputBuffer, id()); 472 msg->setSize("index", index); 473 msg->setInt32("render", true); 474 msg->setInt64("timestampNs", timestampNs); 475 476 sp<AMessage> response; 477 return PostAndAwaitResponse(msg, &response); 478} 479 480status_t MediaCodec::releaseOutputBuffer(size_t index) { 481 sp<AMessage> msg = new AMessage(kWhatReleaseOutputBuffer, id()); 482 msg->setSize("index", index); 483 484 sp<AMessage> response; 485 return PostAndAwaitResponse(msg, &response); 486} 487 488status_t MediaCodec::signalEndOfInputStream() { 489 sp<AMessage> msg = new AMessage(kWhatSignalEndOfInputStream, id()); 490 491 sp<AMessage> response; 492 return PostAndAwaitResponse(msg, &response); 493} 494 495status_t MediaCodec::getOutputFormat(sp<AMessage> *format) const { 496 sp<AMessage> msg = new AMessage(kWhatGetOutputFormat, id()); 497 498 sp<AMessage> response; 499 status_t err; 500 if ((err = PostAndAwaitResponse(msg, &response)) != OK) { 501 return err; 502 } 503 504 CHECK(response->findMessage("format", format)); 505 506 return OK; 507} 508 509status_t MediaCodec::getInputFormat(sp<AMessage> *format) const { 510 sp<AMessage> msg = new AMessage(kWhatGetInputFormat, id()); 511 512 sp<AMessage> response; 513 status_t err; 514 if ((err = PostAndAwaitResponse(msg, &response)) != OK) { 515 return err; 516 } 517 518 CHECK(response->findMessage("format", format)); 519 520 return OK; 521} 522 523status_t MediaCodec::getName(AString *name) const { 524 sp<AMessage> msg = new AMessage(kWhatGetName, id()); 525 526 sp<AMessage> response; 527 status_t err; 528 if ((err = PostAndAwaitResponse(msg, &response)) != OK) { 529 return err; 530 } 531 532 CHECK(response->findString("name", name)); 533 534 return OK; 535} 536 537status_t MediaCodec::getInputBuffers(Vector<sp<ABuffer> > *buffers) const { 538 sp<AMessage> msg = new AMessage(kWhatGetBuffers, id()); 539 msg->setInt32("portIndex", kPortIndexInput); 540 msg->setPointer("buffers", buffers); 541 542 sp<AMessage> response; 543 return PostAndAwaitResponse(msg, &response); 544} 545 546status_t MediaCodec::getOutputBuffers(Vector<sp<ABuffer> > *buffers) const { 547 sp<AMessage> msg = new AMessage(kWhatGetBuffers, id()); 548 msg->setInt32("portIndex", kPortIndexOutput); 549 msg->setPointer("buffers", buffers); 550 551 sp<AMessage> response; 552 return PostAndAwaitResponse(msg, &response); 553} 554 555status_t MediaCodec::getOutputBuffer(size_t index, sp<ABuffer> *buffer) { 556 sp<AMessage> format; 557 return getBufferAndFormat(kPortIndexOutput, index, buffer, &format); 558} 559 560status_t MediaCodec::getOutputFormat(size_t index, sp<AMessage> *format) { 561 sp<ABuffer> buffer; 562 return getBufferAndFormat(kPortIndexOutput, index, &buffer, format); 563} 564 565status_t MediaCodec::getInputBuffer(size_t index, sp<ABuffer> *buffer) { 566 sp<AMessage> format; 567 return getBufferAndFormat(kPortIndexInput, index, buffer, &format); 568} 569 570bool MediaCodec::isExecuting() const { 571 return mState == STARTED || mState == FLUSHED; 572} 573 574status_t MediaCodec::getBufferAndFormat( 575 size_t portIndex, size_t index, 576 sp<ABuffer> *buffer, sp<AMessage> *format) { 577 // use mutex instead of a context switch 578 579 buffer->clear(); 580 format->clear(); 581 if (!isExecuting()) { 582 return INVALID_OPERATION; 583 } 584 585 // we do not want mPortBuffers to change during this section 586 // we also don't want mOwnedByClient to change during this 587 Mutex::Autolock al(mBufferLock); 588 Vector<BufferInfo> *buffers = &mPortBuffers[portIndex]; 589 if (index < buffers->size()) { 590 const BufferInfo &info = buffers->itemAt(index); 591 if (info.mOwnedByClient) { 592 // by the time buffers array is initialized, crypto is set 593 if (portIndex == kPortIndexInput && mCrypto != NULL) { 594 *buffer = info.mEncryptedData; 595 } else { 596 *buffer = info.mData; 597 } 598 *format = info.mFormat; 599 } 600 } 601 return OK; 602} 603 604status_t MediaCodec::flush() { 605 sp<AMessage> msg = new AMessage(kWhatFlush, id()); 606 607 sp<AMessage> response; 608 return PostAndAwaitResponse(msg, &response); 609} 610 611status_t MediaCodec::requestIDRFrame() { 612 (new AMessage(kWhatRequestIDRFrame, id()))->post(); 613 614 return OK; 615} 616 617void MediaCodec::requestActivityNotification(const sp<AMessage> ¬ify) { 618 sp<AMessage> msg = new AMessage(kWhatRequestActivityNotification, id()); 619 msg->setMessage("notify", notify); 620 msg->post(); 621} 622 623//////////////////////////////////////////////////////////////////////////////// 624 625void MediaCodec::cancelPendingDequeueOperations() { 626 if (mFlags & kFlagDequeueInputPending) { 627 PostReplyWithError(mDequeueInputReplyID, INVALID_OPERATION); 628 629 ++mDequeueInputTimeoutGeneration; 630 mDequeueInputReplyID = 0; 631 mFlags &= ~kFlagDequeueInputPending; 632 } 633 634 if (mFlags & kFlagDequeueOutputPending) { 635 PostReplyWithError(mDequeueOutputReplyID, INVALID_OPERATION); 636 637 ++mDequeueOutputTimeoutGeneration; 638 mDequeueOutputReplyID = 0; 639 mFlags &= ~kFlagDequeueOutputPending; 640 } 641} 642 643bool MediaCodec::handleDequeueInputBuffer(uint32_t replyID, bool newRequest) { 644 if (!isExecuting() || (mFlags & kFlagIsAsync) 645 || (newRequest && (mFlags & kFlagDequeueInputPending))) { 646 PostReplyWithError(replyID, INVALID_OPERATION); 647 return true; 648 } else if (mFlags & kFlagStickyError) { 649 PostReplyWithError(replyID, getStickyError()); 650 return true; 651 } 652 653 ssize_t index = dequeuePortBuffer(kPortIndexInput); 654 655 if (index < 0) { 656 CHECK_EQ(index, -EAGAIN); 657 return false; 658 } 659 660 sp<AMessage> response = new AMessage; 661 response->setSize("index", index); 662 response->postReply(replyID); 663 664 return true; 665} 666 667bool MediaCodec::handleDequeueOutputBuffer(uint32_t replyID, bool newRequest) { 668 sp<AMessage> response = new AMessage; 669 670 if (!isExecuting() || (mFlags & kFlagIsAsync) 671 || (newRequest && (mFlags & kFlagDequeueOutputPending))) { 672 response->setInt32("err", INVALID_OPERATION); 673 } else if (mFlags & kFlagStickyError) { 674 response->setInt32("err", getStickyError()); 675 } else if (mFlags & kFlagOutputBuffersChanged) { 676 response->setInt32("err", INFO_OUTPUT_BUFFERS_CHANGED); 677 mFlags &= ~kFlagOutputBuffersChanged; 678 } else if (mFlags & kFlagOutputFormatChanged) { 679 response->setInt32("err", INFO_FORMAT_CHANGED); 680 mFlags &= ~kFlagOutputFormatChanged; 681 } else { 682 ssize_t index = dequeuePortBuffer(kPortIndexOutput); 683 684 if (index < 0) { 685 CHECK_EQ(index, -EAGAIN); 686 return false; 687 } 688 689 const sp<ABuffer> &buffer = 690 mPortBuffers[kPortIndexOutput].itemAt(index).mData; 691 692 response->setSize("index", index); 693 response->setSize("offset", buffer->offset()); 694 response->setSize("size", buffer->size()); 695 696 int64_t timeUs; 697 CHECK(buffer->meta()->findInt64("timeUs", &timeUs)); 698 699 response->setInt64("timeUs", timeUs); 700 701 int32_t omxFlags; 702 CHECK(buffer->meta()->findInt32("omxFlags", &omxFlags)); 703 704 uint32_t flags = 0; 705 if (omxFlags & OMX_BUFFERFLAG_SYNCFRAME) { 706 flags |= BUFFER_FLAG_SYNCFRAME; 707 } 708 if (omxFlags & OMX_BUFFERFLAG_CODECCONFIG) { 709 flags |= BUFFER_FLAG_CODECCONFIG; 710 } 711 if (omxFlags & OMX_BUFFERFLAG_EOS) { 712 flags |= BUFFER_FLAG_EOS; 713 } 714 715 response->setInt32("flags", flags); 716 } 717 718 response->postReply(replyID); 719 720 return true; 721} 722 723void MediaCodec::onMessageReceived(const sp<AMessage> &msg) { 724 switch (msg->what()) { 725 case kWhatCodecNotify: 726 { 727 int32_t what; 728 CHECK(msg->findInt32("what", &what)); 729 730 switch (what) { 731 case CodecBase::kWhatError: 732 { 733 int32_t err, actionCode; 734 CHECK(msg->findInt32("err", &err)); 735 CHECK(msg->findInt32("actionCode", &actionCode)); 736 737 ALOGE("Codec reported err %#x, actionCode %d, while in state %d", 738 err, actionCode, mState); 739 if (err == DEAD_OBJECT) { 740 mFlags |= kFlagSawMediaServerDie; 741 mFlags &= ~kFlagIsComponentAllocated; 742 } 743 744 bool sendErrorResponse = true; 745 746 switch (mState) { 747 case INITIALIZING: 748 { 749 setState(UNINITIALIZED); 750 break; 751 } 752 753 case CONFIGURING: 754 { 755 setState(actionCode == ACTION_CODE_FATAL ? 756 UNINITIALIZED : INITIALIZED); 757 break; 758 } 759 760 case STARTING: 761 { 762 setState(actionCode == ACTION_CODE_FATAL ? 763 UNINITIALIZED : CONFIGURED); 764 break; 765 } 766 767 case STOPPING: 768 case RELEASING: 769 { 770 // Ignore the error, assuming we'll still get 771 // the shutdown complete notification. 772 773 sendErrorResponse = false; 774 775 if (mFlags & kFlagSawMediaServerDie) { 776 // MediaServer died, there definitely won't 777 // be a shutdown complete notification after 778 // all. 779 780 // note that we're directly going from 781 // STOPPING->UNINITIALIZED, instead of the 782 // usual STOPPING->INITIALIZED state. 783 setState(UNINITIALIZED); 784 if (mState == RELEASING) { 785 mComponentName.clear(); 786 } 787 (new AMessage)->postReply(mReplyID); 788 } 789 break; 790 } 791 792 case FLUSHING: 793 { 794 if (actionCode == ACTION_CODE_FATAL) { 795 setState(UNINITIALIZED); 796 } else { 797 setState( 798 (mFlags & kFlagIsAsync) ? FLUSHED : STARTED); 799 } 800 break; 801 } 802 803 case FLUSHED: 804 case STARTED: 805 { 806 sendErrorResponse = false; 807 808 setStickyError(err); 809 postActivityNotificationIfPossible(); 810 811 cancelPendingDequeueOperations(); 812 813 if (mFlags & kFlagIsAsync) { 814 onError(err, actionCode); 815 } 816 switch (actionCode) { 817 case ACTION_CODE_TRANSIENT: 818 break; 819 case ACTION_CODE_RECOVERABLE: 820 setState(INITIALIZED); 821 break; 822 default: 823 setState(UNINITIALIZED); 824 break; 825 } 826 break; 827 } 828 829 default: 830 { 831 sendErrorResponse = false; 832 833 setStickyError(err); 834 postActivityNotificationIfPossible(); 835 836 // actionCode in an uninitialized state is always fatal. 837 if (mState == UNINITIALIZED) { 838 actionCode = ACTION_CODE_FATAL; 839 } 840 if (mFlags & kFlagIsAsync) { 841 onError(err, actionCode); 842 } 843 switch (actionCode) { 844 case ACTION_CODE_TRANSIENT: 845 break; 846 case ACTION_CODE_RECOVERABLE: 847 setState(INITIALIZED); 848 break; 849 default: 850 setState(UNINITIALIZED); 851 break; 852 } 853 break; 854 } 855 } 856 857 if (sendErrorResponse) { 858 PostReplyWithError(mReplyID, err); 859 } 860 break; 861 } 862 863 case CodecBase::kWhatComponentAllocated: 864 { 865 CHECK_EQ(mState, INITIALIZING); 866 setState(INITIALIZED); 867 mFlags |= kFlagIsComponentAllocated; 868 869 CHECK(msg->findString("componentName", &mComponentName)); 870 871 if (mComponentName.startsWith("OMX.google.")) { 872 mFlags |= kFlagIsSoftwareCodec; 873 } else { 874 mFlags &= ~kFlagIsSoftwareCodec; 875 } 876 877 if (mComponentName.endsWith(".secure")) { 878 mFlags |= kFlagIsSecure; 879 } else { 880 mFlags &= ~kFlagIsSecure; 881 } 882 883 (new AMessage)->postReply(mReplyID); 884 break; 885 } 886 887 case CodecBase::kWhatComponentConfigured: 888 { 889 CHECK_EQ(mState, CONFIGURING); 890 891 // reset input surface flag 892 mHaveInputSurface = false; 893 894 CHECK(msg->findMessage("input-format", &mInputFormat)); 895 CHECK(msg->findMessage("output-format", &mOutputFormat)); 896 897 setState(CONFIGURED); 898 (new AMessage)->postReply(mReplyID); 899 break; 900 } 901 902 case CodecBase::kWhatInputSurfaceCreated: 903 { 904 // response to initiateCreateInputSurface() 905 status_t err = NO_ERROR; 906 sp<AMessage> response = new AMessage(); 907 if (!msg->findInt32("err", &err)) { 908 sp<RefBase> obj; 909 msg->findObject("input-surface", &obj); 910 CHECK(obj != NULL); 911 response->setObject("input-surface", obj); 912 mHaveInputSurface = true; 913 } else { 914 response->setInt32("err", err); 915 } 916 response->postReply(mReplyID); 917 break; 918 } 919 920 case CodecBase::kWhatSignaledInputEOS: 921 { 922 // response to signalEndOfInputStream() 923 sp<AMessage> response = new AMessage(); 924 status_t err; 925 if (msg->findInt32("err", &err)) { 926 response->setInt32("err", err); 927 } 928 response->postReply(mReplyID); 929 break; 930 } 931 932 933 case CodecBase::kWhatBuffersAllocated: 934 { 935 Mutex::Autolock al(mBufferLock); 936 int32_t portIndex; 937 CHECK(msg->findInt32("portIndex", &portIndex)); 938 939 ALOGV("%s buffers allocated", 940 portIndex == kPortIndexInput ? "input" : "output"); 941 942 CHECK(portIndex == kPortIndexInput 943 || portIndex == kPortIndexOutput); 944 945 mPortBuffers[portIndex].clear(); 946 947 Vector<BufferInfo> *buffers = &mPortBuffers[portIndex]; 948 949 sp<RefBase> obj; 950 CHECK(msg->findObject("portDesc", &obj)); 951 952 sp<CodecBase::PortDescription> portDesc = 953 static_cast<CodecBase::PortDescription *>(obj.get()); 954 955 size_t numBuffers = portDesc->countBuffers(); 956 957 for (size_t i = 0; i < numBuffers; ++i) { 958 BufferInfo info; 959 info.mBufferID = portDesc->bufferIDAt(i); 960 info.mOwnedByClient = false; 961 info.mData = portDesc->bufferAt(i); 962 963 if (portIndex == kPortIndexInput && mCrypto != NULL) { 964 info.mEncryptedData = 965 new ABuffer(info.mData->capacity()); 966 } 967 968 buffers->push_back(info); 969 } 970 971 if (portIndex == kPortIndexOutput) { 972 if (mState == STARTING) { 973 // We're always allocating output buffers after 974 // allocating input buffers, so this is a good 975 // indication that now all buffers are allocated. 976 setState(STARTED); 977 (new AMessage)->postReply(mReplyID); 978 } else { 979 mFlags |= kFlagOutputBuffersChanged; 980 postActivityNotificationIfPossible(); 981 } 982 } 983 break; 984 } 985 986 case CodecBase::kWhatOutputFormatChanged: 987 { 988 ALOGV("codec output format changed"); 989 990 if (mSoftRenderer == NULL && 991 mNativeWindow != NULL && 992 (mFlags & kFlagIsSoftwareCodec)) { 993 AString mime; 994 CHECK(msg->findString("mime", &mime)); 995 996 if (mime.startsWithIgnoreCase("video/")) { 997 mSoftRenderer = new SoftwareRenderer(mNativeWindow); 998 } 999 } 1000 1001 mOutputFormat = msg; 1002 1003 if (mFlags & kFlagIsEncoder) { 1004 // Before we announce the format change we should 1005 // collect codec specific data and amend the output 1006 // format as necessary. 1007 mFlags |= kFlagGatherCodecSpecificData; 1008 } else if (mFlags & kFlagIsAsync) { 1009 onOutputFormatChanged(); 1010 } else { 1011 mFlags |= kFlagOutputFormatChanged; 1012 postActivityNotificationIfPossible(); 1013 } 1014 break; 1015 } 1016 1017 case CodecBase::kWhatFillThisBuffer: 1018 { 1019 /* size_t index = */updateBuffers(kPortIndexInput, msg); 1020 1021 if (mState == FLUSHING 1022 || mState == STOPPING 1023 || mState == RELEASING) { 1024 returnBuffersToCodecOnPort(kPortIndexInput); 1025 break; 1026 } 1027 1028 if (!mCSD.empty()) { 1029 ssize_t index = dequeuePortBuffer(kPortIndexInput); 1030 CHECK_GE(index, 0); 1031 1032 // If codec specific data had been specified as 1033 // part of the format in the call to configure and 1034 // if there's more csd left, we submit it here 1035 // clients only get access to input buffers once 1036 // this data has been exhausted. 1037 1038 status_t err = queueCSDInputBuffer(index); 1039 1040 if (err != OK) { 1041 ALOGE("queueCSDInputBuffer failed w/ error %d", 1042 err); 1043 1044 setStickyError(err); 1045 postActivityNotificationIfPossible(); 1046 1047 cancelPendingDequeueOperations(); 1048 } 1049 break; 1050 } 1051 1052 if (mFlags & kFlagIsAsync) { 1053 if (!mHaveInputSurface) { 1054 onInputBufferAvailable(); 1055 } 1056 } else if (mFlags & kFlagDequeueInputPending) { 1057 CHECK(handleDequeueInputBuffer(mDequeueInputReplyID)); 1058 1059 ++mDequeueInputTimeoutGeneration; 1060 mFlags &= ~kFlagDequeueInputPending; 1061 mDequeueInputReplyID = 0; 1062 } else { 1063 postActivityNotificationIfPossible(); 1064 } 1065 break; 1066 } 1067 1068 case CodecBase::kWhatDrainThisBuffer: 1069 { 1070 /* size_t index = */updateBuffers(kPortIndexOutput, msg); 1071 1072 if (mState == FLUSHING 1073 || mState == STOPPING 1074 || mState == RELEASING) { 1075 returnBuffersToCodecOnPort(kPortIndexOutput); 1076 break; 1077 } 1078 1079 sp<ABuffer> buffer; 1080 CHECK(msg->findBuffer("buffer", &buffer)); 1081 1082 int32_t omxFlags; 1083 CHECK(msg->findInt32("flags", &omxFlags)); 1084 1085 buffer->meta()->setInt32("omxFlags", omxFlags); 1086 1087 if (mFlags & kFlagGatherCodecSpecificData) { 1088 // This is the very first output buffer after a 1089 // format change was signalled, it'll either contain 1090 // the one piece of codec specific data we can expect 1091 // or there won't be codec specific data. 1092 if (omxFlags & OMX_BUFFERFLAG_CODECCONFIG) { 1093 status_t err = 1094 amendOutputFormatWithCodecSpecificData(buffer); 1095 1096 if (err != OK) { 1097 ALOGE("Codec spit out malformed codec " 1098 "specific data!"); 1099 } 1100 } 1101 1102 mFlags &= ~kFlagGatherCodecSpecificData; 1103 if (mFlags & kFlagIsAsync) { 1104 onOutputFormatChanged(); 1105 } else { 1106 mFlags |= kFlagOutputFormatChanged; 1107 } 1108 } 1109 1110 if (mFlags & kFlagIsAsync) { 1111 onOutputBufferAvailable(); 1112 } else if (mFlags & kFlagDequeueOutputPending) { 1113 CHECK(handleDequeueOutputBuffer(mDequeueOutputReplyID)); 1114 1115 ++mDequeueOutputTimeoutGeneration; 1116 mFlags &= ~kFlagDequeueOutputPending; 1117 mDequeueOutputReplyID = 0; 1118 } else { 1119 postActivityNotificationIfPossible(); 1120 } 1121 1122 break; 1123 } 1124 1125 case CodecBase::kWhatEOS: 1126 { 1127 // We already notify the client of this by using the 1128 // corresponding flag in "onOutputBufferReady". 1129 break; 1130 } 1131 1132 case CodecBase::kWhatShutdownCompleted: 1133 { 1134 if (mState == STOPPING) { 1135 setState(INITIALIZED); 1136 } else { 1137 CHECK_EQ(mState, RELEASING); 1138 setState(UNINITIALIZED); 1139 mComponentName.clear(); 1140 } 1141 mFlags &= ~kFlagIsComponentAllocated; 1142 1143 (new AMessage)->postReply(mReplyID); 1144 break; 1145 } 1146 1147 case CodecBase::kWhatFlushCompleted: 1148 { 1149 if (mState != FLUSHING) { 1150 ALOGW("received FlushCompleted message in state %d", 1151 mState); 1152 break; 1153 } 1154 1155 if (mFlags & kFlagIsAsync) { 1156 setState(FLUSHED); 1157 } else { 1158 setState(STARTED); 1159 mCodec->signalResume(); 1160 } 1161 1162 (new AMessage)->postReply(mReplyID); 1163 break; 1164 } 1165 1166 default: 1167 TRESPASS(); 1168 } 1169 break; 1170 } 1171 1172 case kWhatInit: 1173 { 1174 uint32_t replyID; 1175 CHECK(msg->senderAwaitsResponse(&replyID)); 1176 1177 if (mState != UNINITIALIZED) { 1178 PostReplyWithError(replyID, INVALID_OPERATION); 1179 break; 1180 } 1181 1182 mReplyID = replyID; 1183 setState(INITIALIZING); 1184 1185 AString name; 1186 CHECK(msg->findString("name", &name)); 1187 1188 int32_t nameIsType; 1189 int32_t encoder = false; 1190 CHECK(msg->findInt32("nameIsType", &nameIsType)); 1191 if (nameIsType) { 1192 CHECK(msg->findInt32("encoder", &encoder)); 1193 } 1194 1195 sp<AMessage> format = new AMessage; 1196 1197 if (nameIsType) { 1198 format->setString("mime", name.c_str()); 1199 format->setInt32("encoder", encoder); 1200 } else { 1201 format->setString("componentName", name.c_str()); 1202 } 1203 1204 mCodec->initiateAllocateComponent(format); 1205 break; 1206 } 1207 1208 case kWhatSetCallback: 1209 { 1210 uint32_t replyID; 1211 CHECK(msg->senderAwaitsResponse(&replyID)); 1212 1213 if (mState == UNINITIALIZED 1214 || mState == INITIALIZING 1215 || isExecuting()) { 1216 // callback can't be set after codec is executing, 1217 // or before it's initialized (as the callback 1218 // will be cleared when it goes to INITIALIZED) 1219 PostReplyWithError(replyID, INVALID_OPERATION); 1220 break; 1221 } 1222 1223 sp<AMessage> callback; 1224 CHECK(msg->findMessage("callback", &callback)); 1225 1226 mCallback = callback; 1227 1228 if (mCallback != NULL) { 1229 ALOGI("MediaCodec will operate in async mode"); 1230 mFlags |= kFlagIsAsync; 1231 } else { 1232 mFlags &= ~kFlagIsAsync; 1233 } 1234 1235 sp<AMessage> response = new AMessage; 1236 response->postReply(replyID); 1237 break; 1238 } 1239 1240 case kWhatConfigure: 1241 { 1242 uint32_t replyID; 1243 CHECK(msg->senderAwaitsResponse(&replyID)); 1244 1245 if (mState != INITIALIZED) { 1246 PostReplyWithError(replyID, INVALID_OPERATION); 1247 break; 1248 } 1249 1250 sp<RefBase> obj; 1251 if (!msg->findObject("native-window", &obj)) { 1252 obj.clear(); 1253 } 1254 1255 sp<AMessage> format; 1256 CHECK(msg->findMessage("format", &format)); 1257 1258 if (obj != NULL) { 1259 format->setObject("native-window", obj); 1260 1261 status_t err = setNativeWindow( 1262 static_cast<NativeWindowWrapper *>(obj.get()) 1263 ->getSurfaceTextureClient()); 1264 1265 if (err != OK) { 1266 PostReplyWithError(replyID, err); 1267 break; 1268 } 1269 } else { 1270 setNativeWindow(NULL); 1271 } 1272 1273 mReplyID = replyID; 1274 setState(CONFIGURING); 1275 1276 void *crypto; 1277 if (!msg->findPointer("crypto", &crypto)) { 1278 crypto = NULL; 1279 } 1280 1281 mCrypto = static_cast<ICrypto *>(crypto); 1282 1283 uint32_t flags; 1284 CHECK(msg->findInt32("flags", (int32_t *)&flags)); 1285 1286 if (flags & CONFIGURE_FLAG_ENCODE) { 1287 format->setInt32("encoder", true); 1288 mFlags |= kFlagIsEncoder; 1289 } 1290 1291 extractCSD(format); 1292 1293 mCodec->initiateConfigureComponent(format); 1294 break; 1295 } 1296 1297 case kWhatCreateInputSurface: 1298 { 1299 uint32_t replyID; 1300 CHECK(msg->senderAwaitsResponse(&replyID)); 1301 1302 // Must be configured, but can't have been started yet. 1303 if (mState != CONFIGURED) { 1304 PostReplyWithError(replyID, INVALID_OPERATION); 1305 break; 1306 } 1307 1308 mReplyID = replyID; 1309 mCodec->initiateCreateInputSurface(); 1310 break; 1311 } 1312 1313 case kWhatStart: 1314 { 1315 uint32_t replyID; 1316 CHECK(msg->senderAwaitsResponse(&replyID)); 1317 1318 if (mState == FLUSHED) { 1319 mCodec->signalResume(); 1320 PostReplyWithError(replyID, OK); 1321 } else if (mState != CONFIGURED) { 1322 PostReplyWithError(replyID, INVALID_OPERATION); 1323 break; 1324 } 1325 1326 mReplyID = replyID; 1327 setState(STARTING); 1328 1329 mCodec->initiateStart(); 1330 break; 1331 } 1332 1333 case kWhatStop: 1334 case kWhatRelease: 1335 { 1336 State targetState = 1337 (msg->what() == kWhatStop) ? INITIALIZED : UNINITIALIZED; 1338 1339 uint32_t replyID; 1340 CHECK(msg->senderAwaitsResponse(&replyID)); 1341 1342 if (!((mFlags & kFlagIsComponentAllocated) && targetState == UNINITIALIZED) // See 1 1343 && mState != INITIALIZED 1344 && mState != CONFIGURED && !isExecuting()) { 1345 // 1) Permit release to shut down the component if allocated. 1346 // 1347 // 2) We may be in "UNINITIALIZED" state already and 1348 // also shutdown the encoder/decoder without the 1349 // client being aware of this if media server died while 1350 // we were being stopped. The client would assume that 1351 // after stop() returned, it would be safe to call release() 1352 // and it should be in this case, no harm to allow a release() 1353 // if we're already uninitialized. 1354 sp<AMessage> response = new AMessage; 1355 status_t err = mState == targetState ? OK : INVALID_OPERATION; 1356 response->setInt32("err", err); 1357 if (err == OK && targetState == UNINITIALIZED) { 1358 mComponentName.clear(); 1359 } 1360 response->postReply(replyID); 1361 break; 1362 } 1363 1364 if (mFlags & kFlagSawMediaServerDie) { 1365 // It's dead, Jim. Don't expect initiateShutdown to yield 1366 // any useful results now... 1367 setState(UNINITIALIZED); 1368 if (targetState == UNINITIALIZED) { 1369 mComponentName.clear(); 1370 } 1371 (new AMessage)->postReply(replyID); 1372 break; 1373 } 1374 1375 mReplyID = replyID; 1376 setState(msg->what() == kWhatStop ? STOPPING : RELEASING); 1377 1378 mCodec->initiateShutdown( 1379 msg->what() == kWhatStop /* keepComponentAllocated */); 1380 1381 returnBuffersToCodec(); 1382 break; 1383 } 1384 1385 case kWhatDequeueInputBuffer: 1386 { 1387 uint32_t replyID; 1388 CHECK(msg->senderAwaitsResponse(&replyID)); 1389 1390 if (mFlags & kFlagIsAsync) { 1391 ALOGE("dequeueOutputBuffer can't be used in async mode"); 1392 PostReplyWithError(replyID, INVALID_OPERATION); 1393 break; 1394 } 1395 1396 if (mHaveInputSurface) { 1397 ALOGE("dequeueInputBuffer can't be used with input surface"); 1398 PostReplyWithError(replyID, INVALID_OPERATION); 1399 break; 1400 } 1401 1402 if (handleDequeueInputBuffer(replyID, true /* new request */)) { 1403 break; 1404 } 1405 1406 int64_t timeoutUs; 1407 CHECK(msg->findInt64("timeoutUs", &timeoutUs)); 1408 1409 if (timeoutUs == 0ll) { 1410 PostReplyWithError(replyID, -EAGAIN); 1411 break; 1412 } 1413 1414 mFlags |= kFlagDequeueInputPending; 1415 mDequeueInputReplyID = replyID; 1416 1417 if (timeoutUs > 0ll) { 1418 sp<AMessage> timeoutMsg = 1419 new AMessage(kWhatDequeueInputTimedOut, id()); 1420 timeoutMsg->setInt32( 1421 "generation", ++mDequeueInputTimeoutGeneration); 1422 timeoutMsg->post(timeoutUs); 1423 } 1424 break; 1425 } 1426 1427 case kWhatDequeueInputTimedOut: 1428 { 1429 int32_t generation; 1430 CHECK(msg->findInt32("generation", &generation)); 1431 1432 if (generation != mDequeueInputTimeoutGeneration) { 1433 // Obsolete 1434 break; 1435 } 1436 1437 CHECK(mFlags & kFlagDequeueInputPending); 1438 1439 PostReplyWithError(mDequeueInputReplyID, -EAGAIN); 1440 1441 mFlags &= ~kFlagDequeueInputPending; 1442 mDequeueInputReplyID = 0; 1443 break; 1444 } 1445 1446 case kWhatQueueInputBuffer: 1447 { 1448 uint32_t replyID; 1449 CHECK(msg->senderAwaitsResponse(&replyID)); 1450 1451 if (!isExecuting()) { 1452 PostReplyWithError(replyID, INVALID_OPERATION); 1453 break; 1454 } else if (mFlags & kFlagStickyError) { 1455 PostReplyWithError(replyID, getStickyError()); 1456 break; 1457 } 1458 1459 status_t err = onQueueInputBuffer(msg); 1460 1461 PostReplyWithError(replyID, err); 1462 break; 1463 } 1464 1465 case kWhatDequeueOutputBuffer: 1466 { 1467 uint32_t replyID; 1468 CHECK(msg->senderAwaitsResponse(&replyID)); 1469 1470 if (mFlags & kFlagIsAsync) { 1471 ALOGE("dequeueOutputBuffer can't be used in async mode"); 1472 PostReplyWithError(replyID, INVALID_OPERATION); 1473 break; 1474 } 1475 1476 if (handleDequeueOutputBuffer(replyID, true /* new request */)) { 1477 break; 1478 } 1479 1480 int64_t timeoutUs; 1481 CHECK(msg->findInt64("timeoutUs", &timeoutUs)); 1482 1483 if (timeoutUs == 0ll) { 1484 PostReplyWithError(replyID, -EAGAIN); 1485 break; 1486 } 1487 1488 mFlags |= kFlagDequeueOutputPending; 1489 mDequeueOutputReplyID = replyID; 1490 1491 if (timeoutUs > 0ll) { 1492 sp<AMessage> timeoutMsg = 1493 new AMessage(kWhatDequeueOutputTimedOut, id()); 1494 timeoutMsg->setInt32( 1495 "generation", ++mDequeueOutputTimeoutGeneration); 1496 timeoutMsg->post(timeoutUs); 1497 } 1498 break; 1499 } 1500 1501 case kWhatDequeueOutputTimedOut: 1502 { 1503 int32_t generation; 1504 CHECK(msg->findInt32("generation", &generation)); 1505 1506 if (generation != mDequeueOutputTimeoutGeneration) { 1507 // Obsolete 1508 break; 1509 } 1510 1511 CHECK(mFlags & kFlagDequeueOutputPending); 1512 1513 PostReplyWithError(mDequeueOutputReplyID, -EAGAIN); 1514 1515 mFlags &= ~kFlagDequeueOutputPending; 1516 mDequeueOutputReplyID = 0; 1517 break; 1518 } 1519 1520 case kWhatReleaseOutputBuffer: 1521 { 1522 uint32_t replyID; 1523 CHECK(msg->senderAwaitsResponse(&replyID)); 1524 1525 if (!isExecuting()) { 1526 PostReplyWithError(replyID, INVALID_OPERATION); 1527 break; 1528 } else if (mFlags & kFlagStickyError) { 1529 PostReplyWithError(replyID, getStickyError()); 1530 break; 1531 } 1532 1533 status_t err = onReleaseOutputBuffer(msg); 1534 1535 PostReplyWithError(replyID, err); 1536 break; 1537 } 1538 1539 case kWhatSignalEndOfInputStream: 1540 { 1541 uint32_t replyID; 1542 CHECK(msg->senderAwaitsResponse(&replyID)); 1543 1544 if (!isExecuting()) { 1545 PostReplyWithError(replyID, INVALID_OPERATION); 1546 break; 1547 } else if (mFlags & kFlagStickyError) { 1548 PostReplyWithError(replyID, getStickyError()); 1549 break; 1550 } 1551 1552 mReplyID = replyID; 1553 mCodec->signalEndOfInputStream(); 1554 break; 1555 } 1556 1557 case kWhatGetBuffers: 1558 { 1559 uint32_t replyID; 1560 CHECK(msg->senderAwaitsResponse(&replyID)); 1561 1562 if (!isExecuting() || (mFlags & kFlagIsAsync)) { 1563 PostReplyWithError(replyID, INVALID_OPERATION); 1564 break; 1565 } else if (mFlags & kFlagStickyError) { 1566 PostReplyWithError(replyID, getStickyError()); 1567 break; 1568 } 1569 1570 int32_t portIndex; 1571 CHECK(msg->findInt32("portIndex", &portIndex)); 1572 1573 Vector<sp<ABuffer> > *dstBuffers; 1574 CHECK(msg->findPointer("buffers", (void **)&dstBuffers)); 1575 1576 dstBuffers->clear(); 1577 const Vector<BufferInfo> &srcBuffers = mPortBuffers[portIndex]; 1578 1579 for (size_t i = 0; i < srcBuffers.size(); ++i) { 1580 const BufferInfo &info = srcBuffers.itemAt(i); 1581 1582 dstBuffers->push_back( 1583 (portIndex == kPortIndexInput && mCrypto != NULL) 1584 ? info.mEncryptedData : info.mData); 1585 } 1586 1587 (new AMessage)->postReply(replyID); 1588 break; 1589 } 1590 1591 case kWhatFlush: 1592 { 1593 uint32_t replyID; 1594 CHECK(msg->senderAwaitsResponse(&replyID)); 1595 1596 if (!isExecuting()) { 1597 PostReplyWithError(replyID, INVALID_OPERATION); 1598 break; 1599 } else if (mFlags & kFlagStickyError) { 1600 PostReplyWithError(replyID, getStickyError()); 1601 break; 1602 } 1603 1604 mReplyID = replyID; 1605 // TODO: skip flushing if already FLUSHED 1606 setState(FLUSHING); 1607 1608 mCodec->signalFlush(); 1609 returnBuffersToCodec(); 1610 break; 1611 } 1612 1613 case kWhatGetInputFormat: 1614 case kWhatGetOutputFormat: 1615 { 1616 sp<AMessage> format = 1617 (msg->what() == kWhatGetOutputFormat ? mOutputFormat : mInputFormat); 1618 1619 uint32_t replyID; 1620 CHECK(msg->senderAwaitsResponse(&replyID)); 1621 1622 if ((mState != CONFIGURED && mState != STARTING && 1623 mState != STARTED && mState != FLUSHING && 1624 mState != FLUSHED) 1625 || format == NULL) { 1626 PostReplyWithError(replyID, INVALID_OPERATION); 1627 break; 1628 } else if (mFlags & kFlagStickyError) { 1629 PostReplyWithError(replyID, getStickyError()); 1630 break; 1631 } 1632 1633 sp<AMessage> response = new AMessage; 1634 response->setMessage("format", format); 1635 response->postReply(replyID); 1636 break; 1637 } 1638 1639 case kWhatRequestIDRFrame: 1640 { 1641 mCodec->signalRequestIDRFrame(); 1642 break; 1643 } 1644 1645 case kWhatRequestActivityNotification: 1646 { 1647 CHECK(mActivityNotify == NULL); 1648 CHECK(msg->findMessage("notify", &mActivityNotify)); 1649 1650 postActivityNotificationIfPossible(); 1651 break; 1652 } 1653 1654 case kWhatGetName: 1655 { 1656 uint32_t replyID; 1657 CHECK(msg->senderAwaitsResponse(&replyID)); 1658 1659 if (mComponentName.empty()) { 1660 PostReplyWithError(replyID, INVALID_OPERATION); 1661 break; 1662 } 1663 1664 sp<AMessage> response = new AMessage; 1665 response->setString("name", mComponentName.c_str()); 1666 response->postReply(replyID); 1667 break; 1668 } 1669 1670 case kWhatSetParameters: 1671 { 1672 uint32_t replyID; 1673 CHECK(msg->senderAwaitsResponse(&replyID)); 1674 1675 sp<AMessage> params; 1676 CHECK(msg->findMessage("params", ¶ms)); 1677 1678 status_t err = onSetParameters(params); 1679 1680 PostReplyWithError(replyID, err); 1681 break; 1682 } 1683 1684 default: 1685 TRESPASS(); 1686 } 1687} 1688 1689void MediaCodec::extractCSD(const sp<AMessage> &format) { 1690 mCSD.clear(); 1691 1692 size_t i = 0; 1693 for (;;) { 1694 sp<ABuffer> csd; 1695 if (!format->findBuffer(StringPrintf("csd-%u", i).c_str(), &csd)) { 1696 break; 1697 } 1698 1699 mCSD.push_back(csd); 1700 ++i; 1701 } 1702 1703 ALOGV("Found %zu pieces of codec specific data.", mCSD.size()); 1704} 1705 1706status_t MediaCodec::queueCSDInputBuffer(size_t bufferIndex) { 1707 CHECK(!mCSD.empty()); 1708 1709 const BufferInfo *info = 1710 &mPortBuffers[kPortIndexInput].itemAt(bufferIndex); 1711 1712 sp<ABuffer> csd = *mCSD.begin(); 1713 mCSD.erase(mCSD.begin()); 1714 1715 const sp<ABuffer> &codecInputData = 1716 (mCrypto != NULL) ? info->mEncryptedData : info->mData; 1717 1718 if (csd->size() > codecInputData->capacity()) { 1719 return -EINVAL; 1720 } 1721 1722 memcpy(codecInputData->data(), csd->data(), csd->size()); 1723 1724 AString errorDetailMsg; 1725 1726 sp<AMessage> msg = new AMessage(kWhatQueueInputBuffer, id()); 1727 msg->setSize("index", bufferIndex); 1728 msg->setSize("offset", 0); 1729 msg->setSize("size", csd->size()); 1730 msg->setInt64("timeUs", 0ll); 1731 msg->setInt32("flags", BUFFER_FLAG_CODECCONFIG); 1732 msg->setPointer("errorDetailMsg", &errorDetailMsg); 1733 1734 return onQueueInputBuffer(msg); 1735} 1736 1737void MediaCodec::setState(State newState) { 1738 if (newState == INITIALIZED || newState == UNINITIALIZED) { 1739 delete mSoftRenderer; 1740 mSoftRenderer = NULL; 1741 1742 mCrypto.clear(); 1743 setNativeWindow(NULL); 1744 1745 mInputFormat.clear(); 1746 mOutputFormat.clear(); 1747 mFlags &= ~kFlagOutputFormatChanged; 1748 mFlags &= ~kFlagOutputBuffersChanged; 1749 mFlags &= ~kFlagStickyError; 1750 mFlags &= ~kFlagIsEncoder; 1751 mFlags &= ~kFlagGatherCodecSpecificData; 1752 mFlags &= ~kFlagIsAsync; 1753 mStickyError = OK; 1754 1755 mActivityNotify.clear(); 1756 mCallback.clear(); 1757 } 1758 1759 if (newState == UNINITIALIZED) { 1760 // return any straggling buffers, e.g. if we got here on an error 1761 returnBuffersToCodec(); 1762 1763 // The component is gone, mediaserver's probably back up already 1764 // but should definitely be back up should we try to instantiate 1765 // another component.. and the cycle continues. 1766 mFlags &= ~kFlagSawMediaServerDie; 1767 } 1768 1769 mState = newState; 1770 1771 cancelPendingDequeueOperations(); 1772 1773 updateBatteryStat(); 1774} 1775 1776void MediaCodec::returnBuffersToCodec() { 1777 returnBuffersToCodecOnPort(kPortIndexInput); 1778 returnBuffersToCodecOnPort(kPortIndexOutput); 1779} 1780 1781void MediaCodec::returnBuffersToCodecOnPort(int32_t portIndex) { 1782 CHECK(portIndex == kPortIndexInput || portIndex == kPortIndexOutput); 1783 Mutex::Autolock al(mBufferLock); 1784 1785 Vector<BufferInfo> *buffers = &mPortBuffers[portIndex]; 1786 1787 for (size_t i = 0; i < buffers->size(); ++i) { 1788 BufferInfo *info = &buffers->editItemAt(i); 1789 1790 if (info->mNotify != NULL) { 1791 sp<AMessage> msg = info->mNotify; 1792 info->mNotify = NULL; 1793 info->mOwnedByClient = false; 1794 1795 if (portIndex == kPortIndexInput) { 1796 /* no error, just returning buffers */ 1797 msg->setInt32("err", OK); 1798 } 1799 msg->post(); 1800 } 1801 } 1802 1803 mAvailPortBuffers[portIndex].clear(); 1804} 1805 1806size_t MediaCodec::updateBuffers( 1807 int32_t portIndex, const sp<AMessage> &msg) { 1808 CHECK(portIndex == kPortIndexInput || portIndex == kPortIndexOutput); 1809 1810 uint32_t bufferID; 1811 CHECK(msg->findInt32("buffer-id", (int32_t*)&bufferID)); 1812 1813 Vector<BufferInfo> *buffers = &mPortBuffers[portIndex]; 1814 1815 for (size_t i = 0; i < buffers->size(); ++i) { 1816 BufferInfo *info = &buffers->editItemAt(i); 1817 1818 if (info->mBufferID == bufferID) { 1819 CHECK(info->mNotify == NULL); 1820 CHECK(msg->findMessage("reply", &info->mNotify)); 1821 1822 info->mFormat = 1823 (portIndex == kPortIndexInput) ? mInputFormat : mOutputFormat; 1824 mAvailPortBuffers[portIndex].push_back(i); 1825 1826 return i; 1827 } 1828 } 1829 1830 TRESPASS(); 1831 1832 return 0; 1833} 1834 1835status_t MediaCodec::onQueueInputBuffer(const sp<AMessage> &msg) { 1836 size_t index; 1837 size_t offset; 1838 size_t size; 1839 int64_t timeUs; 1840 uint32_t flags; 1841 CHECK(msg->findSize("index", &index)); 1842 CHECK(msg->findSize("offset", &offset)); 1843 CHECK(msg->findInt64("timeUs", &timeUs)); 1844 CHECK(msg->findInt32("flags", (int32_t *)&flags)); 1845 1846 const CryptoPlugin::SubSample *subSamples; 1847 size_t numSubSamples; 1848 const uint8_t *key; 1849 const uint8_t *iv; 1850 CryptoPlugin::Mode mode = CryptoPlugin::kMode_Unencrypted; 1851 1852 // We allow the simpler queueInputBuffer API to be used even in 1853 // secure mode, by fabricating a single unencrypted subSample. 1854 CryptoPlugin::SubSample ss; 1855 1856 if (msg->findSize("size", &size)) { 1857 if (mCrypto != NULL) { 1858 ss.mNumBytesOfClearData = size; 1859 ss.mNumBytesOfEncryptedData = 0; 1860 1861 subSamples = &ss; 1862 numSubSamples = 1; 1863 key = NULL; 1864 iv = NULL; 1865 } 1866 } else { 1867 if (mCrypto == NULL) { 1868 return -EINVAL; 1869 } 1870 1871 CHECK(msg->findPointer("subSamples", (void **)&subSamples)); 1872 CHECK(msg->findSize("numSubSamples", &numSubSamples)); 1873 CHECK(msg->findPointer("key", (void **)&key)); 1874 CHECK(msg->findPointer("iv", (void **)&iv)); 1875 1876 int32_t tmp; 1877 CHECK(msg->findInt32("mode", &tmp)); 1878 1879 mode = (CryptoPlugin::Mode)tmp; 1880 1881 size = 0; 1882 for (size_t i = 0; i < numSubSamples; ++i) { 1883 size += subSamples[i].mNumBytesOfClearData; 1884 size += subSamples[i].mNumBytesOfEncryptedData; 1885 } 1886 } 1887 1888 if (index >= mPortBuffers[kPortIndexInput].size()) { 1889 return -ERANGE; 1890 } 1891 1892 BufferInfo *info = &mPortBuffers[kPortIndexInput].editItemAt(index); 1893 1894 if (info->mNotify == NULL || !info->mOwnedByClient) { 1895 return -EACCES; 1896 } 1897 1898 if (offset + size > info->mData->capacity()) { 1899 return -EINVAL; 1900 } 1901 1902 sp<AMessage> reply = info->mNotify; 1903 info->mData->setRange(offset, size); 1904 info->mData->meta()->setInt64("timeUs", timeUs); 1905 1906 if (flags & BUFFER_FLAG_EOS) { 1907 info->mData->meta()->setInt32("eos", true); 1908 } 1909 1910 if (flags & BUFFER_FLAG_CODECCONFIG) { 1911 info->mData->meta()->setInt32("csd", true); 1912 } 1913 1914 if (mCrypto != NULL) { 1915 if (size > info->mEncryptedData->capacity()) { 1916 return -ERANGE; 1917 } 1918 1919 AString *errorDetailMsg; 1920 CHECK(msg->findPointer("errorDetailMsg", (void **)&errorDetailMsg)); 1921 1922 ssize_t result = mCrypto->decrypt( 1923 (mFlags & kFlagIsSecure) != 0, 1924 key, 1925 iv, 1926 mode, 1927 info->mEncryptedData->base() + offset, 1928 subSamples, 1929 numSubSamples, 1930 info->mData->base(), 1931 errorDetailMsg); 1932 1933 if (result < 0) { 1934 return result; 1935 } 1936 1937 info->mData->setRange(0, result); 1938 } 1939 1940 // synchronization boundary for getBufferAndFormat 1941 { 1942 Mutex::Autolock al(mBufferLock); 1943 info->mOwnedByClient = false; 1944 } 1945 reply->setBuffer("buffer", info->mData); 1946 reply->post(); 1947 1948 info->mNotify = NULL; 1949 1950 return OK; 1951} 1952 1953status_t MediaCodec::onReleaseOutputBuffer(const sp<AMessage> &msg) { 1954 size_t index; 1955 CHECK(msg->findSize("index", &index)); 1956 1957 int32_t render; 1958 if (!msg->findInt32("render", &render)) { 1959 render = 0; 1960 } 1961 1962 if (!isExecuting()) { 1963 return -EINVAL; 1964 } 1965 1966 if (index >= mPortBuffers[kPortIndexOutput].size()) { 1967 return -ERANGE; 1968 } 1969 1970 BufferInfo *info = &mPortBuffers[kPortIndexOutput].editItemAt(index); 1971 1972 if (info->mNotify == NULL || !info->mOwnedByClient) { 1973 return -EACCES; 1974 } 1975 1976 // synchronization boundary for getBufferAndFormat 1977 { 1978 Mutex::Autolock al(mBufferLock); 1979 info->mOwnedByClient = false; 1980 } 1981 1982 if (render && info->mData != NULL && info->mData->size() != 0) { 1983 info->mNotify->setInt32("render", true); 1984 1985 int64_t timestampNs = 0; 1986 if (msg->findInt64("timestampNs", ×tampNs)) { 1987 info->mNotify->setInt64("timestampNs", timestampNs); 1988 } else { 1989 // TODO: it seems like we should use the timestamp 1990 // in the (media)buffer as it potentially came from 1991 // an input surface, but we did not propagate it prior to 1992 // API 20. Perhaps check for target SDK version. 1993#if 0 1994 if (info->mData->meta()->findInt64("timeUs", ×tampNs)) { 1995 ALOGV("using buffer PTS of %" PRId64, timestampNs); 1996 timestampNs *= 1000; 1997 } 1998#endif 1999 } 2000 2001 if (mSoftRenderer != NULL) { 2002 mSoftRenderer->render( 2003 info->mData->data(), info->mData->size(), 2004 timestampNs, NULL, info->mFormat); 2005 } 2006 } 2007 2008 info->mNotify->post(); 2009 info->mNotify = NULL; 2010 2011 return OK; 2012} 2013 2014ssize_t MediaCodec::dequeuePortBuffer(int32_t portIndex) { 2015 CHECK(portIndex == kPortIndexInput || portIndex == kPortIndexOutput); 2016 2017 List<size_t> *availBuffers = &mAvailPortBuffers[portIndex]; 2018 2019 if (availBuffers->empty()) { 2020 return -EAGAIN; 2021 } 2022 2023 size_t index = *availBuffers->begin(); 2024 availBuffers->erase(availBuffers->begin()); 2025 2026 BufferInfo *info = &mPortBuffers[portIndex].editItemAt(index); 2027 CHECK(!info->mOwnedByClient); 2028 { 2029 Mutex::Autolock al(mBufferLock); 2030 info->mOwnedByClient = true; 2031 2032 // set image-data 2033 if (info->mFormat != NULL) { 2034 sp<ABuffer> imageData; 2035 if (info->mFormat->findBuffer("image-data", &imageData)) { 2036 info->mData->meta()->setBuffer("image-data", imageData); 2037 } 2038 int32_t left, top, right, bottom; 2039 if (info->mFormat->findRect("crop", &left, &top, &right, &bottom)) { 2040 info->mData->meta()->setRect("crop-rect", left, top, right, bottom); 2041 } 2042 } 2043 } 2044 2045 return index; 2046} 2047 2048status_t MediaCodec::setNativeWindow( 2049 const sp<Surface> &surfaceTextureClient) { 2050 status_t err; 2051 2052 if (mNativeWindow != NULL) { 2053 err = native_window_api_disconnect( 2054 mNativeWindow.get(), NATIVE_WINDOW_API_MEDIA); 2055 2056 if (err != OK) { 2057 ALOGW("native_window_api_disconnect returned an error: %s (%d)", 2058 strerror(-err), err); 2059 } 2060 2061 mNativeWindow.clear(); 2062 } 2063 2064 if (surfaceTextureClient != NULL) { 2065 err = native_window_api_connect( 2066 surfaceTextureClient.get(), NATIVE_WINDOW_API_MEDIA); 2067 2068 if (err != OK) { 2069 ALOGE("native_window_api_connect returned an error: %s (%d)", 2070 strerror(-err), err); 2071 2072 return err; 2073 } 2074 2075 mNativeWindow = surfaceTextureClient; 2076 } 2077 2078 return OK; 2079} 2080 2081void MediaCodec::onInputBufferAvailable() { 2082 int32_t index; 2083 while ((index = dequeuePortBuffer(kPortIndexInput)) >= 0) { 2084 sp<AMessage> msg = mCallback->dup(); 2085 msg->setInt32("callbackID", CB_INPUT_AVAILABLE); 2086 msg->setInt32("index", index); 2087 msg->post(); 2088 } 2089} 2090 2091void MediaCodec::onOutputBufferAvailable() { 2092 int32_t index; 2093 while ((index = dequeuePortBuffer(kPortIndexOutput)) >= 0) { 2094 const sp<ABuffer> &buffer = 2095 mPortBuffers[kPortIndexOutput].itemAt(index).mData; 2096 sp<AMessage> msg = mCallback->dup(); 2097 msg->setInt32("callbackID", CB_OUTPUT_AVAILABLE); 2098 msg->setInt32("index", index); 2099 msg->setSize("offset", buffer->offset()); 2100 msg->setSize("size", buffer->size()); 2101 2102 int64_t timeUs; 2103 CHECK(buffer->meta()->findInt64("timeUs", &timeUs)); 2104 2105 msg->setInt64("timeUs", timeUs); 2106 2107 int32_t omxFlags; 2108 CHECK(buffer->meta()->findInt32("omxFlags", &omxFlags)); 2109 2110 uint32_t flags = 0; 2111 if (omxFlags & OMX_BUFFERFLAG_SYNCFRAME) { 2112 flags |= BUFFER_FLAG_SYNCFRAME; 2113 } 2114 if (omxFlags & OMX_BUFFERFLAG_CODECCONFIG) { 2115 flags |= BUFFER_FLAG_CODECCONFIG; 2116 } 2117 if (omxFlags & OMX_BUFFERFLAG_EOS) { 2118 flags |= BUFFER_FLAG_EOS; 2119 } 2120 2121 msg->setInt32("flags", flags); 2122 2123 msg->post(); 2124 } 2125} 2126 2127void MediaCodec::onError(status_t err, int32_t actionCode, const char *detail) { 2128 if (mCallback != NULL) { 2129 sp<AMessage> msg = mCallback->dup(); 2130 msg->setInt32("callbackID", CB_ERROR); 2131 msg->setInt32("err", err); 2132 msg->setInt32("actionCode", actionCode); 2133 2134 if (detail != NULL) { 2135 msg->setString("detail", detail); 2136 } 2137 2138 msg->post(); 2139 } 2140} 2141 2142void MediaCodec::onOutputFormatChanged() { 2143 if (mCallback != NULL) { 2144 sp<AMessage> msg = mCallback->dup(); 2145 msg->setInt32("callbackID", CB_OUTPUT_FORMAT_CHANGED); 2146 msg->setMessage("format", mOutputFormat); 2147 msg->post(); 2148 } 2149} 2150 2151 2152void MediaCodec::postActivityNotificationIfPossible() { 2153 if (mActivityNotify == NULL) { 2154 return; 2155 } 2156 2157 bool isErrorOrOutputChanged = 2158 (mFlags & (kFlagStickyError 2159 | kFlagOutputBuffersChanged 2160 | kFlagOutputFormatChanged)); 2161 2162 if (isErrorOrOutputChanged 2163 || !mAvailPortBuffers[kPortIndexInput].empty() 2164 || !mAvailPortBuffers[kPortIndexOutput].empty()) { 2165 mActivityNotify->setInt32("input-buffers", 2166 mAvailPortBuffers[kPortIndexInput].size()); 2167 2168 if (isErrorOrOutputChanged) { 2169 // we want consumer to dequeue as many times as it can 2170 mActivityNotify->setInt32("output-buffers", INT32_MAX); 2171 } else { 2172 mActivityNotify->setInt32("output-buffers", 2173 mAvailPortBuffers[kPortIndexOutput].size()); 2174 } 2175 mActivityNotify->post(); 2176 mActivityNotify.clear(); 2177 } 2178} 2179 2180status_t MediaCodec::setParameters(const sp<AMessage> ¶ms) { 2181 sp<AMessage> msg = new AMessage(kWhatSetParameters, id()); 2182 msg->setMessage("params", params); 2183 2184 sp<AMessage> response; 2185 return PostAndAwaitResponse(msg, &response); 2186} 2187 2188status_t MediaCodec::onSetParameters(const sp<AMessage> ¶ms) { 2189 mCodec->signalSetParameters(params); 2190 2191 return OK; 2192} 2193 2194status_t MediaCodec::amendOutputFormatWithCodecSpecificData( 2195 const sp<ABuffer> &buffer) { 2196 AString mime; 2197 CHECK(mOutputFormat->findString("mime", &mime)); 2198 2199 if (!strcasecmp(mime.c_str(), MEDIA_MIMETYPE_VIDEO_AVC)) { 2200 // Codec specific data should be SPS and PPS in a single buffer, 2201 // each prefixed by a startcode (0x00 0x00 0x00 0x01). 2202 // We separate the two and put them into the output format 2203 // under the keys "csd-0" and "csd-1". 2204 2205 unsigned csdIndex = 0; 2206 2207 const uint8_t *data = buffer->data(); 2208 size_t size = buffer->size(); 2209 2210 const uint8_t *nalStart; 2211 size_t nalSize; 2212 while (getNextNALUnit(&data, &size, &nalStart, &nalSize, true) == OK) { 2213 sp<ABuffer> csd = new ABuffer(nalSize + 4); 2214 memcpy(csd->data(), "\x00\x00\x00\x01", 4); 2215 memcpy(csd->data() + 4, nalStart, nalSize); 2216 2217 mOutputFormat->setBuffer( 2218 StringPrintf("csd-%u", csdIndex).c_str(), csd); 2219 2220 ++csdIndex; 2221 } 2222 2223 if (csdIndex != 2) { 2224 return ERROR_MALFORMED; 2225 } 2226 } else { 2227 // For everything else we just stash the codec specific data into 2228 // the output format as a single piece of csd under "csd-0". 2229 mOutputFormat->setBuffer("csd-0", buffer); 2230 } 2231 2232 return OK; 2233} 2234 2235void MediaCodec::updateBatteryStat() { 2236 if (mState == CONFIGURED && !mBatteryStatNotified) { 2237 AString mime; 2238 CHECK(mOutputFormat != NULL && 2239 mOutputFormat->findString("mime", &mime)); 2240 2241 mIsVideo = mime.startsWithIgnoreCase("video/"); 2242 2243 BatteryNotifier& notifier(BatteryNotifier::getInstance()); 2244 2245 if (mIsVideo) { 2246 notifier.noteStartVideo(); 2247 } else { 2248 notifier.noteStartAudio(); 2249 } 2250 2251 mBatteryStatNotified = true; 2252 } else if (mState == UNINITIALIZED && mBatteryStatNotified) { 2253 BatteryNotifier& notifier(BatteryNotifier::getInstance()); 2254 2255 if (mIsVideo) { 2256 notifier.noteStopVideo(); 2257 } else { 2258 notifier.noteStopAudio(); 2259 } 2260 2261 mBatteryStatNotified = false; 2262 } 2263} 2264 2265} // namespace android 2266