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