1// Copyright (c) 2012 The Chromium Authors. All rights reserved.
2// Use of this source code is governed by a BSD-style license that can be
3// found in the LICENSE file.
4
5#ifndef MEDIA_WEBM_WEBM_CLUSTER_PARSER_H_
6#define MEDIA_WEBM_WEBM_CLUSTER_PARSER_H_
7
8#include <deque>
9#include <map>
10#include <set>
11#include <string>
12
13#include "base/memory/scoped_ptr.h"
14#include "media/base/media_export.h"
15#include "media/base/media_log.h"
16#include "media/base/stream_parser_buffer.h"
17#include "media/webm/webm_parser.h"
18#include "media/webm/webm_tracks_parser.h"
19
20namespace media {
21
22class MEDIA_EXPORT WebMClusterParser : public WebMParserClient {
23 private:
24  // Helper class that manages per-track state.
25  class Track {
26   public:
27    Track(int track_num, bool is_video);
28    ~Track();
29
30    int track_num() const { return track_num_; }
31    const std::deque<scoped_refptr<StreamParserBuffer> >& buffers() const {
32      return buffers_;
33    }
34
35    bool AddBuffer(const scoped_refptr<StreamParserBuffer>& buffer);
36
37    // Clears all buffer state.
38    void Reset();
39
40    // Helper function used to inspect block data to determine if the
41    // block is a keyframe.
42    // |data| contains the bytes in the block.
43    // |size| indicates the number of bytes in |data|.
44    bool IsKeyframe(const uint8* data, int size) const;
45
46   private:
47    int track_num_;
48    std::deque<scoped_refptr<StreamParserBuffer> > buffers_;
49    bool is_video_;
50  };
51
52  typedef std::map<int, Track> TextTrackMap;
53
54 public:
55  typedef std::deque<scoped_refptr<StreamParserBuffer> > BufferQueue;
56
57  class MEDIA_EXPORT TextTrackIterator {
58   public:
59    explicit TextTrackIterator(const TextTrackMap& text_track_map);
60    TextTrackIterator(const TextTrackIterator& rhs);
61    ~TextTrackIterator();
62
63    // To visit each text track.  If the iterator is exhausted, it returns
64    // as parameters the values 0 and NULL, and the function returns false.
65    // Otherwise, it returns the buffers for the associated track, and the
66    // function returns true.
67    bool operator()(int* track_num, const BufferQueue** buffers);
68   private:
69    TextTrackIterator& operator=(const TextTrackIterator&);
70
71    TextTrackMap::const_iterator iterator_;
72    const TextTrackMap::const_iterator iterator_end_;
73  };
74
75  WebMClusterParser(int64 timecode_scale,
76                    int audio_track_num,
77                    int video_track_num,
78                    const WebMTracksParser::TextTracks& text_tracks,
79                    const std::set<int64>& ignored_tracks,
80                    const std::string& audio_encryption_key_id,
81                    const std::string& video_encryption_key_id,
82                    const LogCB& log_cb);
83  virtual ~WebMClusterParser();
84
85  // Resets the parser state so it can accept a new cluster.
86  void Reset();
87
88  // Parses a WebM cluster element in |buf|.
89  //
90  // Returns -1 if the parse fails.
91  // Returns 0 if more data is needed.
92  // Returns the number of bytes parsed on success.
93  int Parse(const uint8* buf, int size);
94
95  base::TimeDelta cluster_start_time() const { return cluster_start_time_; }
96  const BufferQueue& audio_buffers() const { return audio_.buffers(); }
97  const BufferQueue& video_buffers() const { return video_.buffers(); }
98
99  // Returns an iterator object, allowing each text track to be visited.
100  TextTrackIterator CreateTextTrackIterator() const;
101
102  // Returns true if the last Parse() call stopped at the end of a cluster.
103  bool cluster_ended() const { return cluster_ended_; }
104
105 private:
106  // WebMParserClient methods.
107  virtual WebMParserClient* OnListStart(int id) OVERRIDE;
108  virtual bool OnListEnd(int id) OVERRIDE;
109  virtual bool OnUInt(int id, int64 val) OVERRIDE;
110  virtual bool OnBinary(int id, const uint8* data, int size) OVERRIDE;
111
112  bool ParseBlock(bool is_simple_block, const uint8* buf, int size,
113                  const uint8* additional, int additional_size, int duration,
114                  int64 discard_padding);
115  bool OnBlock(bool is_simple_block, int track_num, int timecode, int duration,
116               int flags, const uint8* data, int size,
117               const uint8* additional, int additional_size,
118               int64 discard_padding);
119
120  // Resets the Track objects associated with each text track.
121  void ResetTextTracks();
122
123  // Search for the indicated track_num among the text tracks.  Returns NULL
124  // if that track num is not a text track.
125  Track* FindTextTrack(int track_num);
126
127  double timecode_multiplier_;  // Multiplier used to convert timecodes into
128                                // microseconds.
129  std::set<int64> ignored_tracks_;
130  std::string audio_encryption_key_id_;
131  std::string video_encryption_key_id_;
132
133  WebMListParser parser_;
134
135  int64 last_block_timecode_;
136  scoped_ptr<uint8[]> block_data_;
137  int block_data_size_;
138  int64 block_duration_;
139  int64 block_add_id_;
140  scoped_ptr<uint8[]> block_additional_data_;
141  int block_additional_data_size_;
142  int64 discard_padding_;
143  bool discard_padding_set_;
144
145  int64 cluster_timecode_;
146  base::TimeDelta cluster_start_time_;
147  bool cluster_ended_;
148
149  Track audio_;
150  Track video_;
151  TextTrackMap text_track_map_;
152  LogCB log_cb_;
153
154  DISALLOW_IMPLICIT_CONSTRUCTORS(WebMClusterParser);
155};
156
157}  // namespace media
158
159#endif  // MEDIA_WEBM_WEBM_CLUSTER_PARSER_H_
160