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