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