libvpx: Pull from upstream

source/libvpx/third_party/libwebm/mkvparser.hpp

 // Copyright (c) 2012 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
@@ skipping 14 matching lines @@
 
  protected:
   virtual ~IMkvReader();
 };
 
 long long GetUIntLength(IMkvReader*, long long, long&);
 long long ReadUInt(IMkvReader*, long long, long&);
 long long UnserializeUInt(IMkvReader*, long long pos, long long size);
 
 long UnserializeFloat(IMkvReader*, long long pos, long long size, double&);
-long UnserializeInt(IMkvReader*, long long pos, long len, long long& result);
+long UnserializeInt(IMkvReader*, long long pos, long long size,
+                    long long& result);
 
 long UnserializeString(IMkvReader*, long long pos, long long size, char*& str);
 
 long ParseElementHeader(IMkvReader* pReader,
                         long long& pos,  // consume id and size fields
                         long long stop,  // if you know size of element's parent
                         long long& id, long long& size);
 
 bool Match(IMkvReader*, long long&, unsigned long, long long&);
 bool Match(IMkvReader*, long long&, unsigned long, unsigned char*&, size_t&);
@@ skipping 345 matching lines @@
   VideoTrack& operator=(const VideoTrack&);
 
   VideoTrack(Segment*, long long element_start, long long element_size);
 
  public:
   static long Parse(Segment*, const Info&, long long element_start,
                     long long element_size, VideoTrack*&);
 
   long long GetWidth() const;
   long long GetHeight() const;
+  long long GetDisplayWidth() const;
+  long long GetDisplayHeight() const;
+  long long GetDisplayUnit() const;
+  long long GetStereoMode() const;
   double GetFrameRate() const;
 
   bool VetEntry(const BlockEntry*) const;
   long Seek(long long time_ns, const BlockEntry*&) const;
 
  private:
   long long m_width;
   long long m_height;
+  long long m_display_width;
+  long long m_display_height;
+  long long m_display_unit;
+  long long m_stereo_mode;
+
   double m_rate;
 };
 
 class AudioTrack : public Track {
   AudioTrack(const AudioTrack&);
   AudioTrack& operator=(const AudioTrack&);
 
   AudioTrack(Segment*, long long element_start, long long element_size);
 
  public:
@@ skipping 156 matching lines @@
 
  private:
   long ParseEdition(long long pos, long long size);
   bool ExpandEditionsArray();
 
   Edition* m_editions;
   int m_editions_size;
   int m_editions_count;
 };
 
+class Tags {
+  Tags(const Tags&);
+  Tags& operator=(const Tags&);
+
+ public:
+  Segment* const m_pSegment;
+  const long long m_start;
+  const long long m_size;
+  const long long m_element_start;
+  const long long m_element_size;
+
+  Tags(Segment*, long long payload_start, long long payload_size,
+       long long element_start, long long element_size);
+
+  ~Tags();
+
+  long Parse();
+
+  class Tag;
+  class SimpleTag;
+
+  class SimpleTag {
+    friend class Tag;
+    SimpleTag();
+    SimpleTag(const SimpleTag&);
+    ~SimpleTag();
+    SimpleTag& operator=(const SimpleTag&);
+
+   public:
+    const char* GetTagName() const;
+    const char* GetTagString() const;
+
+   private:
+    void Init();
+    void ShallowCopy(SimpleTag&) const;
+    void Clear();
+    long Parse(IMkvReader*, long long pos, long long size);
+
+    char* m_tag_name;
+    char* m_tag_string;
+  };
+
+  class Tag {
+    friend class Tags;
+    Tag();
+    Tag(const Tag&);
+    ~Tag();
+    Tag& operator=(const Tag&);
+
+   public:
+    int GetSimpleTagCount() const;
+    const SimpleTag* GetSimpleTag(int index) const;
+
+   private:
+    void Init();
+    void ShallowCopy(Tag&) const;
+    void Clear();
+    long Parse(IMkvReader*, long long pos, long long size);
+
+    long ParseSimpleTag(IMkvReader*, long long pos, long long size);
+    bool ExpandSimpleTagsArray();
+
+    SimpleTag* m_simple_tags;
+    int m_simple_tags_size;
+    int m_simple_tags_count;
+  };
+
+  int GetTagCount() const;
+  const Tag* GetTag(int index) const;
+
+ private:
+  long ParseTag(long long pos, long long size);
+  bool ExpandTagsArray();
+
+  Tag* m_tags;
+  int m_tags_size;
+  int m_tags_count;
+};
+
 class SegmentInfo {
   SegmentInfo(const SegmentInfo&);
   SegmentInfo& operator=(const SegmentInfo&);
 
  public:
   Segment* const m_pSegment;
   const long long m_start;
   const long long m_size;
   const long long m_element_start;
   const long long m_element_size;
@@ skipping 82 matching lines @@
   CuePoint(long, long long);
   ~CuePoint();
 
   CuePoint(const CuePoint&);
   CuePoint& operator=(const CuePoint&);
 
  public:
   long long m_element_start;
   long long m_element_size;
 
-  void Load(IMkvReader*);
+  bool Load(IMkvReader*);
 
   long long GetTimeCode() const;  // absolute but unscaled
   long long GetTime(const 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);
+    bool Parse(IMkvReader*, long long, long long);
   };
 
   const TrackPosition* Find(const Track*) const;
 
  private:
   const long m_index;
   long long m_timecode;
   TrackPosition* m_track_positions;
   size_t m_track_positions_count;
 };
@@ skipping 12 matching lines @@
   Segment* const m_pSegment;
   const long long m_start;
   const long long m_size;
   const long long m_element_start;
   const long long m_element_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;
 
   bool LoadCuePoint() const;
   long GetCount() const;  // loaded only
   // long GetTotal() const;  //loaded + preloaded
   bool DoneParsing() const;
 
  private:
-  void Init() const;
+  bool Init() const;
   void PreloadCuePoint(long&, long long) const;
 
   mutable CuePoint** m_cue_points;
   mutable long m_count;
   mutable long m_preload_count;
   mutable long long m_pos;
 };
 
 class Cluster {
   friend class Segment;
@@ skipping 105 matching lines @@
   // long long Unparsed() const;
   bool DoneParsing() const;
   long long ParseHeaders();  // stops when first cluster is found
   // long FindNextCluster(long long& pos, long& size) const;
   long LoadCluster(long long& pos, long& size);  // load one cluster
   long LoadCluster();
 
   long ParseNext(const Cluster* pCurr, const Cluster*& pNext, long long& pos,
                  long& size);
 
-#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(long long& cluster_pos, long long& new_pos) const;
-    bool AddCluster(long long cluster_pos, long long new_pos);
-#endif
-
   const SeekHead* GetSeekHead() const;
   const Tracks* GetTracks() const;
   const SegmentInfo* GetInfo() const;
   const Cues* GetCues() const;
   const Chapters* GetChapters() const;
+  const Tags* GetTags() const;
 
   long long GetDuration() const;
 
   unsigned long GetCount() const;
   const Cluster* GetFirst() const;
   const Cluster* GetLast() const;
   const Cluster* GetNext(const Cluster*);
 
   const Cluster* FindCluster(long long time_nanoseconds) const;
   // const BlockEntry* Seek(long long time_nanoseconds, const Track*) const;
 
   const Cluster* FindOrPreloadCluster(long long pos);
 
   long ParseCues(long long cues_off,  // offset relative to start of segment
                  long long& parse_pos, long& parse_len);
 
  private:
   long long m_pos;  // absolute file posn; what has been consumed so far
   Cluster* m_pUnknownSize;
 
   SeekHead* m_pSeekHead;
   SegmentInfo* m_pInfo;
   Tracks* m_pTracks;
   Cues* m_pCues;
   Chapters* m_pChapters;
+  Tags* m_pTags;
   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
 
   long DoLoadCluster(long long&, long&);
   long DoLoadClusterUnknownSize(long long&, long&);
   long DoParseNext(const Cluster*&, long long&, long&);
 
   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
 
 inline long mkvparser::Segment::LoadCluster() {
   long long pos;
   long size;
 
   return LoadCluster(pos, size);
 }
 
 #endif  // MKVPARSER_HPP