MSE: Optimize frame processor appends to streams

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"
@@ skipping 49 matching lines @@
   void Reset();
 
   // If |highest_presentation_timestamp_| is unset or |timestamp| is greater
   // than |highest_presentation_timestamp_|, sets
   // |highest_presentation_timestamp_| to |timestamp|. Note that bidirectional
   // prediction between coded frames can cause |timestamp| to not be
   // monotonically increasing even though the decode timestamps are
   // monotonically increasing.
   void SetHighestPresentationTimestampIfIncreased(base::TimeDelta timestamp);
 
+  // Adds |frame_| to the end of |processed_frames_|.

[acolwell GONE FROM CHROMIUM, 2014/07/09 00:11:47]

nit: s/frame_/frame/

[wolenetz, 2014/07/09 18:23:29]

Done.

+  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_;
 
   // 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_frame_duration_(kNoTimestamp()),
       highest_presentation_timestamp_(kNoTimestamp()),
       needs_random_access_point_(true),
       stream_(stream) {
   DCHECK(stream_);
@@ skipping 13 matching lines @@
 }
 
 void MseTrackBuffer::SetHighestPresentationTimestampIfIncreased(
     base::TimeDelta timestamp) {
   if (highest_presentation_timestamp_ == kNoTimestamp() ||
       timestamp > highest_presentation_timestamp_) {
     highest_presentation_timestamp_ = timestamp;
   }
 }
 
+void MseTrackBuffer::EnqueueProcessedFrame(
+    const scoped_refptr<StreamParserBuffer>& frame) {
+  processed_frames_.push_back(frame);
+}
+
+bool MseTrackBuffer::FlushProcessedFrames() {
+  if (processed_frames_.empty())
+    return true;
+
+  bool result = stream_->Append(processed_frames_);
+  processed_frames_.clear();
+  if (!result) {
+    DVLOG(3) << __FUNCTION__

[damienv1, 2014/07/09 01:59:24]

nit: DVLOG_IF

[wolenetz, 2014/07/09 18:23:29]

Done.

+             << "(): Failure appending processed frames to stream";
+  }
+
+  return result;
+}
+
 FrameProcessor::FrameProcessor(const UpdateDurationCB& update_duration_cb)
     : sequence_mode_(false),
       group_start_timestamp_(kNoTimestamp()),
       update_duration_cb_(update_duration_cb) {
   DVLOG(2) << __FUNCTION__ << "()";
   DCHECK(!update_duration_cb.is_null());
 }
 
 FrameProcessor::~FrameProcessor() {
   DVLOG(2) << __FUNCTION__ << "()";
@@ skipping 36 matching lines @@
   // Note that ProcessFrame() implements an inner loop for a single frame that
   // handles "jump to the Loop Top step to restart processing of the current
   // coded frame" per April 1, 2014 MSE spec editor's draft:
   // https://dvcs.w3.org/hg/html-media/raw-file/d471a4412040/media-source/
   //     media-source.html#sourcebuffer-coded-frame-processing
   // 1. For each coded frame in the media segment run the following steps:
   for (StreamParser::BufferQueue::const_iterator frames_itr = frames.begin();
        frames_itr != frames.end(); ++frames_itr) {
     if (!ProcessFrame(*frames_itr, append_window_start, append_window_end,
                       timestamp_offset, new_media_segment)) {
+      FlushProcessedFrames();
       return false;
     }
   }
 
+  if (!FlushProcessedFrames())
+    return false;
+
   // 2. - 4. Are handled by the WebMediaPlayer / Pipeline / Media Element.
 
   // Step 5:
   update_duration_cb_.Run(group_end_timestamp_);
 
   return true;
 }
 
 void FrameProcessor::SetGroupStartTimestampIfInSequenceMode(
     base::TimeDelta timestamp_offset) {
@@ skipping 74 matching lines @@
     base::TimeDelta 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() {
+  DVLOG(2) << __FUNCTION__ << "()";
+
+  bool result = true;
+  for (TrackBufferMap::iterator itr = track_buffers_.begin();
+       itr != track_buffers_.end();
+       ++itr) {
+    result &= itr->second->FlushProcessedFrames();

[damienv1, 2014/07/09 01:56:56]

Notation might be confusing here.
I would rather do sth like:

if (!itr->second->FlushProcessedFrames())
  result = false;

Had you written: result = result && itr->second->FlushProcessedFrames();
then FlushProcessedFrames would not have been called for each stream (if
flushing fails for the first stream).

[wolenetz, 2014/07/09 18:23:29]

Done. Note, as you very probably know, C++ &= and |= are not short-circuiting.
There are also no ||= or &&= in C++ (which would probably short-circuit if they
did exist). We use &= and |= in many places -- when masking or setting up flags,
for instance. However, I'll make this explicit as you suggest to prevent
confusion here.

+  }
+
+  return result;
+}
+
 bool FrameProcessor::HandlePartialAppendWindowTrimming(
     base::TimeDelta append_window_start,
     base::TimeDelta append_window_end,
     const scoped_refptr<StreamParserBuffer>& buffer) {
   DCHECK(buffer->duration() > base::TimeDelta());
   DCHECK_EQ(DemuxerStream::AUDIO, buffer->type());
 
   const base::TimeDelta frame_end_timestamp =
       buffer->timestamp() + buffer->duration();
 
@@ skipping 304 matching lines @@
       }
 
       // 12.2. Set the need random access point flag on track buffer to false.
       track_buffer->set_needs_random_access_point(false);
     }
 
     // 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;
       NotifyNewMediaSegmentStarting(decode_timestamp);
     }
 
     DVLOG(3) << __FUNCTION__ << ": Sending processed frame to stream, "
              << "PTS=" << presentation_timestamp.InSecondsF()
              << ", DTS=" << decode_timestamp.InSecondsF();
 
-    // Steps 13-18:
-    // TODO(wolenetz): Collect and emit more than one buffer at a time, if
-    // possible. Also refactor SourceBufferStream to conform to spec GC timing.
+    // 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().
+    // TODO(wolenetz): Refactor SourceBufferStream to conform to spec GC timing.
     // See http://crbug.com/371197.
-    StreamParser::BufferQueue buffer_to_append;
-    buffer_to_append.push_back(frame);
-    if (!track_buffer->stream()->Append(buffer_to_append)) {
-      DVLOG(3) << __FUNCTION__ << ": Failure appending frame to stream";
-      return false;
-    }
+    track_buffer->EnqueueProcessedFrame(frame);
 
     // 19. Set last decode timestamp for track buffer to decode timestamp.
     track_buffer->set_last_decode_timestamp(decode_timestamp);
 
     // 20. Set last frame duration for track buffer to frame duration.
     track_buffer->set_last_frame_duration(frame_duration);
 
     // 21. If highest presentation timestamp for track buffer is unset or frame
     //     end timestamp is greater than highest presentation timestamp, then
     //     set highest presentation timestamp for track buffer to frame end
     //     timestamp.
     track_buffer->SetHighestPresentationTimestampIfIncreased(
         frame_end_timestamp);
 
     // 22. If frame end timestamp is greater than group end timestamp, then set
     //     group end timestamp equal to frame end timestamp.
     if (frame_end_timestamp > group_end_timestamp_)
       group_end_timestamp_ = frame_end_timestamp;
     DCHECK(group_end_timestamp_ >= base::TimeDelta());
 
     return true;
   }
 
   NOTREACHED();
   return false;
 }
 
 }  // namespace media