OMXHarness.cpp revision 1b86fe063badb5f28c467ade39be0f4008688947 
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/IMediaHTTPService.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            &params, 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 =
246        DataSource::CreateFromURI(NULL /* httpService */, uri);
247
248    if (source == NULL) {
249        return NULL;
250    }
251
252    return MediaExtractor::Create(source);
253}
254
255static sp<MediaSource> MakeSource(
256        const char *uri,
257        const char *mimeType) {
258    sp<MediaExtractor> extractor = CreateExtractorFromURI(uri);
259
260    if (extractor == NULL) {
261        return NULL;
262    }
263
264    for (size_t i = 0; i < extractor->countTracks(); ++i) {
265        sp<MetaData> meta = extractor->getTrackMetaData(i);
266
267        const char *trackMIME;
268        CHECK(meta->findCString(kKeyMIMEType, &trackMIME));
269
270        if (!strcasecmp(trackMIME, mimeType)) {
271            return extractor->getTrack(i);
272        }
273    }
274
275    return NULL;
276}
277
278status_t Harness::testStateTransitions(
279        const char *componentName, const char *componentRole) {
280    if (strncmp(componentName, "OMX.", 4)) {
281        // Non-OMX components, i.e. software decoders won't execute this
282        // test.
283        return OK;
284    }
285
286    sp<MemoryDealer> dealer = new MemoryDealer(16 * 1024 * 1024, "OMXHarness");
287    IOMX::node_id node;
288
289    status_t err =
290        mOMX->allocateNode(componentName, this, &node);
291    EXPECT_SUCCESS(err, "allocateNode");
292
293    NodeReaper reaper(this, node);
294
295    err = setRole(node, componentRole);
296    EXPECT_SUCCESS(err, "setRole");
297
298    // Initiate transition Loaded->Idle
299    err = mOMX->sendCommand(node, OMX_CommandStateSet, OMX_StateIdle);
300    EXPECT_SUCCESS(err, "sendCommand(go-to-Idle)");
301
302    omx_message msg;
303    err = dequeueMessageForNode(node, &msg, DEFAULT_TIMEOUT);
304    // Make sure node doesn't just transition to idle before we are done
305    // allocating all input and output buffers.
306    EXPECT(err == TIMED_OUT,
307            "Component must not transition from loaded to idle before "
308            "all input and output buffers are allocated.");
309
310    // Now allocate buffers.
311    Vector<Buffer> inputBuffers;
312    err = allocatePortBuffers(dealer, node, 0, &inputBuffers);
313    EXPECT_SUCCESS(err, "allocatePortBuffers(input)");
314
315    err = dequeueMessageForNode(node, &msg, DEFAULT_TIMEOUT);
316    CHECK_EQ(err, (status_t)TIMED_OUT);
317
318    Vector<Buffer> outputBuffers;
319    err = allocatePortBuffers(dealer, node, 1, &outputBuffers);
320    EXPECT_SUCCESS(err, "allocatePortBuffers(output)");
321
322    err = dequeueMessageForNode(node, &msg, DEFAULT_TIMEOUT);
323    EXPECT(err == OK
324            && msg.type == omx_message::EVENT
325            && msg.u.event_data.event == OMX_EventCmdComplete
326            && msg.u.event_data.data1 == OMX_CommandStateSet
327            && msg.u.event_data.data2 == OMX_StateIdle,
328           "Component did not properly transition to idle state "
329           "after all input and output buffers were allocated.");
330
331    // Initiate transition Idle->Executing
332    err = mOMX->sendCommand(node, OMX_CommandStateSet, OMX_StateExecuting);
333    EXPECT_SUCCESS(err, "sendCommand(go-to-Executing)");
334
335    err = dequeueMessageForNode(node, &msg, DEFAULT_TIMEOUT);
336    EXPECT(err == OK
337            && msg.type == omx_message::EVENT
338            && msg.u.event_data.event == OMX_EventCmdComplete
339            && msg.u.event_data.data1 == OMX_CommandStateSet
340            && msg.u.event_data.data2 == OMX_StateExecuting,
341           "Component did not properly transition from idle to "
342           "executing state.");
343
344    for (size_t i = 0; i < outputBuffers.size(); ++i) {
345        err = mOMX->fillBuffer(node, outputBuffers[i].mID);
346        EXPECT_SUCCESS(err, "fillBuffer");
347
348        outputBuffers.editItemAt(i).mFlags |= kBufferBusy;
349    }
350
351    err = mOMX->sendCommand(node, OMX_CommandFlush, 1);
352    EXPECT_SUCCESS(err, "sendCommand(flush-output-port)");
353
354    err = dequeueMessageForNodeIgnoringBuffers(
355            node, &inputBuffers, &outputBuffers, &msg, DEFAULT_TIMEOUT);
356    EXPECT(err == OK
357            && msg.type == omx_message::EVENT
358            && msg.u.event_data.event == OMX_EventCmdComplete
359            && msg.u.event_data.data1 == OMX_CommandFlush
360            && msg.u.event_data.data2 == 1,
361           "Component did not properly acknowledge flushing the output port.");
362
363    for (size_t i = 0; i < outputBuffers.size(); ++i) {
364        EXPECT((outputBuffers[i].mFlags & kBufferBusy) == 0,
365               "Not all output buffers have been returned to us by the time "
366               "we received the flush-complete notification.");
367    }
368
369    for (size_t i = 0; i < outputBuffers.size(); ++i) {
370        err = mOMX->fillBuffer(node, outputBuffers[i].mID);
371        EXPECT_SUCCESS(err, "fillBuffer");
372
373        outputBuffers.editItemAt(i).mFlags |= kBufferBusy;
374    }
375
376    // Initiate transition Executing->Idle
377    err = mOMX->sendCommand(node, OMX_CommandStateSet, OMX_StateIdle);
378    EXPECT_SUCCESS(err, "sendCommand(go-to-Idle)");
379
380    err = dequeueMessageForNodeIgnoringBuffers(
381            node, &inputBuffers, &outputBuffers, &msg, DEFAULT_TIMEOUT);
382    EXPECT(err == OK
383            && msg.type == omx_message::EVENT
384            && msg.u.event_data.event == OMX_EventCmdComplete
385            && msg.u.event_data.data1 == OMX_CommandStateSet
386            && msg.u.event_data.data2 == OMX_StateIdle,
387           "Component did not properly transition to from executing to "
388           "idle state.");
389
390    for (size_t i = 0; i < inputBuffers.size(); ++i) {
391        EXPECT((inputBuffers[i].mFlags & kBufferBusy) == 0,
392                "Not all input buffers have been returned to us by the "
393                "time we received the transition-to-idle complete "
394                "notification.");
395    }
396
397    for (size_t i = 0; i < outputBuffers.size(); ++i) {
398        EXPECT((outputBuffers[i].mFlags & kBufferBusy) == 0,
399                "Not all output buffers have been returned to us by the "
400                "time we received the transition-to-idle complete "
401                "notification.");
402    }
403
404    // Initiate transition Idle->Loaded
405    err = mOMX->sendCommand(node, OMX_CommandStateSet, OMX_StateLoaded);
406    EXPECT_SUCCESS(err, "sendCommand(go-to-Loaded)");
407
408    // Make sure node doesn't just transition to loaded before we are done
409    // freeing all input and output buffers.
410    err = dequeueMessageForNode(node, &msg, DEFAULT_TIMEOUT);
411    CHECK_EQ(err, (status_t)TIMED_OUT);
412
413    for (size_t i = 0; i < inputBuffers.size(); ++i) {
414        err = mOMX->freeBuffer(node, 0, inputBuffers[i].mID);
415        EXPECT_SUCCESS(err, "freeBuffer");
416    }
417
418    err = dequeueMessageForNode(node, &msg, DEFAULT_TIMEOUT);
419    CHECK_EQ(err, (status_t)TIMED_OUT);
420
421    for (size_t i = 0; i < outputBuffers.size(); ++i) {
422        err = mOMX->freeBuffer(node, 1, outputBuffers[i].mID);
423        EXPECT_SUCCESS(err, "freeBuffer");
424    }
425
426    err = dequeueMessageForNode(node, &msg, DEFAULT_TIMEOUT);
427    EXPECT(err == OK
428            && msg.type == omx_message::EVENT
429            && msg.u.event_data.event == OMX_EventCmdComplete
430            && msg.u.event_data.data1 == OMX_CommandStateSet
431            && msg.u.event_data.data2 == OMX_StateLoaded,
432           "Component did not properly transition to from idle to "
433           "loaded state after freeing all input and output buffers.");
434
435    err = mOMX->freeNode(node);
436    EXPECT_SUCCESS(err, "freeNode");
437
438    reaper.disarm();
439
440    node = 0;
441
442    return OK;
443}
444
445static const char *GetMimeFromComponentRole(const char *componentRole) {
446    struct RoleToMime {
447        const char *mRole;
448        const char *mMime;
449    };
450    const RoleToMime kRoleToMime[] = {
451        { "video_decoder.avc", "video/avc" },
452        { "video_decoder.mpeg4", "video/mp4v-es" },
453        { "video_decoder.h263", "video/3gpp" },
454        { "video_decoder.vp8", "video/x-vnd.on2.vp8" },
455        { "video_decoder.vp9", "video/x-vnd.on2.vp9" },
456
457        // we appear to use this as a synonym to amrnb.
458        { "audio_decoder.amr", "audio/3gpp" },
459
460        { "audio_decoder.amrnb", "audio/3gpp" },
461        { "audio_decoder.amrwb", "audio/amr-wb" },
462        { "audio_decoder.aac", "audio/mp4a-latm" },
463        { "audio_decoder.mp3", "audio/mpeg" },
464        { "audio_decoder.vorbis", "audio/vorbis" },
465        { "audio_decoder.g711alaw", MEDIA_MIMETYPE_AUDIO_G711_ALAW },
466        { "audio_decoder.g711mlaw", MEDIA_MIMETYPE_AUDIO_G711_MLAW },
467    };
468
469    for (size_t i = 0; i < sizeof(kRoleToMime) / sizeof(kRoleToMime[0]); ++i) {
470        if (!strcmp(componentRole, kRoleToMime[i].mRole)) {
471            return kRoleToMime[i].mMime;
472        }
473    }
474
475    return NULL;
476}
477
478static const char *GetURLForMime(const char *mime) {
479    struct MimeToURL {
480        const char *mMime;
481        const char *mURL;
482    };
483    static const MimeToURL kMimeToURL[] = {
484        { "video/avc",
485          "file:///sdcard/media_api/video/H264_500_AAC_128.3gp" },
486        { "video/mp4v-es", "file:///sdcard/media_api/video/MPEG4_320_AAC_64.mp4" },
487        { "video/3gpp",
488          "file:///sdcard/media_api/video/H263_500_AMRNB_12.3gp" },
489        { "audio/3gpp",
490          "file:///sdcard/media_api/video/H263_500_AMRNB_12.3gp" },
491        { "audio/amr-wb", NULL },
492        { "audio/mp4a-latm",
493          "file:///sdcard/media_api/video/H263_56_AAC_24.3gp" },
494        { "audio/mpeg",
495          "file:///sdcard/media_api/music/MP3_48KHz_128kbps_s_1_17_CBR.mp3" },
496        { "audio/vorbis", NULL },
497        { "video/x-vnd.on2.vp8",
498          "file:///sdcard/media_api/video/big-buck-bunny_trailer.webm" },
499        { MEDIA_MIMETYPE_AUDIO_G711_ALAW, "file:///sdcard/M1F1-Alaw-AFsp.wav" },
500        { MEDIA_MIMETYPE_AUDIO_G711_MLAW,
501          "file:///sdcard/M1F1-mulaw-AFsp.wav" },
502    };
503
504    for (size_t i = 0; i < sizeof(kMimeToURL) / sizeof(kMimeToURL[0]); ++i) {
505        if (!strcasecmp(kMimeToURL[i].mMime, mime)) {
506            return kMimeToURL[i].mURL;
507        }
508    }
509
510    return NULL;
511}
512
513static sp<MediaSource> CreateSourceForMime(const char *mime) {
514    const char *url = GetURLForMime(mime);
515
516    if (url == NULL) {
517        return NULL;
518    }
519
520    sp<MediaExtractor> extractor = CreateExtractorFromURI(url);
521
522    if (extractor == NULL) {
523        return NULL;
524    }
525
526    for (size_t i = 0; i < extractor->countTracks(); ++i) {
527        sp<MetaData> meta = extractor->getTrackMetaData(i);
528        CHECK(meta != NULL);
529
530        const char *trackMime;
531        CHECK(meta->findCString(kKeyMIMEType, &trackMime));
532
533        if (!strcasecmp(mime, trackMime)) {
534            return extractor->getTrack(i);
535        }
536    }
537
538    return NULL;
539}
540
541static double uniform_rand() {
542    return (double)rand() / RAND_MAX;
543}
544
545static bool CloseEnough(int64_t time1Us, int64_t time2Us) {
546#if 0
547    int64_t diff = time1Us - time2Us;
548    if (diff < 0) {
549        diff = -diff;
550    }
551
552    return diff <= 50000;
553#else
554    return time1Us == time2Us;
555#endif
556}
557
558status_t Harness::testSeek(
559        const char *componentName, const char *componentRole) {
560    bool isEncoder =
561        !strncmp(componentRole, "audio_encoder.", 14)
562        || !strncmp(componentRole, "video_encoder.", 14);
563
564    if (isEncoder) {
565        // Not testing seek behaviour for encoders.
566
567        printf("  * Not testing seek functionality for encoders.\n");
568        return OK;
569    }
570
571    const char *mime = GetMimeFromComponentRole(componentRole);
572
573    if (!mime) {
574        printf("  * Cannot perform seek test with this componentRole (%s)\n",
575               componentRole);
576
577        return OK;
578    }
579
580    sp<MediaSource> source = CreateSourceForMime(mime);
581
582    if (source == NULL) {
583        printf("  * Unable to open test content for type '%s', "
584               "skipping test of componentRole %s\n",
585               mime, componentRole);
586
587        return OK;
588    }
589
590    sp<MediaSource> seekSource = CreateSourceForMime(mime);
591    if (source == NULL || seekSource == NULL) {
592        return UNKNOWN_ERROR;
593    }
594
595    CHECK_EQ(seekSource->start(), (status_t)OK);
596
597    sp<MediaSource> codec = OMXCodec::Create(
598            mOMX, source->getFormat(), false /* createEncoder */,
599            source, componentName);
600
601    CHECK(codec != NULL);
602
603    CHECK_EQ(codec->start(), (status_t)OK);
604
605    int64_t durationUs;
606    CHECK(source->getFormat()->findInt64(kKeyDuration, &durationUs));
607
608    ALOGI("stream duration is %lld us (%.2f secs)",
609         durationUs, durationUs / 1E6);
610
611    static const int32_t kNumIterations = 5000;
612
613    // We are always going to seek beyond EOS in the first iteration (i == 0)
614    // followed by a linear read for the second iteration (i == 1).
615    // After that it's all random.
616    for (int32_t i = 0; i < kNumIterations; ++i) {
617        int64_t requestedSeekTimeUs;
618        int64_t actualSeekTimeUs;
619        MediaSource::ReadOptions options;
620
621        double r = uniform_rand();
622
623        if ((i == 1) || (i > 0 && r < 0.5)) {
624            // 50% chance of just continuing to decode from last position.
625
626            requestedSeekTimeUs = -1;
627
628            ALOGI("requesting linear read");
629        } else {
630            if (i == 0 || r < 0.55) {
631                // 5% chance of seeking beyond end of stream.
632
633                requestedSeekTimeUs = durationUs;
634
635                ALOGI("requesting seek beyond EOF");
636            } else {
637                requestedSeekTimeUs =
638                    (int64_t)(uniform_rand() * durationUs);
639
640                ALOGI("requesting seek to %lld us (%.2f secs)",
641                     requestedSeekTimeUs, requestedSeekTimeUs / 1E6);
642            }
643
644            MediaBuffer *buffer = NULL;
645            options.setSeekTo(
646                    requestedSeekTimeUs, MediaSource::ReadOptions::SEEK_NEXT_SYNC);
647
648            if (seekSource->read(&buffer, &options) != OK) {
649                CHECK(buffer == NULL);
650                actualSeekTimeUs = -1;
651            } else {
652                CHECK(buffer != NULL);
653                CHECK(buffer->meta_data()->findInt64(kKeyTime, &actualSeekTimeUs));
654                CHECK(actualSeekTimeUs >= 0);
655
656                buffer->release();
657                buffer = NULL;
658            }
659
660            ALOGI("nearest keyframe is at %lld us (%.2f secs)",
661                 actualSeekTimeUs, actualSeekTimeUs / 1E6);
662        }
663
664        status_t err;
665        MediaBuffer *buffer;
666        for (;;) {
667            err = codec->read(&buffer, &options);
668            options.clearSeekTo();
669            if (err == INFO_FORMAT_CHANGED) {
670                CHECK(buffer == NULL);
671                continue;
672            }
673            if (err == OK) {
674                CHECK(buffer != NULL);
675                if (buffer->range_length() == 0) {
676                    buffer->release();
677                    buffer = NULL;
678                    continue;
679                }
680            } else {
681                CHECK(buffer == NULL);
682            }
683
684            break;
685        }
686
687        if (requestedSeekTimeUs < 0) {
688            // Linear read.
689            if (err != OK) {
690                CHECK(buffer == NULL);
691            } else {
692                CHECK(buffer != NULL);
693                buffer->release();
694                buffer = NULL;
695            }
696        } else if (actualSeekTimeUs < 0) {
697            EXPECT(err != OK,
698                   "We attempted to seek beyond EOS and expected "
699                   "ERROR_END_OF_STREAM to be returned, but instead "
700                   "we got a valid buffer.");
701            EXPECT(err == ERROR_END_OF_STREAM,
702                   "We attempted to seek beyond EOS and expected "
703                   "ERROR_END_OF_STREAM to be returned, but instead "
704                   "we found some other error.");
705            CHECK_EQ(err, (status_t)ERROR_END_OF_STREAM);
706            CHECK(buffer == NULL);
707        } else {
708            EXPECT(err == OK,
709                   "Expected a valid buffer to be returned from "
710                   "OMXCodec::read.");
711            CHECK(buffer != NULL);
712
713            int64_t bufferTimeUs;
714            CHECK(buffer->meta_data()->findInt64(kKeyTime, &bufferTimeUs));
715            if (!CloseEnough(bufferTimeUs, actualSeekTimeUs)) {
716                printf("\n  * Attempted seeking to %lld us (%.2f secs)",
717                       requestedSeekTimeUs, requestedSeekTimeUs / 1E6);
718                printf("\n  * Nearest keyframe is at %lld us (%.2f secs)",
719                       actualSeekTimeUs, actualSeekTimeUs / 1E6);
720                printf("\n  * Returned buffer was at %lld us (%.2f secs)\n\n",
721                       bufferTimeUs, bufferTimeUs / 1E6);
722
723                buffer->release();
724                buffer = NULL;
725
726                CHECK_EQ(codec->stop(), (status_t)OK);
727
728                return UNKNOWN_ERROR;
729            }
730
731            buffer->release();
732            buffer = NULL;
733        }
734    }
735
736    CHECK_EQ(codec->stop(), (status_t)OK);
737
738    return OK;
739}
740
741status_t Harness::test(
742        const char *componentName, const char *componentRole) {
743    printf("testing %s [%s] ... ", componentName, componentRole);
744    ALOGI("testing %s [%s].", componentName, componentRole);
745
746    status_t err1 = testStateTransitions(componentName, componentRole);
747    status_t err2 = testSeek(componentName, componentRole);
748
749    if (err1 != OK) {
750        return err1;
751    }
752
753    return err2;
754}
755
756status_t Harness::testAll() {
757    List<IOMX::ComponentInfo> componentInfos;
758    status_t err = mOMX->listNodes(&componentInfos);
759    EXPECT_SUCCESS(err, "listNodes");
760
761    for (List<IOMX::ComponentInfo>::iterator it = componentInfos.begin();
762         it != componentInfos.end(); ++it) {
763        const IOMX::ComponentInfo &info = *it;
764        const char *componentName = info.mName.string();
765
766        if (strncmp(componentName, "OMX.google.", 11)) {
767            continue;
768        }
769
770        for (List<String8>::const_iterator role_it = info.mRoles.begin();
771             role_it != info.mRoles.end(); ++role_it) {
772            const char *componentRole = (*role_it).string();
773
774            err = test(componentName, componentRole);
775
776            if (err == OK) {
777                printf("OK\n");
778            }
779        }
780    }
781
782    return OK;
783}
784
785}  // namespace android
786
787static void usage(const char *me) {
788    fprintf(stderr, "usage: %s\n"
789                    "  -h(elp)  Show this information\n"
790                    "  -s(eed)  Set the random seed\n"
791                    "    [ component role ]\n\n"
792                    "When launched without specifying a specific component "
793                    "and role, tool will test all available OMX components "
794                    "in all their supported roles. To determine available "
795                    "component names, use \"stagefright -l\"\n"
796                    "It's also a good idea to run a separate \"adb logcat\""
797                    " for additional debug and progress information.", me);
798
799    exit(0);
800}
801
802int main(int argc, char **argv) {
803    using namespace android;
804
805    android::ProcessState::self()->startThreadPool();
806    DataSource::RegisterDefaultSniffers();
807
808    const char *me = argv[0];
809
810    unsigned long seed = 0xdeadbeef;
811
812    int res;
813    while ((res = getopt(argc, argv, "hs:")) >= 0) {
814        switch (res) {
815            case 's':
816            {
817                char *end;
818                unsigned long x = strtoul(optarg, &end, 10);
819
820                if (*end != '\0' || end == optarg) {
821                    fprintf(stderr, "Malformed seed.\n");
822                    return 1;
823                }
824
825                seed = x;
826                break;
827            }
828
829            case '?':
830                fprintf(stderr, "\n");
831                // fall through
832
833            case 'h':
834            default:
835            {
836                usage(me);
837                exit(1);
838                break;
839            }
840        }
841    }
842
843    argc -= optind;
844    argv += optind;
845
846    printf("To reproduce the conditions for this test, launch "
847           "with \"%s -s %lu\"\n", me, seed);
848
849    srand(seed);
850
851    sp<Harness> h = new Harness;
852    CHECK_EQ(h->initCheck(), (status_t)OK);
853
854    if (argc == 0) {
855        h->testAll();
856    } else if (argc == 2) {
857        if (h->test(argv[0], argv[1]) == OK) {
858            printf("OK\n");
859        }
860    }
861
862    return 0;
863}
864