Merge 279817 "Don't crash on splice frame failure with bad content."

media/base/audio_splicer.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/base/audio_splicer.h"
 
 #include <cstdlib>
 #include <deque>
 
 #include "base/logging.h"
 #include "media/base/audio_buffer.h"
 #include "media/base/audio_bus.h"
 #include "media/base/audio_decoder_config.h"
 #include "media/base/audio_timestamp_helper.h"
 #include "media/base/vector_math.h"
 
 namespace media {
 
-// Largest gap or overlap allowed by this class. Anything
-// larger than this will trigger an error.
-// This is an arbitrary value, but the initial selection of 50ms
-// roughly represents the duration of 2 compressed AAC or MP3 frames.
-static const int kMaxTimeDeltaInMilliseconds = 50;
-
 // Minimum gap size needed before the splicer will take action to
 // fill a gap. This avoids periodically inserting and then dropping samples
 // when the buffer timestamps are slightly off because of timestamp rounding
 // in the source content. Unit is frames.
 static const int kMinGapSize = 2;
 
 // AudioBuffer::TrimStart() is not as accurate as the timestamp helper, so
 // manually adjust the duration and timestamp after trimming.
 static void AccurateTrimStart(int frames_to_trim,
                               const scoped_refptr<AudioBuffer> buffer,
@@ skipping 101 matching lines @@
   if (output_timestamp_helper_.base_timestamp() > input->timestamp()) {
     DVLOG(1) << "Input timestamp is before the base timestamp.";
     return false;
   }
 
   const base::TimeDelta timestamp = input->timestamp();
   const base::TimeDelta expected_timestamp =
       output_timestamp_helper_.GetTimestamp();
   const base::TimeDelta delta = timestamp - expected_timestamp;
 
-  if (std::abs(delta.InMilliseconds()) > kMaxTimeDeltaInMilliseconds) {
+  if (std::abs(delta.InMilliseconds()) >
+      AudioSplicer::kMaxTimeDeltaInMilliseconds) {
     DVLOG(1) << "Timestamp delta too large: " << delta.InMicroseconds() << "us";
     return false;
   }
 
   int frames_to_fill = 0;
   if (delta != base::TimeDelta())
     frames_to_fill = output_timestamp_helper_.GetFramesToTarget(timestamp);
 
   if (frames_to_fill == 0 || std::abs(frames_to_fill) < kMinGapSize) {
     AddOutputBuffer(input);
@@ skipping 146 matching lines @@
     output_sanitizer_->ResetTimestampState(
         0, pre_splice_sanitizer_->timestamp_helper().base_timestamp());
   }
 
   // If a splice frame was incorrectly marked due to poor demuxed timestamps, we
   // may not actually have a splice.  Here we check if any frames exist before
   // the splice.  In this case, just transfer all data to the output sanitizer.
   if (pre_splice_sanitizer_->GetFrameCount() <=
       output_ts_helper.GetFramesToTarget(splice_timestamp_)) {
     CHECK(pre_splice_sanitizer_->DrainInto(output_sanitizer_.get()));
-    CHECK(post_splice_sanitizer_->DrainInto(output_sanitizer_.get()));
+
+    // If the file contains incorrectly muxed timestamps, there may be huge gaps
+    // between the demuxed and decoded timestamps.
+    if (!post_splice_sanitizer_->DrainInto(output_sanitizer_.get()))
+      return false;
+
     reset_splice_timestamps();
     return true;
   }
 
   // Wait until we have enough data to crossfade or end of stream.
   if (!input->end_of_stream() &&
       input->timestamp() + input->duration() < max_splice_end_timestamp_) {
     return true;
   }
 
@@ skipping 174 matching lines @@
     AccurateTrimStart(frames_to_trim, remainder, output_ts_helper);
     CHECK(output_sanitizer_->AddInput(remainder));
   }
 
   // Transfer all remaining buffers out and reset once empty.
   CHECK(post_splice_sanitizer_->DrainInto(output_sanitizer_.get()));
   post_splice_sanitizer_->Reset();
 }
 
 }  // namespace media