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_BASE_STREAM_PARSER_BUFFER_H_
6 #define MEDIA_BASE_STREAM_PARSER_BUFFER_H_
7
8 #include <deque>
9
10 #include "media/base/decoder_buffer.h"
11 #include "media/base/demuxer_stream.h"
12 #include "media/base/media_export.h"
13 #include "media/base/stream_parser.h"
14
15 namespace media {
16
17 // Simple wrapper around base::TimeDelta that represents a decode timestamp.
18 // Making DecodeTimestamp a different type makes it easier to determine whether
19 // code is operating on presentation or decode timestamps and makes conversions
20 // between the two types explicit and easy to spot.
21 class DecodeTimestamp {
22 public:
DecodeTimestamp()23 DecodeTimestamp() {}
DecodeTimestamp(const DecodeTimestamp & rhs)24 DecodeTimestamp(const DecodeTimestamp& rhs) : ts_(rhs.ts_) { }
25 DecodeTimestamp& operator=(const DecodeTimestamp& rhs) {
26 if (&rhs != this)
27 ts_ = rhs.ts_;
28 return *this;
29 }
30
31 // Only operators that are actually used by the code have been defined.
32 // Reviewers should pay close attention to the addition of new operators.
33 bool operator<(const DecodeTimestamp& rhs) const { return ts_ < rhs.ts_; }
34 bool operator>(const DecodeTimestamp& rhs) const { return ts_ > rhs.ts_; }
35 bool operator==(const DecodeTimestamp& rhs) const { return ts_ == rhs.ts_; }
36 bool operator!=(const DecodeTimestamp& rhs) const { return ts_ != rhs.ts_; }
37 bool operator>=(const DecodeTimestamp& rhs) const { return ts_ >= rhs.ts_; }
38 bool operator<=(const DecodeTimestamp& rhs) const { return ts_ <= rhs.ts_; }
39
40 base::TimeDelta operator-(const DecodeTimestamp& rhs) const {
41 return ts_ - rhs.ts_;
42 }
43
44 DecodeTimestamp& operator+=(const base::TimeDelta& rhs) {
45 ts_ += rhs;
46 return *this;
47 }
48
49 DecodeTimestamp& operator-=(const base::TimeDelta& rhs) {
50 ts_ -= rhs;
51 return *this;
52 }
53
54 DecodeTimestamp operator+(const base::TimeDelta& rhs) const {
55 return DecodeTimestamp(ts_ + rhs);
56 }
57
58 DecodeTimestamp operator-(const base::TimeDelta& rhs) const {
59 return DecodeTimestamp(ts_ - rhs);
60 }
61
62 int64 operator/(const base::TimeDelta& rhs) const {
63 return ts_ / rhs;
64 }
65
FromSecondsD(double seconds)66 static DecodeTimestamp FromSecondsD(double seconds) {
67 return DecodeTimestamp(base::TimeDelta::FromSecondsD(seconds));
68 }
69
FromMilliseconds(int64 milliseconds)70 static DecodeTimestamp FromMilliseconds(int64 milliseconds) {
71 return DecodeTimestamp(base::TimeDelta::FromMilliseconds(milliseconds));
72 }
73
FromMicroseconds(int64 microseconds)74 static DecodeTimestamp FromMicroseconds(int64 microseconds) {
75 return DecodeTimestamp(base::TimeDelta::FromMicroseconds(microseconds));
76 }
77
78 // This method is used to explicitly call out when presentation timestamps
79 // are being converted to a decode timestamp.
FromPresentationTime(base::TimeDelta timestamp)80 static DecodeTimestamp FromPresentationTime(base::TimeDelta timestamp) {
81 return DecodeTimestamp(timestamp);
82 }
83
InSecondsF()84 double InSecondsF() const { return ts_.InSecondsF(); }
InMilliseconds()85 int64 InMilliseconds() const { return ts_.InMilliseconds(); }
InMicroseconds()86 int64 InMicroseconds() const { return ts_.InMicroseconds(); }
87
88 // TODO(acolwell): Remove once all the hacks are gone. This method is called
89 // by hacks where a decode time is being used as a presentation time.
ToPresentationTime()90 base::TimeDelta ToPresentationTime() const { return ts_; }
91
92 private:
DecodeTimestamp(base::TimeDelta timestamp)93 explicit DecodeTimestamp(base::TimeDelta timestamp) : ts_(timestamp) { }
94
95 base::TimeDelta ts_;
96 };
97
kNoDecodeTimestamp()98 MEDIA_EXPORT extern inline DecodeTimestamp kNoDecodeTimestamp() {
99 return DecodeTimestamp::FromPresentationTime(kNoTimestamp());
100 }
101
102 class MEDIA_EXPORT StreamParserBuffer : public DecoderBuffer {
103 public:
104 // Value used to signal an invalid decoder config ID.
105 enum { kInvalidConfigId = -1 };
106
107 typedef DemuxerStream::Type Type;
108 typedef StreamParser::TrackId TrackId;
109
110 static scoped_refptr<StreamParserBuffer> CreateEOSBuffer();
111
112 static scoped_refptr<StreamParserBuffer> CopyFrom(
113 const uint8* data, int data_size, bool is_keyframe, Type type,
114 TrackId track_id);
115 static scoped_refptr<StreamParserBuffer> CopyFrom(
116 const uint8* data, int data_size,
117 const uint8* side_data, int side_data_size, bool is_keyframe, Type type,
118 TrackId track_id);
IsKeyframe()119 bool IsKeyframe() const { return is_keyframe_; }
120
121 // Decode timestamp. If not explicitly set, or set to kNoTimestamp(), the
122 // value will be taken from the normal timestamp.
123 DecodeTimestamp GetDecodeTimestamp() const;
124 void SetDecodeTimestamp(DecodeTimestamp timestamp);
125
126 // Gets/sets the ID of the decoder config associated with this buffer.
127 int GetConfigId() const;
128 void SetConfigId(int config_id);
129
130 // Returns the config ID of this buffer if it has no splice buffers or
131 // |index| is out of range. Otherwise returns the config ID for the
132 // buffer in |splice_buffers_| at position |index|.
133 int GetSpliceBufferConfigId(size_t index) const;
134
135 // Gets the parser's media type associated with this buffer. Value is
136 // meaningless for EOS buffers.
type()137 Type type() const { return type_; }
138
139 // Gets the parser's track ID associated with this buffer. Value is
140 // meaningless for EOS buffers.
track_id()141 TrackId track_id() const { return track_id_; }
142
143 // Converts this buffer to a splice buffer. |pre_splice_buffers| must not
144 // have any EOS buffers, must not have any splice buffers, nor must have any
145 // buffer with preroll.
146 //
147 // |pre_splice_buffers| will be deep copied and each copy's splice_timestamp()
148 // will be set to this buffer's splice_timestamp(). A copy of |this|, with a
149 // splice_timestamp() of kNoTimestamp(), will be added to the end of
150 // |splice_buffers_|.
151 //
152 // See the Audio Splice Frame Algorithm in the MSE specification for details.
153 typedef StreamParser::BufferQueue BufferQueue;
154 void ConvertToSpliceBuffer(const BufferQueue& pre_splice_buffers);
splice_buffers()155 const BufferQueue& splice_buffers() const { return splice_buffers_; }
156
157 // Specifies a buffer which must be decoded prior to this one to ensure this
158 // buffer can be accurately decoded. The given buffer must be of the same
159 // type, must not be a splice buffer, must not have any discard padding, and
160 // must not be an end of stream buffer. |preroll| is not copied.
161 //
162 // It's expected that this preroll buffer will be discarded entirely post
163 // decoding. As such it's discard_padding() will be set to kInfiniteDuration.
164 //
165 // All future timestamp, decode timestamp, config id, or track id changes to
166 // this buffer will be applied to the preroll buffer as well.
167 void SetPrerollBuffer(const scoped_refptr<StreamParserBuffer>& preroll);
preroll_buffer()168 const scoped_refptr<StreamParserBuffer>& preroll_buffer() {
169 return preroll_buffer_;
170 }
171
172 virtual void set_timestamp(base::TimeDelta timestamp) OVERRIDE;
173
174 private:
175 StreamParserBuffer(const uint8* data, int data_size,
176 const uint8* side_data, int side_data_size,
177 bool is_keyframe, Type type,
178 TrackId track_id);
179 virtual ~StreamParserBuffer();
180
181 bool is_keyframe_;
182 DecodeTimestamp decode_timestamp_;
183 int config_id_;
184 Type type_;
185 TrackId track_id_;
186 BufferQueue splice_buffers_;
187 scoped_refptr<StreamParserBuffer> preroll_buffer_;
188
189 DISALLOW_COPY_AND_ASSIGN(StreamParserBuffer);
190 };
191
192 } // namespace media
193
194 #endif // MEDIA_BASE_STREAM_PARSER_BUFFER_H_
195