media: Increase preloading and max buffer for high-bitrate videos

media/blink/multibuffer_data_source.cc

 // Copyright 2013 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/blink/multibuffer_data_source.h"
 
 #include <utility>
 
 #include "base/bind.h"
 #include "base/callback_helpers.h"
 #include "base/location.h"
 #include "base/macros.h"
 #include "base/single_thread_task_runner.h"
 #include "media/base/media_log.h"
 #include "media/blink/buffered_data_source_host_impl.h"
 #include "media/blink/multibuffer_reader.h"
 #include "net/base/net_errors.h"
 
 using blink::WebFrame;
 
 namespace {
 
 // Minimum preload buffer.
 const int64_t kMinBufferPreload = 2 << 20;  // 2 Mb
 // Maxmimum preload buffer.
-const int64_t kMaxBufferPreload = 20 << 20;  // 20 Mb
+const int64_t kMaxBufferPreload = 50 << 20;  // 50 Mb
 
 // Preload this much extra, then stop preloading until we fall below the
 // kTargetSecondsBufferedAhead.
 const int64_t kPreloadHighExtra = 1 << 20;  // 1 Mb
 
 // Total size of the pinned region in the cache.
+// Note that we go over this if preload is calculated high enough.
 const int64_t kMaxBufferSize = 25 << 20;  // 25 Mb
 
 // If bitrate is not known, use this.
 const int64_t kDefaultBitrate = 200 * 8 << 10;  // 200 Kbps.
 
 // Maximum bitrate for buffer calculations.
 const int64_t kMaxBitrate = 20 * 8 << 20;  // 20 Mbps.
 
 // Maximum playback rate for buffer calculations.
 const double kMaxPlaybackRate = 25.0;
@@ skipping 553 matching lines @@
 
   playback_rate = std::max(playback_rate, 1.0);
   playback_rate = std::min(playback_rate, kMaxPlaybackRate);
 
   int64_t bytes_per_second = (bitrate / 8.0) * playback_rate;
 
   int64_t preload = clamp(kTargetSecondsBufferedAhead * bytes_per_second,
                           kMinBufferPreload, kMaxBufferPreload);
   int64_t preload_high = preload + kPreloadHighExtra;
 
-  // Assert that kMaxBufferSize is big enough that the subtraction on the next
-  // line cannot go negative.
-  static_assert(kMaxBufferSize > kMaxBufferPreload + kPreloadHighExtra,
-                "kMaxBufferSize too small to contain preload.");
-  int64_t back_buffer = clamp(kTargetSecondsBufferedBehind * bytes_per_second,
-                              kMinBufferPreload, kMaxBufferSize - preload_high);
+  // Make sure that kMaxBufferSize is big enough that the subtraction on the
+  // next line cannot go negative.
+  int64_t max_buffer_size =
+      std::max(kMaxBufferSize, kMaxBufferPreload + kPreloadHighExtra);

[watk, 2016/11/03 21:09:18]

Drive by: It's confusing to me that kMaxBufferSize is not the max buffer size
any more.

Also, this is std::max(20MB, 51MB)? So kMaxBufferSize seems unused now.

[hubbe, 2016/11/03 23:11:59]

You're right, and that's not how I wanted it to work.
I re-wrote this part a bit, got rid of some pinning behind the reading position
(if we want to save more data we should just increase buffer_size instead).
Wrote lots of comments and added tests.

+  int64_t back_buffer =
+      clamp(kTargetSecondsBufferedBehind * bytes_per_second, kMinBufferPreload,
+            max_buffer_size - preload_high);
   int64_t buffer_size =
       std::min((kTargetSecondsBufferedAhead + kTargetSecondsBufferedBehind) *
                    bytes_per_second,
-               kMaxBufferSize);
+               max_buffer_size);
   reader_->SetMaxBuffer(buffer_size);
   reader_->SetPinRange(back_buffer, kMaxBufferPreload + kPreloadHighExtra);
 
   if (preload_ == METADATA) {
     reader_->SetPreload(0, 0);
   } else {
     reader_->SetPreload(preload_high, preload);
   }
 }
 
 }  // namespace media