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