MatroskaExtractor.cpp revision f02a7f5c42db707d20e59ff28f32d1eaebcc5429 
1/*
2 * Copyright (C) 2010 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 "MatroskaExtractor"
19#include <utils/Log.h>
20
21#include "MatroskaExtractor.h"
22
23#include "mkvparser.hpp"
24
25#include <media/stagefright/foundation/ADebug.h>
26#include <media/stagefright/foundation/hexdump.h>
27#include <media/stagefright/DataSource.h>
28#include <media/stagefright/MediaBuffer.h>
29#include <media/stagefright/MediaDefs.h>
30#include <media/stagefright/MediaErrors.h>
31#include <media/stagefright/MediaSource.h>
32#include <media/stagefright/MetaData.h>
33#include <media/stagefright/Utils.h>
34#include <utils/String8.h>
35
36namespace android {
37
38struct DataSourceReader : public mkvparser::IMkvReader {
39    DataSourceReader(const sp<DataSource> &source)
40        : mSource(source) {
41    }
42
43    virtual int Read(long long position, long length, unsigned char* buffer) {
44        CHECK(position >= 0);
45        CHECK(length >= 0);
46
47        if (length == 0) {
48            return 0;
49        }
50
51        ssize_t n = mSource->readAt(position, buffer, length);
52
53        if (n <= 0) {
54            return -1;
55        }
56
57        return 0;
58    }
59
60    virtual int Length(long long* total, long long* available) {
61        off64_t size;
62        if (mSource->getSize(&size) != OK) {
63            *total = -1;
64            *available = (long long)((1ull << 63) - 1);
65
66            return 0;
67        }
68
69        if (total) {
70            *total = size;
71        }
72
73        if (available) {
74            *available = size;
75        }
76
77        return 0;
78    }
79
80private:
81    sp<DataSource> mSource;
82
83    DataSourceReader(const DataSourceReader &);
84    DataSourceReader &operator=(const DataSourceReader &);
85};
86
87////////////////////////////////////////////////////////////////////////////////
88
89struct BlockIterator {
90    BlockIterator(MatroskaExtractor *extractor, unsigned long trackNum);
91
92    bool eos() const;
93
94    void advance();
95    void reset();
96
97    void seek(
98            int64_t seekTimeUs, bool isAudio,
99            int64_t *actualFrameTimeUs);
100
101    const mkvparser::Block *block() const;
102    int64_t blockTimeUs() const;
103
104private:
105    MatroskaExtractor *mExtractor;
106    unsigned long mTrackNum;
107
108    const mkvparser::Cluster *mCluster;
109    const mkvparser::BlockEntry *mBlockEntry;
110    long mBlockEntryIndex;
111
112    void advance_l();
113
114    BlockIterator(const BlockIterator &);
115    BlockIterator &operator=(const BlockIterator &);
116};
117
118struct MatroskaSource : public MediaSource {
119    MatroskaSource(
120            const sp<MatroskaExtractor> &extractor, size_t index);
121
122    virtual status_t start(MetaData *params);
123    virtual status_t stop();
124
125    virtual sp<MetaData> getFormat();
126
127    virtual status_t read(
128            MediaBuffer **buffer, const ReadOptions *options);
129
130protected:
131    virtual ~MatroskaSource();
132
133private:
134    enum Type {
135        AVC,
136        AAC,
137        OTHER
138    };
139
140    sp<MatroskaExtractor> mExtractor;
141    size_t mTrackIndex;
142    Type mType;
143    bool mIsAudio;
144    BlockIterator mBlockIter;
145    size_t mNALSizeLen;  // for type AVC
146
147    List<MediaBuffer *> mPendingFrames;
148
149    status_t advance();
150
151    status_t readBlock();
152    void clearPendingFrames();
153
154    MatroskaSource(const MatroskaSource &);
155    MatroskaSource &operator=(const MatroskaSource &);
156};
157
158MatroskaSource::MatroskaSource(
159        const sp<MatroskaExtractor> &extractor, size_t index)
160    : mExtractor(extractor),
161      mTrackIndex(index),
162      mType(OTHER),
163      mIsAudio(false),
164      mBlockIter(mExtractor.get(),
165                 mExtractor->mTracks.itemAt(index).mTrackNum),
166      mNALSizeLen(0) {
167    sp<MetaData> meta = mExtractor->mTracks.itemAt(index).mMeta;
168
169    const char *mime;
170    CHECK(meta->findCString(kKeyMIMEType, &mime));
171
172    mIsAudio = !strncasecmp("audio/", mime, 6);
173
174    if (!strcasecmp(mime, MEDIA_MIMETYPE_VIDEO_AVC)) {
175        mType = AVC;
176
177        uint32_t dummy;
178        const uint8_t *avcc;
179        size_t avccSize;
180        CHECK(meta->findData(
181                    kKeyAVCC, &dummy, (const void **)&avcc, &avccSize));
182
183        CHECK_GE(avccSize, 5u);
184
185        mNALSizeLen = 1 + (avcc[4] & 3);
186        ALOGV("mNALSizeLen = %d", mNALSizeLen);
187    } else if (!strcasecmp(mime, MEDIA_MIMETYPE_AUDIO_AAC)) {
188        mType = AAC;
189    }
190}
191
192MatroskaSource::~MatroskaSource() {
193    clearPendingFrames();
194}
195
196status_t MatroskaSource::start(MetaData *params) {
197    mBlockIter.reset();
198
199    return OK;
200}
201
202status_t MatroskaSource::stop() {
203    clearPendingFrames();
204
205    return OK;
206}
207
208sp<MetaData> MatroskaSource::getFormat() {
209    return mExtractor->mTracks.itemAt(mTrackIndex).mMeta;
210}
211
212////////////////////////////////////////////////////////////////////////////////
213
214BlockIterator::BlockIterator(
215        MatroskaExtractor *extractor, unsigned long trackNum)
216    : mExtractor(extractor),
217      mTrackNum(trackNum),
218      mCluster(NULL),
219      mBlockEntry(NULL),
220      mBlockEntryIndex(0) {
221    reset();
222}
223
224bool BlockIterator::eos() const {
225    return mCluster == NULL || mCluster->EOS();
226}
227
228void BlockIterator::advance() {
229    Mutex::Autolock autoLock(mExtractor->mLock);
230    advance_l();
231}
232
233void BlockIterator::advance_l() {
234    for (;;) {
235        long res = mCluster->GetEntry(mBlockEntryIndex, mBlockEntry);
236        ALOGV("GetEntry returned %ld", res);
237
238        long long pos;
239        long len;
240        if (res < 0) {
241            // Need to parse this cluster some more
242
243            CHECK_EQ(res, mkvparser::E_BUFFER_NOT_FULL);
244
245            res = mCluster->Parse(pos, len);
246            ALOGV("Parse returned %ld", res);
247
248            if (res < 0) {
249                // I/O error
250
251                ALOGE("Cluster::Parse returned result %ld", res);
252
253                mCluster = NULL;
254                break;
255            }
256
257            continue;
258        } else if (res == 0) {
259            // We're done with this cluster
260
261            const mkvparser::Cluster *nextCluster;
262            res = mExtractor->mSegment->ParseNext(
263                    mCluster, nextCluster, pos, len);
264            ALOGV("ParseNext returned %ld", res);
265
266            if (res > 0) {
267                // EOF
268
269                mCluster = NULL;
270                break;
271            }
272
273            CHECK_EQ(res, 0);
274            CHECK(nextCluster != NULL);
275            CHECK(!nextCluster->EOS());
276
277            mCluster = nextCluster;
278
279            res = mCluster->Parse(pos, len);
280            ALOGV("Parse (2) returned %ld", res);
281            CHECK_GE(res, 0);
282
283            mBlockEntryIndex = 0;
284            continue;
285        }
286
287        CHECK(mBlockEntry != NULL);
288        CHECK(mBlockEntry->GetBlock() != NULL);
289        ++mBlockEntryIndex;
290
291        if (mBlockEntry->GetBlock()->GetTrackNumber() == mTrackNum) {
292            break;
293        }
294    }
295}
296
297void BlockIterator::reset() {
298    Mutex::Autolock autoLock(mExtractor->mLock);
299
300    mCluster = mExtractor->mSegment->GetFirst();
301    mBlockEntry = NULL;
302    mBlockEntryIndex = 0;
303
304    do {
305        advance_l();
306    } while (!eos() && block()->GetTrackNumber() != mTrackNum);
307}
308
309void BlockIterator::seek(
310        int64_t seekTimeUs, bool isAudio,
311        int64_t *actualFrameTimeUs) {
312    Mutex::Autolock autoLock(mExtractor->mLock);
313
314    *actualFrameTimeUs = -1ll;
315
316    const int64_t seekTimeNs = seekTimeUs * 1000ll;
317
318    mkvparser::Segment* const pSegment = mExtractor->mSegment;
319
320    // Special case the 0 seek to avoid loading Cues when the application
321    // extraneously seeks to 0 before playing.
322    if (seekTimeNs <= 0) {
323        ALOGV("Seek to beginning: %lld", seekTimeUs);
324        mCluster = pSegment->GetFirst();
325        mBlockEntryIndex = 0;
326        do {
327            advance_l();
328        } while (!eos() && block()->GetTrackNumber() != mTrackNum);
329        return;
330    }
331
332    ALOGV("Seeking to: %lld", seekTimeUs);
333
334    // If the Cues have not been located then find them.
335    const mkvparser::Cues* pCues = pSegment->GetCues();
336    const mkvparser::SeekHead* pSH = pSegment->GetSeekHead();
337    if (!pCues && pSH) {
338        const size_t count = pSH->GetCount();
339        const mkvparser::SeekHead::Entry* pEntry;
340        ALOGV("No Cues yet");
341
342        for (size_t index = 0; index < count; index++) {
343            pEntry = pSH->GetEntry(index);
344
345            if (pEntry->id == 0x0C53BB6B) { // Cues ID
346                long len; long long pos;
347                pSegment->ParseCues(pEntry->pos, pos, len);
348                pCues = pSegment->GetCues();
349                ALOGV("Cues found");
350                break;
351            }
352        }
353
354        if (!pCues) {
355            ALOGE("No Cues in file");
356            return;
357        }
358    }
359    else if (!pSH) {
360        ALOGE("No SeekHead");
361        return;
362    }
363
364    const mkvparser::CuePoint* pCP;
365    while (!pCues->DoneParsing()) {
366        pCues->LoadCuePoint();
367        pCP = pCues->GetLast();
368
369        if (pCP->GetTime(pSegment) >= seekTimeNs) {
370            ALOGV("Parsed past relevant Cue");
371            break;
372        }
373    }
374
375    // The Cue index is built around video keyframes
376    mkvparser::Tracks const *pTracks = pSegment->GetTracks();
377    const mkvparser::Track *pTrack = NULL;
378    for (size_t index = 0; index < pTracks->GetTracksCount(); ++index) {
379        pTrack = pTracks->GetTrackByIndex(index);
380        if (pTrack && pTrack->GetType() == 1) { // VIDEO_TRACK
381            ALOGV("Video track located at %d", index);
382            break;
383        }
384    }
385
386    // Always *search* based on the video track, but finalize based on mTrackNum
387    const mkvparser::CuePoint::TrackPosition* pTP;
388    if (pTrack && pTrack->GetType() == 1) {
389        pCues->Find(seekTimeNs, pTrack, pCP, pTP);
390    } else {
391        ALOGE("Did not locate the video track for seeking");
392        return;
393    }
394
395    mCluster = pSegment->FindOrPreloadCluster(pTP->m_pos);
396
397    CHECK(mCluster);
398    CHECK(!mCluster->EOS());
399
400    // mBlockEntryIndex starts at 0 but m_block starts at 1
401    CHECK_GT(pTP->m_block, 0);
402    mBlockEntryIndex = pTP->m_block - 1;
403
404    for (;;) {
405        advance_l();
406
407        if (eos()) break;
408
409        if (isAudio || block()->IsKey()) {
410            // Accept the first key frame
411            *actualFrameTimeUs = (block()->GetTime(mCluster) + 500LL) / 1000LL;
412            ALOGV("Requested seek point: %lld actual: %lld",
413                  seekTimeUs, actualFrameTimeUs);
414            break;
415        }
416    }
417}
418
419const mkvparser::Block *BlockIterator::block() const {
420    CHECK(!eos());
421
422    return mBlockEntry->GetBlock();
423}
424
425int64_t BlockIterator::blockTimeUs() const {
426    return (mBlockEntry->GetBlock()->GetTime(mCluster) + 500ll) / 1000ll;
427}
428
429////////////////////////////////////////////////////////////////////////////////
430
431static unsigned U24_AT(const uint8_t *ptr) {
432    return ptr[0] << 16 | ptr[1] << 8 | ptr[2];
433}
434
435static size_t clz(uint8_t x) {
436    size_t numLeadingZeroes = 0;
437
438    while (!(x & 0x80)) {
439        ++numLeadingZeroes;
440        x = x << 1;
441    }
442
443    return numLeadingZeroes;
444}
445
446void MatroskaSource::clearPendingFrames() {
447    while (!mPendingFrames.empty()) {
448        MediaBuffer *frame = *mPendingFrames.begin();
449        mPendingFrames.erase(mPendingFrames.begin());
450
451        frame->release();
452        frame = NULL;
453    }
454}
455
456status_t MatroskaSource::readBlock() {
457    CHECK(mPendingFrames.empty());
458
459    if (mBlockIter.eos()) {
460        return ERROR_END_OF_STREAM;
461    }
462
463    const mkvparser::Block *block = mBlockIter.block();
464
465    int64_t timeUs = mBlockIter.blockTimeUs();
466
467    for (int i = 0; i < block->GetFrameCount(); ++i) {
468        const mkvparser::Block::Frame &frame = block->GetFrame(i);
469
470        MediaBuffer *mbuf = new MediaBuffer(frame.len);
471        mbuf->meta_data()->setInt64(kKeyTime, timeUs);
472        mbuf->meta_data()->setInt32(kKeyIsSyncFrame, block->IsKey());
473
474        long n = frame.Read(mExtractor->mReader, (unsigned char *)mbuf->data());
475        if (n != 0) {
476            mPendingFrames.clear();
477
478            mBlockIter.advance();
479            return ERROR_IO;
480        }
481
482        mPendingFrames.push_back(mbuf);
483    }
484
485    mBlockIter.advance();
486
487    return OK;
488}
489
490status_t MatroskaSource::read(
491        MediaBuffer **out, const ReadOptions *options) {
492    *out = NULL;
493
494    int64_t targetSampleTimeUs = -1ll;
495
496    int64_t seekTimeUs;
497    ReadOptions::SeekMode mode;
498    if (options && options->getSeekTo(&seekTimeUs, &mode)
499            && !mExtractor->isLiveStreaming()) {
500        clearPendingFrames();
501
502        // The audio we want is located by using the Cues to seek the video
503        // stream to find the target Cluster then iterating to finalize for
504        // audio.
505        int64_t actualFrameTimeUs;
506        mBlockIter.seek(seekTimeUs, mIsAudio, &actualFrameTimeUs);
507
508        if (mode == ReadOptions::SEEK_CLOSEST) {
509            targetSampleTimeUs = actualFrameTimeUs;
510        }
511    }
512
513    while (mPendingFrames.empty()) {
514        status_t err = readBlock();
515
516        if (err != OK) {
517            clearPendingFrames();
518
519            return err;
520        }
521    }
522
523    MediaBuffer *frame = *mPendingFrames.begin();
524    mPendingFrames.erase(mPendingFrames.begin());
525
526    if (mType != AVC) {
527        if (targetSampleTimeUs >= 0ll) {
528            frame->meta_data()->setInt64(
529                    kKeyTargetTime, targetSampleTimeUs);
530        }
531
532        *out = frame;
533
534        return OK;
535    }
536
537    // Each input frame contains one or more NAL fragments, each fragment
538    // is prefixed by mNALSizeLen bytes giving the fragment length,
539    // followed by a corresponding number of bytes containing the fragment.
540    // We output all these fragments into a single large buffer separated
541    // by startcodes (0x00 0x00 0x00 0x01).
542
543    const uint8_t *srcPtr =
544        (const uint8_t *)frame->data() + frame->range_offset();
545
546    size_t srcSize = frame->range_length();
547
548    size_t dstSize = 0;
549    MediaBuffer *buffer = NULL;
550    uint8_t *dstPtr = NULL;
551
552    for (int32_t pass = 0; pass < 2; ++pass) {
553        size_t srcOffset = 0;
554        size_t dstOffset = 0;
555        while (srcOffset + mNALSizeLen <= srcSize) {
556            size_t NALsize;
557            switch (mNALSizeLen) {
558                case 1: NALsize = srcPtr[srcOffset]; break;
559                case 2: NALsize = U16_AT(srcPtr + srcOffset); break;
560                case 3: NALsize = U24_AT(srcPtr + srcOffset); break;
561                case 4: NALsize = U32_AT(srcPtr + srcOffset); break;
562                default:
563                    TRESPASS();
564            }
565
566            if (srcOffset + mNALSizeLen + NALsize > srcSize) {
567                break;
568            }
569
570            if (pass == 1) {
571                memcpy(&dstPtr[dstOffset], "\x00\x00\x00\x01", 4);
572
573                memcpy(&dstPtr[dstOffset + 4],
574                       &srcPtr[srcOffset + mNALSizeLen],
575                       NALsize);
576            }
577
578            dstOffset += 4;  // 0x00 00 00 01
579            dstOffset += NALsize;
580
581            srcOffset += mNALSizeLen + NALsize;
582        }
583
584        if (srcOffset < srcSize) {
585            // There were trailing bytes or not enough data to complete
586            // a fragment.
587
588            frame->release();
589            frame = NULL;
590
591            return ERROR_MALFORMED;
592        }
593
594        if (pass == 0) {
595            dstSize = dstOffset;
596
597            buffer = new MediaBuffer(dstSize);
598
599            int64_t timeUs;
600            CHECK(frame->meta_data()->findInt64(kKeyTime, &timeUs));
601            int32_t isSync;
602            CHECK(frame->meta_data()->findInt32(kKeyIsSyncFrame, &isSync));
603
604            buffer->meta_data()->setInt64(kKeyTime, timeUs);
605            buffer->meta_data()->setInt32(kKeyIsSyncFrame, isSync);
606
607            dstPtr = (uint8_t *)buffer->data();
608        }
609    }
610
611    frame->release();
612    frame = NULL;
613
614    if (targetSampleTimeUs >= 0ll) {
615        buffer->meta_data()->setInt64(
616                kKeyTargetTime, targetSampleTimeUs);
617    }
618
619    *out = buffer;
620
621    return OK;
622}
623
624////////////////////////////////////////////////////////////////////////////////
625
626MatroskaExtractor::MatroskaExtractor(const sp<DataSource> &source)
627    : mDataSource(source),
628      mReader(new DataSourceReader(mDataSource)),
629      mSegment(NULL),
630      mExtractedThumbnails(false),
631      mIsWebm(false) {
632    off64_t size;
633    mIsLiveStreaming =
634        (mDataSource->flags()
635            & (DataSource::kWantsPrefetching
636                | DataSource::kIsCachingDataSource))
637        && mDataSource->getSize(&size) != OK;
638
639    mkvparser::EBMLHeader ebmlHeader;
640    long long pos;
641    if (ebmlHeader.Parse(mReader, pos) < 0) {
642        return;
643    }
644
645    if (ebmlHeader.m_docType && !strcmp("webm", ebmlHeader.m_docType)) {
646        mIsWebm = true;
647    }
648
649    long long ret =
650        mkvparser::Segment::CreateInstance(mReader, pos, mSegment);
651
652    if (ret) {
653        CHECK(mSegment == NULL);
654        return;
655    }
656
657    ret = mSegment->ParseHeaders();
658    CHECK_EQ(ret, 0);
659
660    long len;
661    ret = mSegment->LoadCluster(pos, len);
662    CHECK_EQ(ret, 0);
663
664    if (ret < 0) {
665        delete mSegment;
666        mSegment = NULL;
667        return;
668    }
669
670#if 0
671    const mkvparser::SegmentInfo *info = mSegment->GetInfo();
672    ALOGI("muxing app: %s, writing app: %s",
673         info->GetMuxingAppAsUTF8(),
674         info->GetWritingAppAsUTF8());
675#endif
676
677    addTracks();
678}
679
680MatroskaExtractor::~MatroskaExtractor() {
681    delete mSegment;
682    mSegment = NULL;
683
684    delete mReader;
685    mReader = NULL;
686}
687
688size_t MatroskaExtractor::countTracks() {
689    return mTracks.size();
690}
691
692sp<MediaSource> MatroskaExtractor::getTrack(size_t index) {
693    if (index >= mTracks.size()) {
694        return NULL;
695    }
696
697    return new MatroskaSource(this, index);
698}
699
700sp<MetaData> MatroskaExtractor::getTrackMetaData(
701        size_t index, uint32_t flags) {
702    if (index >= mTracks.size()) {
703        return NULL;
704    }
705
706    if ((flags & kIncludeExtensiveMetaData) && !mExtractedThumbnails
707            && !isLiveStreaming()) {
708        findThumbnails();
709        mExtractedThumbnails = true;
710    }
711
712    return mTracks.itemAt(index).mMeta;
713}
714
715bool MatroskaExtractor::isLiveStreaming() const {
716    return mIsLiveStreaming;
717}
718
719static void addESDSFromCodecPrivate(
720        const sp<MetaData> &meta,
721        bool isAudio, const void *priv, size_t privSize) {
722    static const uint8_t kStaticESDS[] = {
723        0x03, 22,
724        0x00, 0x00,     // ES_ID
725        0x00,           // streamDependenceFlag, URL_Flag, OCRstreamFlag
726
727        0x04, 17,
728        0x40,           // ObjectTypeIndication
729        0x00, 0x00, 0x00, 0x00,
730        0x00, 0x00, 0x00, 0x00,
731        0x00, 0x00, 0x00, 0x00,
732
733        0x05,
734        // CodecSpecificInfo (with size prefix) follows
735    };
736
737    // Make sure all sizes can be coded in a single byte.
738    CHECK(privSize + 22 - 2 < 128);
739    size_t esdsSize = sizeof(kStaticESDS) + privSize + 1;
740    uint8_t *esds = new uint8_t[esdsSize];
741    memcpy(esds, kStaticESDS, sizeof(kStaticESDS));
742    uint8_t *ptr = esds + sizeof(kStaticESDS);
743    *ptr++ = privSize;
744    memcpy(ptr, priv, privSize);
745
746    // Increment by codecPrivateSize less 2 bytes that are accounted for
747    // already in lengths of 22/17
748    esds[1] += privSize - 2;
749    esds[6] += privSize - 2;
750
751    // Set ObjectTypeIndication.
752    esds[7] = isAudio ? 0x40   // Audio ISO/IEC 14496-3
753                      : 0x20;  // Visual ISO/IEC 14496-2
754
755    meta->setData(kKeyESDS, 0, esds, esdsSize);
756
757    delete[] esds;
758    esds = NULL;
759}
760
761void addVorbisCodecInfo(
762        const sp<MetaData> &meta,
763        const void *_codecPrivate, size_t codecPrivateSize) {
764    // printf("vorbis private data follows:\n");
765    // hexdump(_codecPrivate, codecPrivateSize);
766
767    CHECK(codecPrivateSize >= 3);
768
769    const uint8_t *codecPrivate = (const uint8_t *)_codecPrivate;
770    CHECK(codecPrivate[0] == 0x02);
771
772    size_t len1 = codecPrivate[1];
773    size_t len2 = codecPrivate[2];
774
775    CHECK(codecPrivateSize > 3 + len1 + len2);
776
777    CHECK(codecPrivate[3] == 0x01);
778    meta->setData(kKeyVorbisInfo, 0, &codecPrivate[3], len1);
779
780    CHECK(codecPrivate[len1 + 3] == 0x03);
781
782    CHECK(codecPrivate[len1 + len2 + 3] == 0x05);
783    meta->setData(
784            kKeyVorbisBooks, 0, &codecPrivate[len1 + len2 + 3],
785            codecPrivateSize - len1 - len2 - 3);
786}
787
788void MatroskaExtractor::addTracks() {
789    const mkvparser::Tracks *tracks = mSegment->GetTracks();
790
791    for (size_t index = 0; index < tracks->GetTracksCount(); ++index) {
792        const mkvparser::Track *track = tracks->GetTrackByIndex(index);
793
794        if (track == NULL) {
795            // Apparently this is currently valid (if unexpected) behaviour
796            // of the mkv parser lib.
797            continue;
798        }
799
800        const char *const codecID = track->GetCodecId();
801        ALOGV("codec id = %s", codecID);
802        ALOGV("codec name = %s", track->GetCodecNameAsUTF8());
803
804        size_t codecPrivateSize;
805        const unsigned char *codecPrivate =
806            track->GetCodecPrivate(codecPrivateSize);
807
808        enum { VIDEO_TRACK = 1, AUDIO_TRACK = 2 };
809
810        sp<MetaData> meta = new MetaData;
811
812        switch (track->GetType()) {
813            case VIDEO_TRACK:
814            {
815                const mkvparser::VideoTrack *vtrack =
816                    static_cast<const mkvparser::VideoTrack *>(track);
817
818                if (!strcmp("V_MPEG4/ISO/AVC", codecID)) {
819                    meta->setCString(kKeyMIMEType, MEDIA_MIMETYPE_VIDEO_AVC);
820                    meta->setData(kKeyAVCC, 0, codecPrivate, codecPrivateSize);
821                } else if (!strcmp("V_MPEG4/ISO/ASP", codecID)) {
822                    if (codecPrivateSize > 0) {
823                        meta->setCString(
824                                kKeyMIMEType, MEDIA_MIMETYPE_VIDEO_MPEG4);
825                        addESDSFromCodecPrivate(
826                                meta, false, codecPrivate, codecPrivateSize);
827                    } else {
828                        ALOGW("%s is detected, but does not have configuration.",
829                                codecID);
830                        continue;
831                    }
832                } else if (!strcmp("V_VP8", codecID)) {
833                    meta->setCString(kKeyMIMEType, MEDIA_MIMETYPE_VIDEO_VPX);
834                } else {
835                    ALOGW("%s is not supported.", codecID);
836                    continue;
837                }
838
839                meta->setInt32(kKeyWidth, vtrack->GetWidth());
840                meta->setInt32(kKeyHeight, vtrack->GetHeight());
841                break;
842            }
843
844            case AUDIO_TRACK:
845            {
846                const mkvparser::AudioTrack *atrack =
847                    static_cast<const mkvparser::AudioTrack *>(track);
848
849                if (!strcmp("A_AAC", codecID)) {
850                    meta->setCString(kKeyMIMEType, MEDIA_MIMETYPE_AUDIO_AAC);
851                    CHECK(codecPrivateSize >= 2);
852
853                    addESDSFromCodecPrivate(
854                            meta, true, codecPrivate, codecPrivateSize);
855                } else if (!strcmp("A_VORBIS", codecID)) {
856                    meta->setCString(kKeyMIMEType, MEDIA_MIMETYPE_AUDIO_VORBIS);
857
858                    addVorbisCodecInfo(meta, codecPrivate, codecPrivateSize);
859                } else if (!strcmp("A_MPEG/L3", codecID)) {
860                    meta->setCString(kKeyMIMEType, MEDIA_MIMETYPE_AUDIO_MPEG);
861                } else {
862                    ALOGW("%s is not supported.", codecID);
863                    continue;
864                }
865
866                meta->setInt32(kKeySampleRate, atrack->GetSamplingRate());
867                meta->setInt32(kKeyChannelCount, atrack->GetChannels());
868                break;
869            }
870
871            default:
872                continue;
873        }
874
875        long long durationNs = mSegment->GetDuration();
876        meta->setInt64(kKeyDuration, (durationNs + 500) / 1000);
877
878        mTracks.push();
879        TrackInfo *trackInfo = &mTracks.editItemAt(mTracks.size() - 1);
880        trackInfo->mTrackNum = track->GetNumber();
881        trackInfo->mMeta = meta;
882    }
883}
884
885void MatroskaExtractor::findThumbnails() {
886    for (size_t i = 0; i < mTracks.size(); ++i) {
887        TrackInfo *info = &mTracks.editItemAt(i);
888
889        const char *mime;
890        CHECK(info->mMeta->findCString(kKeyMIMEType, &mime));
891
892        if (strncasecmp(mime, "video/", 6)) {
893            continue;
894        }
895
896        BlockIterator iter(this, info->mTrackNum);
897        int32_t i = 0;
898        int64_t thumbnailTimeUs = 0;
899        size_t maxBlockSize = 0;
900        while (!iter.eos() && i < 20) {
901            if (iter.block()->IsKey()) {
902                ++i;
903
904                size_t blockSize = 0;
905                for (int i = 0; i < iter.block()->GetFrameCount(); ++i) {
906                    blockSize += iter.block()->GetFrame(i).len;
907                }
908
909                if (blockSize > maxBlockSize) {
910                    maxBlockSize = blockSize;
911                    thumbnailTimeUs = iter.blockTimeUs();
912                }
913            }
914            iter.advance();
915        }
916        info->mMeta->setInt64(kKeyThumbnailTime, thumbnailTimeUs);
917    }
918}
919
920sp<MetaData> MatroskaExtractor::getMetaData() {
921    sp<MetaData> meta = new MetaData;
922
923    meta->setCString(
924            kKeyMIMEType,
925            mIsWebm ? "video/webm" : MEDIA_MIMETYPE_CONTAINER_MATROSKA);
926
927    return meta;
928}
929
930uint32_t MatroskaExtractor::flags() const {
931    uint32_t x = CAN_PAUSE;
932    if (!isLiveStreaming()) {
933        x |= CAN_SEEK_BACKWARD | CAN_SEEK_FORWARD | CAN_SEEK;
934    }
935
936    return x;
937}
938
939bool SniffMatroska(
940        const sp<DataSource> &source, String8 *mimeType, float *confidence,
941        sp<AMessage> *) {
942    DataSourceReader reader(source);
943    mkvparser::EBMLHeader ebmlHeader;
944    long long pos;
945    if (ebmlHeader.Parse(&reader, pos) < 0) {
946        return false;
947    }
948
949    mimeType->setTo(MEDIA_MIMETYPE_CONTAINER_MATROSKA);
950    *confidence = 0.6;
951
952    return true;
953}
954
955}  // namespace android
956