media/base/stream_parser_buffer.h

   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:
  23   DecodeTimestamp() {}
  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
  66   static DecodeTimestamp FromSecondsD(double seconds) {
  67     return DecodeTimestamp(base::TimeDelta::FromSecondsD(seconds));
  68   }
  69
  70   static DecodeTimestamp FromMilliseconds(int64 milliseconds) {
  71     return DecodeTimestamp(base::TimeDelta::FromMilliseconds(milliseconds));
  72   }
  73
  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.
  80   static DecodeTimestamp FromPresentationTime(base::TimeDelta timestamp) {
  81     return DecodeTimestamp(timestamp);
  82   }
  83
  84   double InSecondsF() const { return ts_.InSecondsF(); }
  85   int64 InMilliseconds() const { return ts_.InMilliseconds(); }
  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.
  90   base::TimeDelta ToPresentationTime() const { return ts_; }
  91
  92  private:
  93   explicit DecodeTimestamp(base::TimeDelta timestamp) : ts_(timestamp) { }
  94
  95   base::TimeDelta ts_;
  96 };
  97
  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_key_frame, 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_key_frame, Type type,
 118       TrackId track_id);
 119
 120   // Decode timestamp. If not explicitly set, or set to kNoTimestamp(), the
 121   // value will be taken from the normal timestamp.
 122   DecodeTimestamp GetDecodeTimestamp() const;
 123   void SetDecodeTimestamp(DecodeTimestamp timestamp);
 124
 125   // Gets/sets the ID of the decoder config associated with this buffer.
 126   int GetConfigId() const;
 127   void SetConfigId(int config_id);
 128
 129   // Returns the config ID of this buffer if it has no splice buffers or
 130   // |index| is out of range.  Otherwise returns the config ID for the
 131   // buffer in |splice_buffers_| at position |index|.
 132   int GetSpliceBufferConfigId(size_t index) const;
 133
 134   // Gets the parser's media type associated with this buffer. Value is
 135   // meaningless for EOS buffers.
 136   Type type() const { return type_; }
 137   const char* GetTypeName() const;
 138
 139   // Gets the parser's track ID associated with this buffer. Value is
 140   // meaningless for EOS buffers.
 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);
 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);
 168   const scoped_refptr<StreamParserBuffer>& preroll_buffer() {
 169     return preroll_buffer_;
 170   }
 171
 172   void set_timestamp(base::TimeDelta timestamp) override;
 173
 174   bool is_duration_estimated() const { return is_duration_estimated_; }
 175
 176   void set_is_duration_estimated(bool is_estimated) {
 177     is_duration_estimated_ = is_estimated;
 178   }
 179
 180  private:
 181   StreamParserBuffer(const uint8* data, int data_size,
 182                      const uint8* side_data, int side_data_size,
 183                      bool is_key_frame, Type type,
 184                      TrackId track_id);
 185   ~StreamParserBuffer() override;
 186
 187   DecodeTimestamp decode_timestamp_;
 188   int config_id_;
 189   Type type_;
 190   TrackId track_id_;
 191   BufferQueue splice_buffers_;
 192   scoped_refptr<StreamParserBuffer> preroll_buffer_;
 193   bool is_duration_estimated_;
 194
 195   DISALLOW_COPY_AND_ASSIGN(StreamParserBuffer);
 196 };
 197
 198 }  // namespace media
 199
 200 #endif  // MEDIA_BASE_STREAM_PARSER_BUFFER_H_