Introduce DecodeTimestamp class to make it easier to distiguish presentation and decode timestamps.

media/base/stream_parser_buffer.h

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #ifndef MEDIA_BASE_STREAM_PARSER_BUFFER_H_
 #define MEDIA_BASE_STREAM_PARSER_BUFFER_H_
 
 #include <deque>
 
 #include "media/base/decoder_buffer.h"
 #include "media/base/demuxer_stream.h"
 #include "media/base/media_export.h"
 #include "media/base/stream_parser.h"
 
 namespace media {
 
+// Simple wrapper around base::TimeDelta that represents a decode timestamp.
+// Making DecodeTimestamp a different type makes it easier to determine whether
+// code is operating on presentation or decode timestamps and makes conversions
+// between the two types explicit and easy to spot.
+class DecodeTimestamp {
+ public:
+  DecodeTimestamp() {};

[wolenetz, 2014/08/08 21:30:04]

lint nit: s/;//

[acolwell GONE FROM CHROMIUM, 2014/08/11 17:05:05]

Done.

+  DecodeTimestamp(const DecodeTimestamp& rhs) : ts_(rhs.ts_) { }
+  DecodeTimestamp& operator=(const DecodeTimestamp& rhs) {
+    if (&rhs != this)
+      ts_ = rhs.ts_;
+    return *this;
+  }
+
+  bool operator<(const DecodeTimestamp& rhs) const { return ts_ < rhs.ts_; }
+  bool operator>(const DecodeTimestamp& rhs) const  { return ts_ > rhs.ts_; }
+  bool operator==(const DecodeTimestamp& rhs) const  { return ts_ == rhs.ts_; }
+  bool operator!=(const DecodeTimestamp& rhs) const  { return ts_ != rhs.ts_; }
+  bool operator>=(const DecodeTimestamp& rhs) const  { return ts_ >= rhs.ts_; }
+  bool operator<=(const DecodeTimestamp& rhs) const  { return ts_ <= rhs.ts_; }
+
+  base::TimeDelta operator-(const DecodeTimestamp& rhs) const {
+    return ts_ - rhs.ts_;
+  }
+
+  DecodeTimestamp& operator+=(const base::TimeDelta& rhs) {
+    ts_ += rhs;
+    return *this;
+  }
+
+  DecodeTimestamp& operator-=(const base::TimeDelta& rhs)  {
+    ts_ -= rhs;
+    return *this;
+  }
+
+  DecodeTimestamp operator+(const base::TimeDelta& rhs) const {

[wolenetz, 2014/08/08 21:30:04]

nit: Is there no expected need for adding two DTS? I'm struggling to find where
this might be useful, but if so, we could add something like:
DecodeTimestamp operator+(const DecodeTimestamp& rhs) const {
  return DecodeTimestamp(ts_ - rhs.ts_);
}

[acolwell GONE FROM CHROMIUM, 2014/08/11 17:05:05]

I can't think of any reason to do that. I've only added operators that are
actually being used right now. We can add such an operator when it is actually
needed.

[wolenetz, 2014/08/12 00:09:00]

Acknowledged.

+    return DecodeTimestamp(ts_ + rhs);
+  }
+
+  DecodeTimestamp operator-(const base::TimeDelta& rhs) const {
+    return DecodeTimestamp(ts_ - rhs);
+  }
+
+  int64 operator/(const base::TimeDelta& rhs) const {

[wolenetz, 2014/08/08 21:30:04]

nit: Is there no expected need for dividing or multiplying a DTS by an int? Like
above, I suppose we could add if and when that might be necessary, unless you
have specific reason why we shouldn't ever add such. (and if so, please document
that reason in code comment here)

[acolwell GONE FROM CHROMIUM, 2014/08/11 17:05:05]

I am only implementing operators that are actually being used. When other
operators are actually needed they can be added.

[wolenetz, 2014/08/12 00:09:00]

Acknowledged.

+    return ts_ / rhs;
+  }
+
+  static DecodeTimestamp FromSecondsD(double seconds) {
+    return DecodeTimestamp(base::TimeDelta::FromSecondsD(seconds));
+  }
+
+  static DecodeTimestamp FromMilliseconds(int64 milliseconds) {
+    return DecodeTimestamp(base::TimeDelta::FromMilliseconds(milliseconds));
+  }
+
+  static DecodeTimestamp FromMicroseconds(int64 microseconds) {
+    return DecodeTimestamp(base::TimeDelta::FromMicroseconds(microseconds));
+  }
+
+  // This method is used to explicitly call out when presentation timestamps
+  // are being converted to a decode timestamp.
+  static DecodeTimestamp FromPresentationTime(base::TimeDelta timestamp) {
+    return DecodeTimestamp(timestamp);
+  }
+
+  double InSecondsF() const { return ts_.InSecondsF(); }
+  int64 InMilliseconds() const { return ts_.InMilliseconds(); }
+  int64 InMicroseconds() const { return ts_.InMicroseconds(); }
+
+  // TODO(acolwell): Remove once all the hacks are gone. This method is called
+  // by hacks where a decode time is being used as a presentation time.
+  base::TimeDelta ToPresentationTime() const { return ts_; }
+
+ private:
+  explicit DecodeTimestamp(base::TimeDelta timestamp) : ts_(timestamp) { }
+
+  base::TimeDelta ts_;
+};
+
+MEDIA_EXPORT extern inline DecodeTimestamp kNoDecodeTimestamp() {
+  return DecodeTimestamp::FromPresentationTime(kNoTimestamp());
+}
+
 class MEDIA_EXPORT StreamParserBuffer : public DecoderBuffer {
  public:
   // Value used to signal an invalid decoder config ID.
   enum { kInvalidConfigId = -1 };
 
   typedef DemuxerStream::Type Type;
   typedef StreamParser::TrackId TrackId;
 
   static scoped_refptr<StreamParserBuffer> CreateEOSBuffer();
 
   static scoped_refptr<StreamParserBuffer> CopyFrom(
       const uint8* data, int data_size, bool is_keyframe, Type type,
       TrackId track_id);
   static scoped_refptr<StreamParserBuffer> CopyFrom(
       const uint8* data, int data_size,
       const uint8* side_data, int side_data_size, bool is_keyframe, Type type,
       TrackId track_id);
   bool IsKeyframe() const { return is_keyframe_; }
 
   // Decode timestamp. If not explicitly set, or set to kNoTimestamp(), the
   // value will be taken from the normal timestamp.
-  base::TimeDelta GetDecodeTimestamp() const;
-  void SetDecodeTimestamp(base::TimeDelta timestamp);
+  DecodeTimestamp GetDecodeTimestamp() const;
+  void SetDecodeTimestamp(DecodeTimestamp timestamp);
 
   // Gets/sets the ID of the decoder config associated with this buffer.
   int GetConfigId() const;
   void SetConfigId(int config_id);
 
   // Gets the parser's media type associated with this buffer. Value is
   // meaningless for EOS buffers.
   Type type() const { return type_; }
 
   // Gets the parser's track ID associated with this buffer. Value is
@@ skipping 32 matching lines @@
   virtual void set_timestamp(base::TimeDelta timestamp) OVERRIDE;
 
  private:
   StreamParserBuffer(const uint8* data, int data_size,
                      const uint8* side_data, int side_data_size,
                      bool is_keyframe, Type type,
                      TrackId track_id);
   virtual ~StreamParserBuffer();
 
   bool is_keyframe_;
-  base::TimeDelta decode_timestamp_;
+  DecodeTimestamp decode_timestamp_;
   int config_id_;
   Type type_;
   TrackId track_id_;
   BufferQueue splice_buffers_;
   scoped_refptr<StreamParserBuffer> preroll_buffer_;
 
   DISALLOW_COPY_AND_ASSIGN(StreamParserBuffer);
 };
 
 }  // namespace media
 
 #endif  // MEDIA_BASE_STREAM_PARSER_BUFFER_H_