Move key frame flag from StreamParserBuffer to DecoderBuffer

media/filters/source_buffer_stream.cc

 // Copyright (c) 2012 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/source_buffer_stream.h"
 
 #include <algorithm>
 #include <map>
 
 #include "base/bind.h"
@@ skipping 171 matching lines @@
   TRACE_EVENT2("media", "SourceBufferStream::Append",
                "stream type", GetStreamTypeName(),
                "buffers to append", buffers.size());
 
   DCHECK(!buffers.empty());
   DCHECK(media_segment_start_time_ != kNoDecodeTimestamp());
   DCHECK(media_segment_start_time_ <= buffers.front()->GetDecodeTimestamp());
   DCHECK(!end_of_stream_);
 
   // New media segments must begin with a keyframe.
-  if (new_media_segment_ && !buffers.front()->IsKeyframe()) {
-    MEDIA_LOG(log_cb_) << "Media segment did not begin with keyframe.";
+  if (new_media_segment_ && !buffers.front()->is_key_frame()) {
+    MEDIA_LOG(log_cb_) << "Media segment did not begin with key frame.";
     return false;
   }
 
   // Buffers within a media segment should be monotonically increasing.
   if (!IsMonotonicallyIncreasing(buffers))
     return false;
 
   if (media_segment_start_time_ < DecodeTimestamp() ||
       buffers.front()->GetDecodeTimestamp() < DecodeTimestamp()) {
     MEDIA_LOG(log_cb_)
         << "Cannot append a media segment with negative timestamps.";
     return false;
   }
 
   if (!IsNextTimestampValid(buffers.front()->GetDecodeTimestamp(),
-                            buffers.front()->IsKeyframe())) {
+                            buffers.front()->is_key_frame())) {
     MEDIA_LOG(log_cb_) << "Invalid same timestamp construct detected at time "
                        << buffers.front()->GetDecodeTimestamp().InSecondsF();
 
     return false;
   }
 
   UpdateMaxInterbufferDistance(buffers);
   SetConfigIds(buffers);
 
   // Save a snapshot of stream state before range modifications are made.
   DecodeTimestamp next_buffer_timestamp = GetNextBufferTimestamp();
   BufferQueue deleted_buffers;
 
   PrepareRangesForNextAppend(buffers, &deleted_buffers);
 
   // If there's a range for |buffers|, insert |buffers| accordingly. Otherwise,
   // create a new range with |buffers|.
   if (range_for_next_append_ != ranges_.end()) {
     (*range_for_next_append_)->AppendBuffersToEnd(buffers);
     last_appended_buffer_timestamp_ = buffers.back()->GetDecodeTimestamp();
-    last_appended_buffer_is_keyframe_ = buffers.back()->IsKeyframe();
+    last_appended_buffer_is_keyframe_ = buffers.back()->is_key_frame();
   } else {
     DecodeTimestamp new_range_start_time = std::min(
         media_segment_start_time_, buffers.front()->GetDecodeTimestamp());
     const BufferQueue* buffers_for_new_range = &buffers;
     BufferQueue trimmed_buffers;
 
     // If the new range is not being created because of a new media
-    // segment, then we must make sure that we start with a keyframe.
+    // segment, then we must make sure that we start with a key frame.
     // This can happen if the GOP in the previous append gets destroyed
     // by a Remove() call.
     if (!new_media_segment_) {
       BufferQueue::const_iterator itr = buffers.begin();
 
-      // Scan past all the non-keyframes.
-      while (itr != buffers.end() && !(*itr)->IsKeyframe()) {
+      // Scan past all the non-key-frames.
+      while (itr != buffers.end() && !(*itr)->is_key_frame()) {
         ++itr;
       }
 
-      // If we didn't find a keyframe, then update the last appended
+      // If we didn't find a key frame, then update the last appended
       // buffer state and return.
       if (itr == buffers.end()) {
         last_appended_buffer_timestamp_ = buffers.back()->GetDecodeTimestamp();
-        last_appended_buffer_is_keyframe_ = buffers.back()->IsKeyframe();
+        last_appended_buffer_is_keyframe_ = buffers.back()->is_key_frame();
         return true;
       } else if (itr != buffers.begin()) {
-        // Copy the first keyframe and everything after it into
+        // Copy the first key frame and everything after it into
         // |trimmed_buffers|.
         trimmed_buffers.assign(itr, buffers.end());
         buffers_for_new_range = &trimmed_buffers;
       }
 
       new_range_start_time =
           buffers_for_new_range->front()->GetDecodeTimestamp();
     }
 
     range_for_next_append_ =
         AddToRanges(new SourceBufferRange(
             TypeToGapPolicy(GetType()),
             *buffers_for_new_range, new_range_start_time,
             base::Bind(&SourceBufferStream::GetMaxInterbufferDistance,
                        base::Unretained(this))));
     last_appended_buffer_timestamp_ =
         buffers_for_new_range->back()->GetDecodeTimestamp();
     last_appended_buffer_is_keyframe_ =
-        buffers_for_new_range->back()->IsKeyframe();
+        buffers_for_new_range->back()->is_key_frame();
   }
 
   new_media_segment_ = false;
 
   MergeWithAdjacentRangeIfNecessary(range_for_next_append_);
 
   // Seek to try to fulfill a previous call to Seek().
   if (seek_pending_) {
     DCHECK(!selected_range_);
     DCHECK(deleted_buffers.empty());
@@ skipping 163 matching lines @@
 }
 
 bool SourceBufferStream::IsMonotonicallyIncreasing(
     const BufferQueue& buffers) const {
   DCHECK(!buffers.empty());
   DecodeTimestamp prev_timestamp = last_appended_buffer_timestamp_;
   bool prev_is_keyframe = last_appended_buffer_is_keyframe_;
   for (BufferQueue::const_iterator itr = buffers.begin();
        itr != buffers.end(); ++itr) {
     DecodeTimestamp current_timestamp = (*itr)->GetDecodeTimestamp();
-    bool current_is_keyframe = (*itr)->IsKeyframe();
+    bool current_is_keyframe = (*itr)->is_key_frame();
     DCHECK(current_timestamp != kNoDecodeTimestamp());
     DCHECK((*itr)->duration() >= base::TimeDelta())
         << "Packet with invalid duration."
         << " pts " << (*itr)->timestamp().InSecondsF()
         << " dts " << (*itr)->GetDecodeTimestamp().InSecondsF()
         << " dur " << (*itr)->duration().InSecondsF();
 
     if (prev_timestamp != kNoDecodeTimestamp()) {
       if (current_timestamp < prev_timestamp) {
         MEDIA_LOG(log_cb_) << "Buffers were not monotonically increasing.";
@@ skipping 263 matching lines @@
 
   // Handle splices between the existing buffers and the new buffers.  If a
   // splice is generated the timestamp and duration of the first buffer in
   // |new_buffers| will be modified.
   if (splice_frames_enabled_)
     GenerateSpliceFrame(new_buffers);
 
   DecodeTimestamp prev_timestamp = last_appended_buffer_timestamp_;
   bool prev_is_keyframe = last_appended_buffer_is_keyframe_;
   DecodeTimestamp next_timestamp = new_buffers.front()->GetDecodeTimestamp();
-  bool next_is_keyframe = new_buffers.front()->IsKeyframe();
+  bool next_is_keyframe = new_buffers.front()->is_key_frame();
 
   if (prev_timestamp != kNoDecodeTimestamp() &&
       prev_timestamp != next_timestamp) {
     // Clean up the old buffers between the last appended buffer and the
     // beginning of |new_buffers|.
     RemoveInternal(prev_timestamp, next_timestamp, true, deleted_buffers);
   }
 
   // Make the delete range exclusive if we are dealing with an allowed same
   // timestamp situation. This prevents the first buffer in the current append
@@ skipping 717 matching lines @@
     return false;
 
   DCHECK_NE(have_splice_buffers, have_preroll_buffer);
   splice_buffers_index_ = 0;
   pending_buffer_.swap(*out_buffer);
   pending_buffers_complete_ = false;
   return true;
 }
 
 }  // namespace media