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