Added IsEndOfStream and IsDiscontiguous flags to buffers.

media/base/buffers.h

-// Copyright (c) 2006-2008 The Chromium Authors. All rights reserved.
+// Copyright (c) 2008-2009 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.
 
 // Defines various types of timestamped media buffers used for transporting
 // data between filters.  Every buffer contains a timestamp in microseconds
 // describing the relative position of the buffer within the media stream, and
 // the duration in microseconds for the length of time the buffer will be
 // rendered.
 //
 // Timestamps are derived directly from the encoded media file and are commonly
@@ skipping 17 matching lines @@
 
 #include "base/logging.h"
 #include "base/ref_counted.h"
 #include "base/time.h"
 
 namespace media {
 
 class StreamSample : public base::RefCountedThreadSafe<StreamSample> {
  public:
   // Returns the timestamp of this buffer in microseconds.
-  virtual base::TimeDelta GetTimestamp() const = 0;
+  base::TimeDelta GetTimestamp() const {
+    return timestamp_;
+  }
 
   // Returns the duration of this buffer in microseconds.
-  virtual base::TimeDelta GetDuration() const = 0;
+  base::TimeDelta GetDuration() const {
+    return duration_;
+  }
+
+  // Indicates that the sample is the last one in the stream.
+  bool IsEndOfStream() const {
+    return end_of_stream_;
+  }
+
+  // Indicates that this sample is discontinuous from the previous one, for
+  // example, following a seek.
+  bool IsDiscontinuous() const {
+    return discontinuous_;
+  }
 
   // Sets the timestamp of this buffer in microseconds.
-  virtual void SetTimestamp(const base::TimeDelta& timestamp) = 0;
+  void SetTimestamp(const base::TimeDelta& timestamp) {
+    timestamp_ = timestamp;
+  }
 
   // Sets the duration of this buffer in microseconds.
-  virtual void SetDuration(const base::TimeDelta& duration) = 0;
+  void SetDuration(const base::TimeDelta& duration) {
+    duration_ = duration;
+  }
+
+  // Sets the value returned by IsEndOfStream().
+  void SetEndOfStream(bool end_of_stream) {
+    end_of_stream_ = end_of_stream;
+  }
+
+  // Sets the value returned by IsDiscontinuous().
+  void SetDiscontinuous(bool discontinuous) {
+    discontinuous_ = discontinuous;
+  }
 
  protected:
   friend class base::RefCountedThreadSafe<StreamSample>;
+  StreamSample()
+      : end_of_stream_(false),
+        discontinuous_(false) {
+  }
   virtual ~StreamSample() {}
+
+  base::TimeDelta timestamp_;
+  base::TimeDelta duration_;
+  bool end_of_stream_;
+  bool discontinuous_;
+
+ private:
+  DISALLOW_COPY_AND_ASSIGN(StreamSample);
 };
 
 
 class Buffer : public StreamSample {
  public:
   // Returns a read only pointer to the buffer data.
   virtual const char* GetData() const = 0;
 
   // Returns the size of valid data in bytes.
   virtual size_t GetDataSize() const = 0;
@@ skipping 64 matching lines @@
 
 
 // An interface for receiving the results of an asynchronous read.  Downstream
 // filters typically implement this interface or use AssignableBuffer and
 // provide it to upstream filters as a read request.  When the upstream filter
 // has completed the read, they call SetBuffer/OnAssignment to notify the
 // downstream filter.
 //
 // TODO(scherkus): rethink the Assignable interface -- it's a bit kludgy.
 template <class BufferType>
-class Assignable :
-    public base::RefCountedThreadSafe< Assignable<BufferType> > {
+class Assignable
+    : public base::RefCountedThreadSafe< Assignable<BufferType> > {
  public:
   // Assigns a buffer to the owner.
   virtual void SetBuffer(BufferType* buffer) = 0;
 
   // Notifies the owner that an assignment has been completed.
   virtual void OnAssignment() = 0;
 
   // TODO(scherkus): figure out a solution to friending a template.
   // See http://www.comeaucomputing.com/techtalk/templates/#friendclassT for
   // an explanation.
-  //protected:
+  // protected:
   // friend class base::RefCountedThreadSafe< Assignable<class T> >;
   virtual ~Assignable() {}
 };
 
 
 // Template for easily creating Assignable buffers.  Pass in the pointer of the
 // object to receive the OnAssignment callback.
 template <class OwnerType, class BufferType>
 class AssignableBuffer : public Assignable<BufferType> {
  public:
@@ skipping 15 matching lines @@
  private:
   OwnerType* owner_;
   scoped_refptr<BufferType> buffer_;
 
   DISALLOW_COPY_AND_ASSIGN(AssignableBuffer);
 };
 
 }  // namespace media
 
 #endif  // MEDIA_BASE_BUFFERS_H_