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