Add gapless playback support for AAC playback.

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 "base/stl_util.h"
 #include "media/base/buffers.h"
 #include "media/base/stream_parser_buffer.h"
 
@@ skipping 57 matching lines @@
   }
 
   // 2. - 4. Are handled by the WebMediaPlayer / Pipeline / Media Element.
 
   // Step 5:
   update_duration_cb_.Run(group_end_timestamp_);
 
   return true;
 }
 
-bool FrameProcessor::ProcessFrame(scoped_refptr<StreamParserBuffer> frame,
-                                  base::TimeDelta append_window_start,
-                                  base::TimeDelta append_window_end,
-                                  base::TimeDelta* timestamp_offset,
-                                  bool* new_media_segment) {
+bool FrameProcessor::ProcessFrame(
+    const scoped_refptr<StreamParserBuffer>& frame,
+    base::TimeDelta append_window_start,
+    base::TimeDelta append_window_end,
+    base::TimeDelta* timestamp_offset,
+    bool* new_media_segment) {
   // Implements the loop within step 1 of the coded frame processing algorithm
   // for a single input 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
 
   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
@@ skipping 163 matching lines @@
 
     // 10.  If presentation timestamp is less than appendWindowStart, then set
     //      the need random access point flag to true, drop the coded frame, and
     //      jump to the top of the loop to start processing the next coded
     //      frame.
     // Note: We keep the result of partial discard of a buffer that overlaps
     //      |append_window_start| and does not end after |append_window_end|.
     // 11. If frame end timestamp is greater than appendWindowEnd, then set the
     //     need random access point flag to true, drop the coded frame, and jump
     //     to the top of the loop to start processing the next coded frame.
-    if (presentation_timestamp < append_window_start ||
-        frame_end_timestamp > append_window_end) {
-      // See if a partial discard can be done around |append_window_start|.
-      // TODO(wolenetz): Refactor this into a base helper across legacy and
-      // new frame processors?
-      if (track_buffer->stream()->supports_partial_append_window_trimming() &&
-          presentation_timestamp < append_window_start &&
-          frame_end_timestamp > append_window_start &&
-          frame_end_timestamp <= append_window_end) {
-        DCHECK(frame->IsKeyframe());
-        DVLOG(1) << "Truncating buffer which overlaps append window start."
-                 << " presentation_timestamp "
-                 << presentation_timestamp.InSecondsF()
-                 << " append_window_start " << append_window_start.InSecondsF();
+    if (track_buffer->stream()->supports_partial_append_window_trimming() &&
+        HandlePartialAppendWindowTrimming(append_window_start,
+                                          append_window_end,
+                                          presentation_timestamp,
+                                          frame_end_timestamp,
+                                          frame)) {
+      // |frame| has been partially trimmed or had preroll added.

[wolenetz, 2014/05/23 19:59:45]

ditto of LegacyFrameProcessor comment: do the following here, too?
track_buffer->set_needs_random_access_point(true);
if (!sequence_mode_)
  *new_media_segment = true;

[DaleCurtis, 2014/05/23 21:46:26]

Blew out the else from below. Should be fine now?

+      decode_timestamp = frame->GetDecodeTimestamp();
+      presentation_timestamp = frame->timestamp();
+      frame_duration = frame->duration();

[acolwell GONE FROM CHROMIUM, 2014/05/23 17:27:30]

Since presentation_timestamp & frame_duration are being updated here, does
frame_end_timestamp need to be recomputed?

[DaleCurtis, 2014/05/23 21:46:26]

No, since the timestamp is moved forward by a value equal to that by which the
duration is shrunk.

[acolwell GONE FROM CHROMIUM, 2014/05/24 00:58:20]

ok. A comment or DCHECK here would be nice so that this is clear.

[DaleCurtis, 2014/05/27 23:59:32]

Done.

+    } else if (presentation_timestamp < append_window_start ||

[acolwell GONE FROM CHROMIUM, 2014/05/23 17:27:30]

I wonder if we should drop the else here. ISTM that if the partial code above
does its job right, then it should not trigger the code in this block to run.
That would at least make it easier to see that the partial code can't
accidentally violate what the spec requires.

[wolenetz, 2014/05/23 19:59:45]

Good point: I think that would address my
*new_media_segment/set_needs_random_access_point comments, too.

[DaleCurtis, 2014/05/23 21:46:26]

Seems reasonable.  Done.

+               frame_end_timestamp > append_window_end) {
+      track_buffer->set_needs_random_access_point(true);
+      DVLOG(3) << "Dropping frame that is outside append window.";
 
-        // Adjust the timestamp of this frame forward to |append_window_start|,
-        // while decreasing the duration appropriately.
-        frame->set_discard_padding(std::make_pair(
-            append_window_start - presentation_timestamp, base::TimeDelta()));
-        presentation_timestamp = append_window_start;  // |frame| updated below.
-        decode_timestamp = append_window_start;  // |frame| updated below.
-        frame_duration = frame_end_timestamp - presentation_timestamp;
-        frame->set_duration(frame_duration);
+      if (!sequence_mode_) {
+        // This also triggers a discontinuity so we need to treat the next
+        // frames appended within the append window as if they were the
+        // beginning of a new segment.
+        *new_media_segment = true;
+      }
 
-        // TODO(dalecurtis): This could also be done with |append_window_end|,
-        // but is not necessary since splice frames covert the overlap there.
-      } else {
-        track_buffer->set_needs_random_access_point(true);
-        DVLOG(3) << "Dropping frame that is outside append window.";
-
-        if (!sequence_mode_) {
-          // This also triggers a discontinuity so we need to treat the next
-          // frames appended within the append window as if they were the
-          // beginning of a new segment.
-          *new_media_segment = true;
-        }
-
-        return true;
-      }
+      return true;
     }
 
     // 12. If the need random access point flag on track buffer equals true,
     //     then run the following steps:
     if (track_buffer->needs_random_access_point()) {
       // 12.1. If the coded frame is not a random access point, then drop the
       //       coded frame and jump to the top of the loop to start processing
       //       the next coded frame.
       if (!frame->IsKeyframe()) {
         DVLOG(3) << __FUNCTION__
@@ skipping 54 matching lines @@
 }
 
 void FrameProcessor::SetAllTrackBuffersNeedRandomAccessPoint() {
   for (TrackBufferMap::iterator itr = track_buffers_.begin();
        itr != track_buffers_.end(); ++itr) {
     itr->second->set_needs_random_access_point(true);
   }
 }
 
 }  // namespace media