Merge "Remove mkvparser code from /frameworks/base"

include $(CLEAR_VARS)

LOCAL_SRC_FILES:=                 \

        MatroskaExtractor.cpp     \

        mkvparser.cpp             \

        MatroskaExtractor.cpp

LOCAL_C_INCLUDES:= \

        $(JNI_H_INCLUDE) \

        $(TOP)/external/libvpx/mkvparser \

        $(TOP)/frameworks/base/include/media/stagefright/openmax \

LOCAL_CFLAGS += -Wno-multichar

// Copyright (c) 2010 The WebM project authors. All Rights Reserved.

//

// Use of this source code is governed by a BSD-style license

// that can be found in the LICENSE file in the root of the source

// tree. An additional intellectual property rights grant can be found

// in the file PATENTS.  All contributing project authors may

// be found in the AUTHORS file in the root of the source tree.

#ifndef MKVPARSER_HPP

#define MKVPARSER_HPP

#include <cstdlib>

#include <cstdio>

namespace mkvparser

{

const int E_FILE_FORMAT_INVALID = -2;

const int E_BUFFER_NOT_FULL = -3;

class IMkvReader

{

public:

    virtual int Read(long long pos, long len, unsigned char* buf) = 0;

    virtual int Length(long long* total, long long* available) = 0;

protected:

    virtual ~IMkvReader();

};

long long GetUIntLength(IMkvReader*, long long, long&);

long long ReadUInt(IMkvReader*, long long, long&);

long long SyncReadUInt(IMkvReader*, long long pos, long long stop, long&);

long long UnserializeUInt(IMkvReader*, long long pos, long long size);

float Unserialize4Float(IMkvReader*, long long);

double Unserialize8Double(IMkvReader*, long long);

short Unserialize2SInt(IMkvReader*, long long);

signed char Unserialize1SInt(IMkvReader*, long long);

bool Match(IMkvReader*, long long&, unsigned long, long long&);

bool Match(IMkvReader*, long long&, unsigned long, char*&);

bool Match(IMkvReader*, long long&, unsigned long,unsigned char*&, size_t&);

bool Match(IMkvReader*, long long&, unsigned long, double&);

bool Match(IMkvReader*, long long&, unsigned long, short&);

void GetVersion(int& major, int& minor, int& build, int& revision);

struct EBMLHeader

{

    EBMLHeader();

    ~EBMLHeader();

    long long m_version;

    long long m_readVersion;

    long long m_maxIdLength;

    long long m_maxSizeLength;

    char* m_docType;

    long long m_docTypeVersion;

    long long m_docTypeReadVersion;

    long long Parse(IMkvReader*, long long&);

};

class Segment;

class Track;

class Cluster;

class Block

{

    Block(const Block&);

    Block& operator=(const Block&);

public:

    const long long m_start;

    const long long m_size;

    Block(long long start, long long size, IMkvReader*);

    long long GetTrackNumber() const;

    long long GetTimeCode(Cluster*) const;  //absolute, but not scaled

    long long GetTime(Cluster*) const;      //absolute, and scaled (ns units)

    bool IsKey() const;

    void SetKey(bool);

    unsigned char Flags() const;

    long long GetOffset() const;

    long GetSize() const;

    long Read(IMkvReader*, unsigned char*) const;

private:

    long long m_track;   //Track::Number()

    short m_timecode;  //relative to cluster

    unsigned char m_flags;

    long long m_frameOff;

    long m_frameSize;

};

class BlockEntry

{

    BlockEntry(const BlockEntry&);

    BlockEntry& operator=(const BlockEntry&);

public:

    virtual ~BlockEntry();

    virtual bool EOS() const = 0;

    virtual Cluster* GetCluster() const = 0;

    virtual size_t GetIndex() const = 0;

    virtual const Block* GetBlock() const = 0;

    virtual bool IsBFrame() const = 0;

protected:

    BlockEntry();

};

class SimpleBlock : public BlockEntry

{

    SimpleBlock(const SimpleBlock&);

    SimpleBlock& operator=(const SimpleBlock&);

public:

    SimpleBlock(Cluster*, size_t, long long start, long long size);

    bool EOS() const;

    Cluster* GetCluster() const;

    size_t GetIndex() const;

    const Block* GetBlock() const;

    bool IsBFrame() const;

protected:

    Cluster* const m_pCluster;

    const size_t m_index;

    Block m_block;

};

class BlockGroup : public BlockEntry

{

    BlockGroup(const BlockGroup&);

    BlockGroup& operator=(const BlockGroup&);

public:

    BlockGroup(Cluster*, size_t, long long, long long);

    ~BlockGroup();

    bool EOS() const;

    Cluster* GetCluster() const;

    size_t GetIndex() const;

    const Block* GetBlock() const;

    bool IsBFrame() const;

    short GetPrevTimeCode() const;  //relative to block's time

    short GetNextTimeCode() const;  //as above

protected:

    Cluster* const m_pCluster;

    const size_t m_index;

private:

    BlockGroup(Cluster*, size_t, unsigned long);

    void ParseBlock(long long start, long long size);

    short m_prevTimeCode;

    short m_nextTimeCode;

    //TODO: the Matroska spec says you can have multiple blocks within the

    //same block group, with blocks ranked by priority (the flag bits).

    //For now we just cache a single block.

#if 0

    typedef std::deque<Block*> blocks_t;

    blocks_t m_blocks;  //In practice should contain only a single element.

#else

    Block* m_pBlock;

#endif

};

class Track

{

    Track(const Track&);

    Track& operator=(const Track&);

public:

    Segment* const m_pSegment;

    virtual ~Track();

    long long GetType() const;

    long long GetNumber() const;

    const char* GetNameAsUTF8() const;

    const char* GetCodecNameAsUTF8() const;

    const char* GetCodecId() const;

    const unsigned char* GetCodecPrivate(size_t&) const;

    const BlockEntry* GetEOS() const;

    struct Settings

    {

        long long start;

        long long size;

    };

    struct Info

    {

        long long type;

        long long number;

        long long uid;

        char* nameAsUTF8;

        char* codecId;

        unsigned char* codecPrivate;

        size_t codecPrivateSize;

        char* codecNameAsUTF8;

        Settings settings;

        Info();

        void Clear();

    };

    long GetFirst(const BlockEntry*&) const;

    long GetNext(const BlockEntry* pCurr, const BlockEntry*& pNext) const;

    virtual bool VetEntry(const BlockEntry*) const = 0;

protected:

    Track(Segment*, const Info&);

    const Info m_info;

    class EOSBlock : public BlockEntry

    {

    public:

        EOSBlock();

        bool EOS() const;

        Cluster* GetCluster() const;

        size_t GetIndex() const;

        const Block* GetBlock() const;

        bool IsBFrame() const;

    };

    EOSBlock m_eos;

};

class VideoTrack : public Track

{

    VideoTrack(const VideoTrack&);

    VideoTrack& operator=(const VideoTrack&);

public:

    VideoTrack(Segment*, const Info&);

    long long GetWidth() const;

    long long GetHeight() const;

    double GetFrameRate() const;

    bool VetEntry(const BlockEntry*) const;

private:

    long long m_width;

    long long m_height;

    double m_rate;

};

class AudioTrack : public Track

{

    AudioTrack(const AudioTrack&);

    AudioTrack& operator=(const AudioTrack&);

public:

    AudioTrack(Segment*, const Info&);

    double GetSamplingRate() const;

    long long GetChannels() const;

    long long GetBitDepth() const;

    bool VetEntry(const BlockEntry*) const;

private:

    double m_rate;

    long long m_channels;

    long long m_bitDepth;

};

class Tracks

{

    Tracks(const Tracks&);

    Tracks& operator=(const Tracks&);

public:

    Segment* const m_pSegment;

    const long long m_start;

    const long long m_size;

    Tracks(Segment*, long long start, long long size);

    virtual ~Tracks();

    Track* GetTrackByNumber(unsigned long tn) const;

    Track* GetTrackByIndex(unsigned long idx) const;

private:

    Track** m_trackEntries;

    Track** m_trackEntriesEnd;

    void ParseTrackEntry(long long, long long, Track*&);

public:

    unsigned long GetTracksCount() const;

};

class SegmentInfo

{

    SegmentInfo(const SegmentInfo&);

    SegmentInfo& operator=(const SegmentInfo&);

public:

    Segment* const m_pSegment;

    const long long m_start;

    const long long m_size;

    SegmentInfo(Segment*, long long start, long long size);

    ~SegmentInfo();

    long long GetTimeCodeScale() const;

    long long GetDuration() const;  //scaled

    const char* GetMuxingAppAsUTF8() const;

    const char* GetWritingAppAsUTF8() const;

    const char* GetTitleAsUTF8() const;

private:

    long long m_timecodeScale;

    double m_duration;

    char* m_pMuxingAppAsUTF8;

    char* m_pWritingAppAsUTF8;

    char* m_pTitleAsUTF8;

};

class Cues;

class CuePoint

{

    friend class Cues;

    CuePoint(size_t, long long);

    ~CuePoint();

    CuePoint(const CuePoint&);

    CuePoint& operator=(const CuePoint&);

public:

    void Load(IMkvReader*);

    long long GetTimeCode() const;      //absolute but unscaled

    long long GetTime(Segment*) const;  //absolute and scaled (ns units)

    struct TrackPosition

    {

        long long m_track;

        long long m_pos;  //of cluster

        long long m_block;

        //codec_state  //defaults to 0

        //reference = clusters containing req'd referenced blocks

        //  reftime = timecode of the referenced block

        void Parse(IMkvReader*, long long, long long);

    };

    const TrackPosition* Find(const Track*) const;

private:

    const size_t m_index;

    long long m_timecode;

    TrackPosition* m_track_positions;

    size_t m_track_positions_count;

};

class Cues

{

    friend class Segment;

    Cues(Segment*, long long start, long long size);

    ~Cues();

    Cues(const Cues&);

    Cues& operator=(const Cues&);

public:

    Segment* const m_pSegment;

    const long long m_start;

    const long long m_size;

    bool Find(  //lower bound of time_ns

        long long time_ns,

        const Track*,

        const CuePoint*&,

        const CuePoint::TrackPosition*&) const;

#if 0

    bool FindNext(  //upper_bound of time_ns

        long long time_ns,

        const Track*,

        const CuePoint*&,

        const CuePoint::TrackPosition*&) const;

#endif

    const CuePoint* GetFirst() const;

    const CuePoint* GetLast() const;

    const CuePoint* GetNext(const CuePoint*) const;

    const BlockEntry* GetBlock(

                        const CuePoint*,

                        const CuePoint::TrackPosition*) const;

private:

    void Init() const;

    bool LoadCuePoint() const;

    void PreloadCuePoint(size_t&, long long) const;

    mutable CuePoint** m_cue_points;

    mutable size_t m_count;

    mutable size_t m_preload_count;

    mutable long long m_pos;

};

class Cluster

{

    Cluster(const Cluster&);

    Cluster& operator=(const Cluster&);

public:

    Segment* const m_pSegment;

public:

    static Cluster* Parse(Segment*, long, long long off);

    Cluster();  //EndOfStream

    ~Cluster();

    bool EOS() const;

    long long GetTimeCode();   //absolute, but not scaled

    long long GetTime();       //absolute, and scaled (nanosecond units)

    long long GetFirstTime();  //time (ns) of first (earliest) block

    long long GetLastTime();   //time (ns) of last (latest) block

    const BlockEntry* GetFirst();

    const BlockEntry* GetLast();

    const BlockEntry* GetNext(const BlockEntry*) const;

    const BlockEntry* GetEntry(const Track*);

    const BlockEntry* GetEntry(

        const CuePoint&,

        const CuePoint::TrackPosition&);

    const BlockEntry* GetMaxKey(const VideoTrack*);

protected:

    Cluster(Segment*, long, long long off);

public:

    //TODO: these should all be private, with public selector functions

    long m_index;

    long long m_pos;

    long long m_size;

private:

    long long m_timecode;

    BlockEntry** m_entries;

    size_t m_entriesCount;

    void Load();

    void LoadBlockEntries();

    void ParseBlockGroup(long long, long long, size_t);

    void ParseSimpleBlock(long long, long long, size_t);

};

class Segment

{

    friend class Cues;

    Segment(const Segment&);

    Segment& operator=(const Segment&);

private:

    Segment(IMkvReader*, long long pos, long long size);

public:

    IMkvReader* const m_pReader;

    const long long m_start;  //posn of segment payload

    const long long m_size;   //size of segment payload

    Cluster m_eos;  //TODO: make private?

    static long long CreateInstance(IMkvReader*, long long, Segment*&);

    ~Segment();

    long Load();  //loads headers and all clusters

    //for incremental loading (splitter)

    long long Unparsed() const;

    long long ParseHeaders();  //stops when first cluster is found

    long LoadCluster();        //loads one cluster

#if 0

    //This pair parses one cluster, but only changes the state of the

    //segment object when the cluster is actually added to the index.

    long ParseCluster(Cluster*&, long long& newpos) const;

    bool AddCluster(Cluster*, long long);

#endif

    Tracks* GetTracks() const;

    const SegmentInfo* GetInfo() const;

    const Cues* GetCues() const;

    long long GetDuration() const;

    unsigned long GetCount() const;

    Cluster* GetFirst();

    Cluster* GetLast();

    Cluster* GetNext(const Cluster*);

    Cluster* FindCluster(long long time_nanoseconds);

    const BlockEntry* Seek(long long time_nanoseconds, const Track*);

private:

    long long m_pos;  //absolute file posn; what has been consumed so far

    SegmentInfo* m_pInfo;

    Tracks* m_pTracks;

    Cues* m_pCues;

    Cluster** m_clusters;

    long m_clusterCount;         //number of entries for which m_index >= 0

    long m_clusterPreloadCount;  //number of entries for which m_index < 0

    long m_clusterSize;          //array size

    void AppendCluster(Cluster*);

    void PreloadCluster(Cluster*, ptrdiff_t);

    void ParseSeekHead(long long pos, long long size);

    void ParseSeekEntry(long long pos, long long size);

    void ParseCues(long long);

    const BlockEntry* GetBlock(

        const CuePoint&,

        const CuePoint::TrackPosition&);

};

}  //end namespace mkvparser

#endif  //MKVPARSER_HPP