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