1 /* 2 * Copyright (C) 2009 The Android Open Source Project 3 * 4 * Licensed under the Apache License, Version 2.0 (the "License"); 5 * you may not use this file except in compliance with the License. 6 * You may obtain a copy of the License at 7 * 8 * http://www.apache.org/licenses/LICENSE-2.0 9 * 10 * Unless required by applicable law or agreed to in writing, software 11 * distributed under the License is distributed on an "AS IS" BASIS, 12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13 * See the License for the specific language governing permissions and 14 * limitations under the License. 15 */ 16 17 //#define LOG_NDEBUG 0 18 #define LOG_TAG "OMXHarness" 19 #include <inttypes.h> 20 #include <android-base/macros.h> 21 #include <utils/Log.h> 22 23 #include "OMXHarness.h" 24 25 #include <sys/time.h> 26 27 #include <binder/ProcessState.h> 28 #include <binder/IServiceManager.h> 29 #include <cutils/properties.h> 30 #include <datasource/DataSourceFactory.h> 31 #include <media/DataSource.h> 32 #include <media/IMediaHTTPService.h> 33 #include <media/stagefright/MediaSource.h> 34 #include <media/OMXBuffer.h> 35 #include <media/stagefright/foundation/ADebug.h> 36 #include <media/stagefright/foundation/ALooper.h> 37 #include <media/stagefright/InterfaceUtils.h> 38 #include <media/stagefright/MediaBuffer.h> 39 #include <media/stagefright/MediaDefs.h> 40 #include <media/stagefright/MediaErrors.h> 41 #include <media/stagefright/MediaExtractorFactory.h> 42 #include <media/stagefright/MetaData.h> 43 #include <media/stagefright/OMXClient.h> 44 #include <media/stagefright/SimpleDecodingSource.h> 45 #include <system/window.h> 46 47 #define DEFAULT_TIMEOUT 500000 48 49 namespace android { 50 51 ///////////////////////////////////////////////////////////////////// 52 53 struct Harness::CodecObserver : public BnOMXObserver { CodecObserverandroid::Harness::CodecObserver54 CodecObserver(const sp<Harness> &harness, int32_t gen) 55 : mHarness(harness), mGeneration(gen) {} 56 57 void onMessages(const std::list<omx_message> &messages) override; 58 59 private: 60 sp<Harness> mHarness; 61 int32_t mGeneration; 62 }; 63 onMessages(const std::list<omx_message> & messages)64 void Harness::CodecObserver::onMessages(const std::list<omx_message> &messages) { 65 mHarness->handleMessages(mGeneration, messages); 66 } 67 68 ///////////////////////////////////////////////////////////////////// 69 Harness()70 Harness::Harness() 71 : mInitCheck(NO_INIT) { 72 mInitCheck = initOMX(); 73 } 74 ~Harness()75 Harness::~Harness() { 76 } 77 initCheck() const78 status_t Harness::initCheck() const { 79 return mInitCheck; 80 } 81 initOMX()82 status_t Harness::initOMX() { 83 OMXClient client; 84 if (client.connect() != OK) { 85 ALOGE("Failed to connect to OMX to create persistent input surface."); 86 return NO_INIT; 87 } 88 89 mOMX = client.interface(); 90 91 return mOMX != 0 ? OK : NO_INIT; 92 } 93 handleMessages(int32_t gen,const std::list<omx_message> & messages)94 void Harness::handleMessages(int32_t gen, const std::list<omx_message> &messages) { 95 Mutex::Autolock autoLock(mLock); 96 for (std::list<omx_message>::const_iterator it = messages.cbegin(); it != messages.cend(); ) { 97 mMessageQueue.push_back(*it++); 98 mLastMsgGeneration = gen; 99 } 100 mMessageAddedCondition.signal(); 101 } 102 dequeueMessageForNode(omx_message * msg,int64_t timeoutUs)103 status_t Harness::dequeueMessageForNode(omx_message *msg, int64_t timeoutUs) { 104 return dequeueMessageForNodeIgnoringBuffers(NULL, NULL, msg, timeoutUs); 105 } 106 107 // static handleBufferMessage(const omx_message & msg,Vector<Buffer> * inputBuffers,Vector<Buffer> * outputBuffers)108 bool Harness::handleBufferMessage( 109 const omx_message &msg, 110 Vector<Buffer> *inputBuffers, 111 Vector<Buffer> *outputBuffers) { 112 switch (msg.type) { 113 case omx_message::EMPTY_BUFFER_DONE: 114 { 115 if (inputBuffers) { 116 for (size_t i = 0; i < inputBuffers->size(); ++i) { 117 if ((*inputBuffers)[i].mID == msg.u.buffer_data.buffer) { 118 inputBuffers->editItemAt(i).mFlags &= ~kBufferBusy; 119 return true; 120 } 121 } 122 CHECK(!"should not be here"); 123 } 124 break; 125 } 126 127 case omx_message::FILL_BUFFER_DONE: 128 { 129 if (outputBuffers) { 130 for (size_t i = 0; i < outputBuffers->size(); ++i) { 131 if ((*outputBuffers)[i].mID == msg.u.buffer_data.buffer) { 132 outputBuffers->editItemAt(i).mFlags &= ~kBufferBusy; 133 return true; 134 } 135 } 136 CHECK(!"should not be here"); 137 } 138 break; 139 } 140 141 default: 142 break; 143 } 144 145 return false; 146 } 147 dequeueMessageForNodeIgnoringBuffers(Vector<Buffer> * inputBuffers,Vector<Buffer> * outputBuffers,omx_message * msg,int64_t timeoutUs)148 status_t Harness::dequeueMessageForNodeIgnoringBuffers( 149 Vector<Buffer> *inputBuffers, 150 Vector<Buffer> *outputBuffers, 151 omx_message *msg, int64_t timeoutUs) { 152 int64_t finishBy = ALooper::GetNowUs() + timeoutUs; 153 154 for (;;) { 155 Mutex::Autolock autoLock(mLock); 156 // Messages are queued in batches, if the last batch queued is 157 // from a node that already expired, discard those messages. 158 if (mLastMsgGeneration < mCurGeneration) { 159 mMessageQueue.clear(); 160 } 161 List<omx_message>::iterator it = mMessageQueue.begin(); 162 while (it != mMessageQueue.end()) { 163 if (handleBufferMessage(*it, inputBuffers, outputBuffers)) { 164 it = mMessageQueue.erase(it); 165 continue; 166 } 167 168 *msg = *it; 169 mMessageQueue.erase(it); 170 171 return OK; 172 } 173 174 status_t err = (timeoutUs < 0) 175 ? mMessageAddedCondition.wait(mLock) 176 : mMessageAddedCondition.waitRelative( 177 mLock, (finishBy - ALooper::GetNowUs()) * 1000); 178 179 if (err == TIMED_OUT) { 180 return err; 181 } 182 CHECK_EQ(err, (status_t)OK); 183 } 184 } 185 getPortDefinition(OMX_U32 portIndex,OMX_PARAM_PORTDEFINITIONTYPE * def)186 status_t Harness::getPortDefinition( 187 OMX_U32 portIndex, OMX_PARAM_PORTDEFINITIONTYPE *def) { 188 def->nSize = sizeof(*def); 189 def->nVersion.s.nVersionMajor = 1; 190 def->nVersion.s.nVersionMinor = 0; 191 def->nVersion.s.nRevision = 0; 192 def->nVersion.s.nStep = 0; 193 def->nPortIndex = portIndex; 194 return mOMXNode->getParameter( 195 OMX_IndexParamPortDefinition, def, sizeof(*def)); 196 } 197 198 #define EXPECT(condition, info) \ 199 if (!(condition)) { \ 200 ALOGE(info); printf("\n * " info "\n"); return UNKNOWN_ERROR; \ 201 } 202 203 #define EXPECT_SUCCESS(err, info) \ 204 EXPECT((err) == OK, info " failed") 205 allocatePortBuffers(OMX_U32 portIndex,Vector<Buffer> * buffers)206 status_t Harness::allocatePortBuffers( 207 OMX_U32 portIndex, Vector<Buffer> *buffers) { 208 buffers->clear(); 209 210 OMX_PARAM_PORTDEFINITIONTYPE def; 211 status_t err = getPortDefinition(portIndex, &def); 212 EXPECT_SUCCESS(err, "getPortDefinition"); 213 214 switch (def.eDomain) { 215 case OMX_PortDomainVideo: 216 EXPECT(def.format.video.cMIMEType == 0, "portDefinition video MIME"); 217 break; 218 case OMX_PortDomainAudio: 219 EXPECT(def.format.audio.cMIMEType == 0, "portDefinition audio MIME"); 220 break; 221 default: 222 break; 223 } 224 225 for (OMX_U32 i = 0; i < def.nBufferCountActual; ++i) { 226 Buffer buffer; 227 buffer.mFlags = 0; 228 bool success; 229 auto transStatus = mAllocator->allocate(def.nBufferSize, 230 [&success, &buffer]( 231 bool s, 232 hidl_memory const& m) { 233 success = s; 234 buffer.mHidlMemory = m; 235 }); 236 EXPECT(transStatus.isOk(), 237 "Cannot call allocator"); 238 EXPECT(success, 239 "Cannot allocate memory"); 240 err = mOMXNode->useBuffer(portIndex, buffer.mHidlMemory, &buffer.mID); 241 242 EXPECT_SUCCESS(err, "useBuffer"); 243 244 buffers->push(buffer); 245 } 246 247 return OK; 248 } 249 setRole(const char * role)250 status_t Harness::setRole(const char *role) { 251 OMX_PARAM_COMPONENTROLETYPE params; 252 params.nSize = sizeof(params); 253 params.nVersion.s.nVersionMajor = 1; 254 params.nVersion.s.nVersionMinor = 0; 255 params.nVersion.s.nRevision = 0; 256 params.nVersion.s.nStep = 0; 257 strncpy((char *)params.cRole, role, OMX_MAX_STRINGNAME_SIZE - 1); 258 params.cRole[OMX_MAX_STRINGNAME_SIZE - 1] = '\0'; 259 260 return mOMXNode->setParameter( 261 OMX_IndexParamStandardComponentRole, 262 ¶ms, sizeof(params)); 263 } 264 265 struct NodeReaper { NodeReaperandroid::NodeReaper266 NodeReaper(const sp<Harness> &harness, const sp<IOMXNode> &omxNode) 267 : mHarness(harness), 268 mOMXNode(omxNode) { 269 } 270 ~NodeReaperandroid::NodeReaper271 ~NodeReaper() { 272 if (mOMXNode != 0) { 273 mOMXNode->freeNode(); 274 mOMXNode = NULL; 275 } 276 } 277 disarmandroid::NodeReaper278 void disarm() { 279 mOMXNode = NULL; 280 } 281 282 private: 283 sp<Harness> mHarness; 284 sp<IOMXNode> mOMXNode; 285 286 NodeReaper(const NodeReaper &); 287 NodeReaper &operator=(const NodeReaper &); 288 }; 289 CreateExtractorFromURI(const char * uri)290 static sp<IMediaExtractor> CreateExtractorFromURI(const char *uri) { 291 sp<DataSource> source = 292 DataSourceFactory::getInstance()->CreateFromURI(NULL /* httpService */, uri); 293 294 if (source == NULL) { 295 return NULL; 296 } 297 298 return MediaExtractorFactory::Create(source); 299 } 300 testStateTransitions(const char * componentName,const char * componentRole)301 status_t Harness::testStateTransitions( 302 const char *componentName, const char *componentRole) { 303 if (strncmp(componentName, "OMX.", 4)) { 304 // Non-OMX components, i.e. software decoders won't execute this 305 // test. 306 return OK; 307 } 308 309 mAllocator = IAllocator::getService("ashmem"); 310 EXPECT(mAllocator != nullptr, 311 "Cannot obtain hidl AshmemAllocator"); 312 // TODO: When Treble has MemoryHeap/MemoryDealer, we should specify the heap 313 // size to be 16 * 1024 * 1024. 314 315 sp<CodecObserver> observer = new CodecObserver(this, ++mCurGeneration); 316 317 status_t err = mOMX->allocateNode(componentName, observer, &mOMXNode); 318 EXPECT_SUCCESS(err, "allocateNode"); 319 320 NodeReaper reaper(this, mOMXNode); 321 322 err = setRole(componentRole); 323 EXPECT_SUCCESS(err, "setRole"); 324 325 // Initiate transition Loaded->Idle 326 err = mOMXNode->sendCommand(OMX_CommandStateSet, OMX_StateIdle); 327 EXPECT_SUCCESS(err, "sendCommand(go-to-Idle)"); 328 329 omx_message msg; 330 err = dequeueMessageForNode(&msg, DEFAULT_TIMEOUT); 331 // Make sure node doesn't just transition to idle before we are done 332 // allocating all input and output buffers. 333 EXPECT(err == TIMED_OUT, 334 "Component must not transition from loaded to idle before " 335 "all input and output buffers are allocated."); 336 337 // Now allocate buffers. 338 Vector<Buffer> inputBuffers; 339 err = allocatePortBuffers(0, &inputBuffers); 340 EXPECT_SUCCESS(err, "allocatePortBuffers(input)"); 341 342 err = dequeueMessageForNode(&msg, DEFAULT_TIMEOUT); 343 CHECK_EQ(err, (status_t)TIMED_OUT); 344 345 Vector<Buffer> outputBuffers; 346 err = allocatePortBuffers(1, &outputBuffers); 347 EXPECT_SUCCESS(err, "allocatePortBuffers(output)"); 348 349 err = dequeueMessageForNode(&msg, DEFAULT_TIMEOUT); 350 EXPECT(err == OK 351 && msg.type == omx_message::EVENT 352 && msg.u.event_data.event == OMX_EventCmdComplete 353 && msg.u.event_data.data1 == OMX_CommandStateSet 354 && msg.u.event_data.data2 == OMX_StateIdle, 355 "Component did not properly transition to idle state " 356 "after all input and output buffers were allocated."); 357 358 // Initiate transition Idle->Executing 359 err = mOMXNode->sendCommand(OMX_CommandStateSet, OMX_StateExecuting); 360 EXPECT_SUCCESS(err, "sendCommand(go-to-Executing)"); 361 362 err = dequeueMessageForNode(&msg, DEFAULT_TIMEOUT); 363 EXPECT(err == OK 364 && msg.type == omx_message::EVENT 365 && msg.u.event_data.event == OMX_EventCmdComplete 366 && msg.u.event_data.data1 == OMX_CommandStateSet 367 && msg.u.event_data.data2 == OMX_StateExecuting, 368 "Component did not properly transition from idle to " 369 "executing state."); 370 371 for (size_t i = 0; i < outputBuffers.size(); ++i) { 372 err = mOMXNode->fillBuffer(outputBuffers[i].mID, OMXBuffer::sPreset); 373 EXPECT_SUCCESS(err, "fillBuffer"); 374 375 outputBuffers.editItemAt(i).mFlags |= kBufferBusy; 376 } 377 378 err = mOMXNode->sendCommand(OMX_CommandFlush, 1); 379 EXPECT_SUCCESS(err, "sendCommand(flush-output-port)"); 380 381 err = dequeueMessageForNodeIgnoringBuffers( 382 &inputBuffers, &outputBuffers, &msg, DEFAULT_TIMEOUT); 383 EXPECT(err == OK 384 && msg.type == omx_message::EVENT 385 && msg.u.event_data.event == OMX_EventCmdComplete 386 && msg.u.event_data.data1 == OMX_CommandFlush 387 && msg.u.event_data.data2 == 1, 388 "Component did not properly acknowledge flushing the output port."); 389 390 for (size_t i = 0; i < outputBuffers.size(); ++i) { 391 EXPECT((outputBuffers[i].mFlags & kBufferBusy) == 0, 392 "Not all output buffers have been returned to us by the time " 393 "we received the flush-complete notification."); 394 } 395 396 for (size_t i = 0; i < outputBuffers.size(); ++i) { 397 err = mOMXNode->fillBuffer(outputBuffers[i].mID, OMXBuffer::sPreset); 398 EXPECT_SUCCESS(err, "fillBuffer"); 399 400 outputBuffers.editItemAt(i).mFlags |= kBufferBusy; 401 } 402 403 // Initiate transition Executing->Idle 404 err = mOMXNode->sendCommand(OMX_CommandStateSet, OMX_StateIdle); 405 EXPECT_SUCCESS(err, "sendCommand(go-to-Idle)"); 406 407 err = dequeueMessageForNodeIgnoringBuffers( 408 &inputBuffers, &outputBuffers, &msg, DEFAULT_TIMEOUT); 409 EXPECT(err == OK 410 && msg.type == omx_message::EVENT 411 && msg.u.event_data.event == OMX_EventCmdComplete 412 && msg.u.event_data.data1 == OMX_CommandStateSet 413 && msg.u.event_data.data2 == OMX_StateIdle, 414 "Component did not properly transition to from executing to " 415 "idle state."); 416 417 for (size_t i = 0; i < inputBuffers.size(); ++i) { 418 EXPECT((inputBuffers[i].mFlags & kBufferBusy) == 0, 419 "Not all input buffers have been returned to us by the " 420 "time we received the transition-to-idle complete " 421 "notification."); 422 } 423 424 for (size_t i = 0; i < outputBuffers.size(); ++i) { 425 EXPECT((outputBuffers[i].mFlags & kBufferBusy) == 0, 426 "Not all output buffers have been returned to us by the " 427 "time we received the transition-to-idle complete " 428 "notification."); 429 } 430 431 // Initiate transition Idle->Loaded 432 err = mOMXNode->sendCommand(OMX_CommandStateSet, OMX_StateLoaded); 433 EXPECT_SUCCESS(err, "sendCommand(go-to-Loaded)"); 434 435 // Make sure node doesn't just transition to loaded before we are done 436 // freeing all input and output buffers. 437 err = dequeueMessageForNode(&msg, DEFAULT_TIMEOUT); 438 CHECK_EQ(err, (status_t)TIMED_OUT); 439 440 for (size_t i = 0; i < inputBuffers.size(); ++i) { 441 err = mOMXNode->freeBuffer(0, inputBuffers[i].mID); 442 EXPECT_SUCCESS(err, "freeBuffer"); 443 } 444 445 err = dequeueMessageForNode(&msg, DEFAULT_TIMEOUT); 446 CHECK_EQ(err, (status_t)TIMED_OUT); 447 448 for (size_t i = 0; i < outputBuffers.size(); ++i) { 449 err = mOMXNode->freeBuffer(1, outputBuffers[i].mID); 450 EXPECT_SUCCESS(err, "freeBuffer"); 451 } 452 453 err = dequeueMessageForNode(&msg, DEFAULT_TIMEOUT); 454 EXPECT(err == OK 455 && msg.type == omx_message::EVENT 456 && msg.u.event_data.event == OMX_EventCmdComplete 457 && msg.u.event_data.data1 == OMX_CommandStateSet 458 && msg.u.event_data.data2 == OMX_StateLoaded, 459 "Component did not properly transition to from idle to " 460 "loaded state after freeing all input and output buffers."); 461 462 err = mOMXNode->freeNode(); 463 EXPECT_SUCCESS(err, "freeNode"); 464 465 reaper.disarm(); 466 467 mOMXNode = NULL; 468 469 return OK; 470 } 471 GetMimeFromComponentRole(const char * componentRole)472 static const char *GetMimeFromComponentRole(const char *componentRole) { 473 struct RoleToMime { 474 const char *mRole; 475 const char *mMime; 476 }; 477 const RoleToMime kRoleToMime[] = { 478 { "video_decoder.avc", "video/avc" }, 479 { "video_decoder.mpeg4", "video/mp4v-es" }, 480 { "video_decoder.h263", "video/3gpp" }, 481 { "video_decoder.vp8", "video/x-vnd.on2.vp8" }, 482 { "video_decoder.vp9", "video/x-vnd.on2.vp9" }, 483 484 // we appear to use this as a synonym to amrnb. 485 { "audio_decoder.amr", "audio/3gpp" }, 486 487 { "audio_decoder.amrnb", "audio/3gpp" }, 488 { "audio_decoder.amrwb", "audio/amr-wb" }, 489 { "audio_decoder.aac", "audio/mp4a-latm" }, 490 { "audio_decoder.mp3", "audio/mpeg" }, 491 { "audio_decoder.vorbis", "audio/vorbis" }, 492 { "audio_decoder.opus", "audio/opus" }, 493 { "audio_decoder.g711alaw", MEDIA_MIMETYPE_AUDIO_G711_ALAW }, 494 { "audio_decoder.g711mlaw", MEDIA_MIMETYPE_AUDIO_G711_MLAW }, 495 }; 496 497 for (size_t i = 0; i < sizeof(kRoleToMime) / sizeof(kRoleToMime[0]); ++i) { 498 if (!strcmp(componentRole, kRoleToMime[i].mRole)) { 499 return kRoleToMime[i].mMime; 500 } 501 } 502 503 return NULL; 504 } 505 GetURLForMime(const char * mime)506 static const char *GetURLForMime(const char *mime) { 507 struct MimeToURL { 508 const char *mMime; 509 const char *mURL; 510 }; 511 static const MimeToURL kMimeToURL[] = { 512 { "video/avc", 513 "file:///sdcard/media_api/video/H264_500_AAC_128.3gp" }, 514 { "video/mp4v-es", "file:///sdcard/media_api/video/MPEG4_320_AAC_64.mp4" }, 515 { "video/3gpp", 516 "file:///sdcard/media_api/video/H263_500_AMRNB_12.3gp" }, 517 { "audio/3gpp", 518 "file:///sdcard/media_api/video/H263_500_AMRNB_12.3gp" }, 519 { "audio/amr-wb", NULL }, 520 { "audio/mp4a-latm", 521 "file:///sdcard/media_api/video/H263_56_AAC_24.3gp" }, 522 { "audio/mpeg", 523 "file:///sdcard/media_api/music/MP3_48KHz_128kbps_s_1_17_CBR.mp3" }, 524 { "audio/vorbis", NULL }, 525 { "audio/opus", NULL }, 526 { "video/x-vnd.on2.vp8", 527 "file:///sdcard/media_api/video/big-buck-bunny_trailer.webm" }, 528 { MEDIA_MIMETYPE_AUDIO_G711_ALAW, "file:///sdcard/M1F1-Alaw-AFsp.wav" }, 529 { MEDIA_MIMETYPE_AUDIO_G711_MLAW, 530 "file:///sdcard/M1F1-mulaw-AFsp.wav" }, 531 }; 532 533 for (size_t i = 0; i < sizeof(kMimeToURL) / sizeof(kMimeToURL[0]); ++i) { 534 if (!strcasecmp(kMimeToURL[i].mMime, mime)) { 535 return kMimeToURL[i].mURL; 536 } 537 } 538 539 return NULL; 540 } 541 CreateSourceForMime(const char * mime)542 static sp<MediaSource> CreateSourceForMime(const char *mime) { 543 const char *url = GetURLForMime(mime); 544 545 if (url == NULL) { 546 return NULL; 547 } 548 549 sp<IMediaExtractor> extractor = CreateExtractorFromURI(url); 550 551 if (extractor == NULL) { 552 return NULL; 553 } 554 555 for (size_t i = 0; i < extractor->countTracks(); ++i) { 556 sp<MetaData> meta = extractor->getTrackMetaData(i); 557 CHECK(meta != NULL); 558 559 const char *trackMime; 560 CHECK(meta->findCString(kKeyMIMEType, &trackMime)); 561 562 if (!strcasecmp(mime, trackMime)) { 563 return CreateMediaSourceFromIMediaSource(extractor->getTrack(i)); 564 } 565 } 566 567 return NULL; 568 } 569 uniform_rand()570 static double uniform_rand() { 571 return (double)rand() / RAND_MAX; 572 } 573 CloseEnough(int64_t time1Us,int64_t time2Us)574 static bool CloseEnough(int64_t time1Us, int64_t time2Us) { 575 #if 0 576 int64_t diff = time1Us - time2Us; 577 if (diff < 0) { 578 diff = -diff; 579 } 580 581 return diff <= 50000; 582 #else 583 return time1Us == time2Us; 584 #endif 585 } 586 testSeek(const char * componentName,const char * componentRole)587 status_t Harness::testSeek( 588 const char *componentName, const char *componentRole) { 589 bool isEncoder = 590 !strncmp(componentRole, "audio_encoder.", 14) 591 || !strncmp(componentRole, "video_encoder.", 14); 592 593 if (isEncoder) { 594 // Not testing seek behaviour for encoders. 595 596 printf(" * Not testing seek functionality for encoders.\n"); 597 return OK; 598 } 599 600 const char *mime = GetMimeFromComponentRole(componentRole); 601 602 if (!mime) { 603 printf(" * Cannot perform seek test with this componentRole (%s)\n", 604 componentRole); 605 606 return OK; 607 } 608 609 sp<MediaSource> source = CreateSourceForMime(mime); 610 611 if (source == NULL) { 612 printf(" * Unable to open test content for type '%s', " 613 "skipping test of componentRole %s\n", 614 mime, componentRole); 615 616 return OK; 617 } 618 619 sp<MediaSource> seekSource = CreateSourceForMime(mime); 620 if (source == NULL || seekSource == NULL) { 621 return UNKNOWN_ERROR; 622 } 623 624 CHECK_EQ(seekSource->start(), (status_t)OK); 625 626 sp<MediaSource> codec = SimpleDecodingSource::Create( 627 source, 0 /* flags */, NULL /* nativeWindow */, componentName); 628 629 CHECK(codec != NULL); 630 631 CHECK_EQ(codec->start(), (status_t)OK); 632 633 int64_t durationUs; 634 CHECK(source->getFormat()->findInt64(kKeyDuration, &durationUs)); 635 636 ALOGI("stream duration is %lld us (%.2f secs)", 637 durationUs, durationUs / 1E6); 638 639 static const int32_t kNumIterations = 5000; 640 641 // We are always going to seek beyond EOS in the first iteration (i == 0) 642 // followed by a linear read for the second iteration (i == 1). 643 // After that it's all random. 644 for (int32_t i = 0; i < kNumIterations; ++i) { 645 int64_t requestedSeekTimeUs; 646 int64_t actualSeekTimeUs; 647 MediaSource::ReadOptions options; 648 649 double r = uniform_rand(); 650 651 if ((i == 1) || (i > 0 && r < 0.5)) { 652 // 50% chance of just continuing to decode from last position. 653 654 requestedSeekTimeUs = -1; 655 656 ALOGI("requesting linear read"); 657 } else { 658 if (i == 0 || r < 0.55) { 659 // 5% chance of seeking beyond end of stream. 660 661 requestedSeekTimeUs = durationUs; 662 663 ALOGI("requesting seek beyond EOF"); 664 } else { 665 requestedSeekTimeUs = 666 (int64_t)(uniform_rand() * durationUs); 667 668 ALOGI("requesting seek to %lld us (%.2f secs)", 669 requestedSeekTimeUs, requestedSeekTimeUs / 1E6); 670 } 671 672 MediaBufferBase *buffer = NULL; 673 options.setSeekTo( 674 requestedSeekTimeUs, MediaSource::ReadOptions::SEEK_NEXT_SYNC); 675 676 if (seekSource->read(&buffer, &options) != OK) { 677 CHECK(buffer == NULL); 678 actualSeekTimeUs = -1; 679 } else { 680 CHECK(buffer != NULL); 681 CHECK(buffer->meta_data().findInt64(kKeyTime, &actualSeekTimeUs)); 682 CHECK(actualSeekTimeUs >= 0); 683 684 buffer->release(); 685 buffer = NULL; 686 } 687 688 ALOGI("nearest keyframe is at %lld us (%.2f secs)", 689 actualSeekTimeUs, actualSeekTimeUs / 1E6); 690 } 691 692 status_t err; 693 MediaBufferBase *buffer; 694 for (;;) { 695 err = codec->read(&buffer, &options); 696 options.clearSeekTo(); 697 if (err == INFO_FORMAT_CHANGED) { 698 CHECK(buffer == NULL); 699 continue; 700 } 701 if (err == OK) { 702 CHECK(buffer != NULL); 703 if (buffer->range_length() == 0) { 704 buffer->release(); 705 buffer = NULL; 706 continue; 707 } 708 } else { 709 CHECK(buffer == NULL); 710 } 711 712 break; 713 } 714 715 if (requestedSeekTimeUs < 0) { 716 // Linear read. 717 if (err != OK) { 718 CHECK(buffer == NULL); 719 } else { 720 CHECK(buffer != NULL); 721 buffer->release(); 722 buffer = NULL; 723 } 724 } else if (actualSeekTimeUs < 0) { 725 EXPECT(err != OK, 726 "We attempted to seek beyond EOS and expected " 727 "ERROR_END_OF_STREAM to be returned, but instead " 728 "we got a valid buffer."); 729 EXPECT(err == ERROR_END_OF_STREAM, 730 "We attempted to seek beyond EOS and expected " 731 "ERROR_END_OF_STREAM to be returned, but instead " 732 "we found some other error."); 733 CHECK_EQ(err, (status_t)ERROR_END_OF_STREAM); 734 CHECK(buffer == NULL); 735 } else { 736 EXPECT(err == OK, 737 "Expected a valid buffer to be returned from " 738 "OMXCodec::read."); 739 CHECK(buffer != NULL); 740 741 int64_t bufferTimeUs; 742 CHECK(buffer->meta_data().findInt64(kKeyTime, &bufferTimeUs)); 743 if (!CloseEnough(bufferTimeUs, actualSeekTimeUs)) { 744 printf("\n * Attempted seeking to %" PRId64 " us (%.2f secs)", 745 requestedSeekTimeUs, requestedSeekTimeUs / 1E6); 746 printf("\n * Nearest keyframe is at %" PRId64 " us (%.2f secs)", 747 actualSeekTimeUs, actualSeekTimeUs / 1E6); 748 printf("\n * Returned buffer was at %" PRId64 " us (%.2f secs)\n\n", 749 bufferTimeUs, bufferTimeUs / 1E6); 750 751 buffer->release(); 752 buffer = NULL; 753 754 CHECK_EQ(codec->stop(), (status_t)OK); 755 756 return UNKNOWN_ERROR; 757 } 758 759 buffer->release(); 760 buffer = NULL; 761 } 762 } 763 764 CHECK_EQ(codec->stop(), (status_t)OK); 765 766 return OK; 767 } 768 test(const char * componentName,const char * componentRole)769 status_t Harness::test( 770 const char *componentName, const char *componentRole) { 771 printf("testing %s [%s] ... ", componentName, componentRole); 772 ALOGI("testing %s [%s].", componentName, componentRole); 773 774 status_t err1 = testStateTransitions(componentName, componentRole); 775 status_t err2 = testSeek(componentName, componentRole); 776 777 if (err1 != OK) { 778 return err1; 779 } 780 781 return err2; 782 } 783 testAll()784 status_t Harness::testAll() { 785 List<IOMX::ComponentInfo> componentInfos; 786 status_t err = mOMX->listNodes(&componentInfos); 787 EXPECT_SUCCESS(err, "listNodes"); 788 789 for (List<IOMX::ComponentInfo>::iterator it = componentInfos.begin(); 790 it != componentInfos.end(); ++it) { 791 const IOMX::ComponentInfo &info = *it; 792 const char *componentName = info.mName.string(); 793 794 if (strncmp(componentName, "OMX.google.", 11)) { 795 continue; 796 } 797 798 for (List<String8>::const_iterator role_it = info.mRoles.begin(); 799 role_it != info.mRoles.end(); ++role_it) { 800 const char *componentRole = (*role_it).string(); 801 802 err = test(componentName, componentRole); 803 804 if (err == OK) { 805 printf("OK\n"); 806 } 807 } 808 } 809 810 return OK; 811 } 812 813 } // namespace android 814 usage(const char * me)815 static void usage(const char *me) { 816 fprintf(stderr, "usage: %s\n" 817 " -h(elp) Show this information\n" 818 " -s(eed) Set the random seed\n" 819 " [ component role ]\n\n" 820 "When launched without specifying a specific component " 821 "and role, tool will test all available OMX components " 822 "in all their supported roles. To determine available " 823 "component names, use \"stagefright -l\"\n" 824 "It's also a good idea to run a separate \"adb logcat\"" 825 " for additional debug and progress information.", me); 826 827 exit(0); 828 } 829 main(int argc,char ** argv)830 int main(int argc, char **argv) { 831 using namespace android; 832 833 android::ProcessState::self()->startThreadPool(); 834 835 const char *me = argv[0]; 836 837 unsigned long seed = 0xdeadbeef; 838 839 int res; 840 while ((res = getopt(argc, argv, "hs:")) >= 0) { 841 switch (res) { 842 case 's': 843 { 844 char *end; 845 unsigned long x = strtoul(optarg, &end, 10); 846 847 if (*end != '\0' || end == optarg) { 848 fprintf(stderr, "Malformed seed.\n"); 849 return 1; 850 } 851 852 seed = x; 853 break; 854 } 855 856 case '?': 857 fprintf(stderr, "\n"); 858 FALLTHROUGH_INTENDED; 859 860 case 'h': 861 default: 862 { 863 usage(me); 864 exit(1); 865 break; 866 } 867 } 868 } 869 870 argc -= optind; 871 argv += optind; 872 873 printf("To reproduce the conditions for this test, launch " 874 "with \"%s -s %lu\"\n", me, seed); 875 876 srand(seed); 877 878 sp<Harness> h = new Harness; 879 CHECK_EQ(h->initCheck(), (status_t)OK); 880 881 if (argc == 0) { 882 h->testAll(); 883 } else if (argc == 2) { 884 if (h->test(argv[0], argv[1]) == OK) { 885 printf("OK\n"); 886 } 887 } 888 889 return 0; 890 } 891