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