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

media/filters/frame_processor.cc

 // Copyright 2014 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.
 
 #include "media/filters/frame_processor.h"
 
 #include <cstdlib>
 
 #include "base/stl_util.h"
 #include "media/base/buffers.h"
 #include "media/base/stream_parser_buffer.h"
 
 namespace media {
 
 // Helper class to capture per-track details needed by a frame processor. Some
 // of this information may be duplicated in the short-term in the associated
 // ChunkDemuxerStream and SourceBufferStream for a track.
 // This parallels the MSE spec each of a SourceBuffer's Track Buffers at
 // http://www.w3.org/TR/media-source/#track-buffers.
 class MseTrackBuffer {
  public:
   explicit MseTrackBuffer(ChunkDemuxerStream* stream);
   ~MseTrackBuffer();
 
   // Get/set |last_decode_timestamp_|.
-  base::TimeDelta last_decode_timestamp() const {
+  DecodeTimestamp last_decode_timestamp() const {
     return last_decode_timestamp_;
   }
-  void set_last_decode_timestamp(base::TimeDelta timestamp) {
+  void set_last_decode_timestamp(DecodeTimestamp timestamp) {
     last_decode_timestamp_ = timestamp;
   }
 
   // Get/set |last_frame_duration_|.
   base::TimeDelta last_frame_duration() const {
     return last_frame_duration_;
   }
   void set_last_frame_duration(base::TimeDelta duration) {
     last_frame_duration_ = duration;
   }
@@ skipping 31 matching lines @@
   void EnqueueProcessedFrame(const scoped_refptr<StreamParserBuffer>& frame);
 
   // Appends |processed_frames_|, if not empty, to |stream_| and clears
   // |processed_frames_|. Returns false if append failed, true otherwise.
   // |processed_frames_| is cleared in both cases.
   bool FlushProcessedFrames();
 
  private:
   // The decode timestamp of the last coded frame appended in the current coded
   // frame group. Initially kNoTimestamp(), meaning "unset".
-  base::TimeDelta last_decode_timestamp_;
+  DecodeTimestamp last_decode_timestamp_;
 
   // The coded frame duration of the last coded frame appended in the current
   // coded frame group. Initially kNoTimestamp(), meaning "unset".
   base::TimeDelta last_frame_duration_;
 
   // The highest presentation timestamp encountered in a coded frame appended
   // in the current coded frame group. Initially kNoTimestamp(), meaning
   // "unset".
   base::TimeDelta highest_presentation_timestamp_;
 
   // Keeps track of whether the track buffer is waiting for a random access
   // point coded frame. Initially set to true to indicate that a random access
   // point coded frame is needed before anything can be added to the track
   // buffer.
   bool needs_random_access_point_;
 
   // Pointer to the stream associated with this track. The stream is not owned
   // by |this|.
   ChunkDemuxerStream* const stream_;
 
   // Queue of processed frames that have not yet been appended to |stream_|.
   // EnqueueProcessedFrame() adds to this queue, and FlushProcessedFrames()
   // clears it.
   StreamParser::BufferQueue processed_frames_;
 
   DISALLOW_COPY_AND_ASSIGN(MseTrackBuffer);
 };
 
 MseTrackBuffer::MseTrackBuffer(ChunkDemuxerStream* stream)
-    : last_decode_timestamp_(kNoTimestamp()),
+    : last_decode_timestamp_(kNoDecodeTimestamp()),
       last_frame_duration_(kNoTimestamp()),
       highest_presentation_timestamp_(kNoTimestamp()),
       needs_random_access_point_(true),
       stream_(stream) {
   DCHECK(stream_);
 }
 
 MseTrackBuffer::~MseTrackBuffer() {
   DVLOG(2) << __FUNCTION__ << "()";
 }
 
 void MseTrackBuffer::Reset() {
   DVLOG(2) << __FUNCTION__ << "()";
 
-  last_decode_timestamp_ = kNoTimestamp();
+  last_decode_timestamp_ = kNoDecodeTimestamp();
   last_frame_duration_ = kNoTimestamp();
   highest_presentation_timestamp_ = kNoTimestamp();
   needs_random_access_point_ = true;
 }
 
 void MseTrackBuffer::SetHighestPresentationTimestampIfIncreased(
     base::TimeDelta timestamp) {
   if (highest_presentation_timestamp_ == kNoTimestamp() ||
       timestamp > highest_presentation_timestamp_) {
     highest_presentation_timestamp_ = timestamp;
@@ skipping 158 matching lines @@
 
 MseTrackBuffer* FrameProcessor::FindTrack(StreamParser::TrackId id) {
   TrackBufferMap::iterator itr = track_buffers_.find(id);
   if (itr == track_buffers_.end())
     return NULL;
 
   return itr->second;
 }
 
 void FrameProcessor::NotifyNewMediaSegmentStarting(
-    base::TimeDelta segment_timestamp) {
+    DecodeTimestamp segment_timestamp) {
   DVLOG(2) << __FUNCTION__ << "(" << segment_timestamp.InSecondsF() << ")";
 
   for (TrackBufferMap::iterator itr = track_buffers_.begin();
        itr != track_buffers_.end();
        ++itr) {
     itr->second->stream()->OnNewMediaSegment(segment_timestamp);
   }
 }
 
 bool FrameProcessor::FlushProcessedFrames() {
@@ skipping 67 matching lines @@
              << " frame_end_timestamp " << frame_end_timestamp.InSecondsF()
              << " append_window_start " << append_window_start.InSecondsF();
 
     // Mark the overlapping portion of the buffer for discard.
     buffer->set_discard_padding(std::make_pair(
         append_window_start - buffer->timestamp(), base::TimeDelta()));
 
     // Adjust the timestamp of this buffer forward to |append_window_start| and
     // decrease the duration to compensate.
     buffer->set_timestamp(append_window_start);
-    buffer->SetDecodeTimestamp(append_window_start);
+    buffer->SetDecodeTimestamp(
+        DecodeTimestamp::FromPresentationTime(append_window_start));
     buffer->set_duration(frame_end_timestamp - append_window_start);
     processed_buffer = true;
   }
 
   // See if a partial discard can be done around |append_window_end|.
   if (frame_end_timestamp > append_window_end) {
     DVLOG(1) << "Truncating buffer which overlaps append window end."
              << " presentation_timestamp " << buffer->timestamp().InSecondsF()
              << " frame_end_timestamp " << frame_end_timestamp.InSecondsF()
              << " append_window_end " << append_window_end.InSecondsF();
@@ skipping 23 matching lines @@
   //     media-source.html#sourcebuffer-coded-frame-processing
 
   while (true) {
     // 1. Loop Top: Let presentation timestamp be a double precision floating
     //    point representation of the coded frame's presentation timestamp in
     //    seconds.
     // 2. Let decode timestamp be a double precision floating point
     //    representation of the coded frame's decode timestamp in seconds.
     // 3. Let frame duration be a double precision floating point representation
     //    of the coded frame's duration in seconds.
-    // We use base::TimeDelta instead of double.
+    // We use base::TimeDelta and DecodeTimestamp instead of double.
     base::TimeDelta presentation_timestamp = frame->timestamp();
-    base::TimeDelta decode_timestamp = frame->GetDecodeTimestamp();
+    DecodeTimestamp decode_timestamp = frame->GetDecodeTimestamp();
     base::TimeDelta frame_duration = frame->duration();
 
     DVLOG(3) << __FUNCTION__ << ": Processing frame "
              << "Type=" << frame->type()
              << ", TrackID=" << frame->track_id()
              << ", PTS=" << presentation_timestamp.InSecondsF()
              << ", DTS=" << decode_timestamp.InSecondsF()
              << ", DUR=" << frame_duration.InSecondsF()
              << ", RAP=" << frame->IsKeyframe();
 
     // Sanity check the timestamps.
     if (presentation_timestamp == kNoTimestamp()) {
       DVLOG(2) << __FUNCTION__ << ": Unknown frame PTS";
       return false;
     }
-    if (decode_timestamp == kNoTimestamp()) {
+    if (decode_timestamp == kNoDecodeTimestamp()) {
       DVLOG(2) << __FUNCTION__ << ": Unknown frame DTS";
       return false;
     }
-    if (decode_timestamp > presentation_timestamp) {
+    if (decode_timestamp.ToPresentationTime() > presentation_timestamp) {
       // TODO(wolenetz): Determine whether DTS>PTS should really be allowed. See
       // http://crbug.com/354518.
       DVLOG(2) << __FUNCTION__ << ": WARNING: Frame DTS("
                << decode_timestamp.InSecondsF() << ") > PTS("
                << presentation_timestamp.InSecondsF() << ")";
     }
 
     // TODO(acolwell/wolenetz): All stream parsers must emit valid (positive)
     // frame durations. For now, we allow non-negative frame duration.
     // See http://crbug.com/351166.
@@ skipping 67 matching lines @@
                << ", parser track id=" << frame->track_id();
       return false;
     }
 
     // 7. If last decode timestamp for track buffer is set and decode timestamp
     //    is less than last decode timestamp
     //    OR
     //    If last decode timestamp for track buffer is set and the difference
     //    between decode timestamp and last decode timestamp is greater than 2
     //    times last frame duration:
-    base::TimeDelta last_decode_timestamp =
+    DecodeTimestamp last_decode_timestamp =
         track_buffer->last_decode_timestamp();
-    if (last_decode_timestamp != kNoTimestamp()) {
+    if (last_decode_timestamp != kNoDecodeTimestamp()) {
       base::TimeDelta dts_delta = decode_timestamp - last_decode_timestamp;
       if (dts_delta < base::TimeDelta() ||
           dts_delta > 2 * track_buffer->last_frame_duration()) {
         // 7.1. If mode equals "segments": Set group end timestamp to
         //      presentation timestamp.
         //      If mode equals "sequence": Set group start timestamp equal to
         //      the group end timestamp.
         if (!sequence_mode_) {
           group_end_timestamp_ = presentation_timestamp;
           // This triggers a discontinuity so we need to treat the next frames
@@ skipping 59 matching lines @@
       return true;
     }
 
     // Note: This step is relocated, versus April 1 spec, to allow append window
     // processing to first filter coded frames shifted by |timestamp_offset_| in
     // such a way that their PTS is negative.
     // 8. If the presentation timestamp or decode timestamp is less than the
     // presentation start time, then run the end of stream algorithm with the
     // error parameter set to "decode", and abort these steps.
     DCHECK(presentation_timestamp >= base::TimeDelta());
-    if (decode_timestamp < base::TimeDelta()) {
+    if (decode_timestamp < DecodeTimestamp()) {
       // B-frames may still result in negative DTS here after being shifted by
       // |timestamp_offset_|.
       DVLOG(2) << __FUNCTION__
                << ": frame PTS=" << presentation_timestamp.InSecondsF()
                << " has negative DTS=" << decode_timestamp.InSecondsF()
                << " after applying timestampOffset, handling any discontinuity,"
                << " and filtering against append window";
       return false;
     }
 
@@ skipping 16 matching lines @@
     // We now have a processed buffer to append to the track buffer's stream.
     // If it is the first in a new media segment or following a discontinuity,
     // notify all the track buffers' streams that a new segment is beginning.
     if (*new_media_segment) {
       // First, complete the append to track buffer streams of previous media
       // segment's frames, if any.
       if (!FlushProcessedFrames())
         return false;
 
       *new_media_segment = false;
+
+      // TODO(acolwell/wolenetz): This should be changed to a presentation
+      // timestamp. See http://crbug.com/402502
       NotifyNewMediaSegmentStarting(decode_timestamp);
     }
 
     DVLOG(3) << __FUNCTION__ << ": Sending processed frame to stream, "
              << "PTS=" << presentation_timestamp.InSecondsF()
              << ", DTS=" << decode_timestamp.InSecondsF();
 
     // Steps 13-18: Note, we optimize by appending groups of contiguous
     // processed frames for each track buffer at end of ProcessFrames() or prior
     // to NotifyNewMediaSegmentStarting().
@@ skipping 21 matching lines @@
     DCHECK(group_end_timestamp_ >= base::TimeDelta());
 
     return true;
   }
 
   NOTREACHED();
   return false;
 }
 
 }  // namespace media