media: Increase max number of decode threads for VP9 decodes at higher resolutions.

media/filters/vpx_video_decoder.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/vpx_video_decoder.h"
 
 #include <algorithm>
 #include <string>
 
 #include "base/bind.h"
@@ skipping 24 matching lines @@
 
 namespace media {
 
 // Always try to use three threads for video decoding.  There is little reason
 // not to since current day CPUs tend to be multi-core and we measured
 // performance benefits on older machines such as P4s with hyperthreading.
 static const int kDecodeThreads = 2;
 static const int kMaxDecodeThreads = 16;
 
 // Returns the number of threads.
-static int GetThreadCount() {
-  // TODO(scherkus): De-duplicate this function and the one used by
-  // FFmpegVideoDecoder.
-
+static int GetThreadCount(const VideoDecoderConfig& config) {
   // Refer to http://crbug.com/93932 for tsan suppressions on decoding.
   int decode_threads = kDecodeThreads;
 
   const CommandLine* cmd_line = CommandLine::ForCurrentProcess();
   std::string threads(cmd_line->GetSwitchValueASCII(switches::kVideoThreads));
-  if (threads.empty() || !base::StringToInt(threads, &decode_threads))
+  if (threads.empty() || !base::StringToInt(threads, &decode_threads)) {
+    if (config.codec() == kCodecVP9) {
+      // For VP9 decode when using the default thread count, increase the number
+      // of decode threads to equal the maximum number of tiles possible for
+      // higher resolution streams.
+      if (config.coded_size().width() >= 2048)

[scherkus (not reviewing), 2013/11/04 20:30:54]

I don't know much about tiling, but do we need to take area (width * height)
into account?

To take an extreme example, what is the intended result if we're decoding a
2048x32 video?

+        decode_threads = 8;
+      else if (config.coded_size().width() >= 1024)
+        decode_threads = 4;
+    }
+
     return decode_threads;
+  }
 
   decode_threads = std::max(decode_threads, 0);
   decode_threads = std::min(decode_threads, kMaxDecodeThreads);
   return decode_threads;
 }
 
 VpxVideoDecoder::VpxVideoDecoder(
     const scoped_refptr<base::MessageLoopProxy>& message_loop)
     : message_loop_(message_loop),
       weak_factory_(this),
@@ skipping 27 matching lines @@
   state_ = kNormal;
   status_cb.Run(PIPELINE_OK);
 }
 
 static vpx_codec_ctx* InitializeVpxContext(vpx_codec_ctx* context,
                                            const VideoDecoderConfig& config) {
   context = new vpx_codec_ctx();
   vpx_codec_dec_cfg_t vpx_config = {0};
   vpx_config.w = config.coded_size().width();
   vpx_config.h = config.coded_size().height();
-  vpx_config.threads = GetThreadCount();
+  vpx_config.threads = GetThreadCount(config);
 
   vpx_codec_err_t status = vpx_codec_dec_init(context,
                                               config.codec() == kCodecVP9 ?
                                                   vpx_codec_vp9_dx() :
                                                   vpx_codec_vp8_dx(),
                                               &vpx_config,
                                               0);
   if (status != VPX_CODEC_OK) {
     LOG(ERROR) << "vpx_codec_dec_init failed, status=" << status;
     delete context;
@@ skipping 248 matching lines @@
         vpx_image->stride[VPX_PLANE_Y], vpx_image->d_h, video_frame->get());
     return;
   }
   CopyAPlane(vpx_image_alpha->planes[VPX_PLANE_Y],
              vpx_image->stride[VPX_PLANE_Y],
              vpx_image->d_h,
              video_frame->get());
 }
 
 }  // namespace media