media: Only add more threads for codecs that benefit from it

media/filters/ffmpeg_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/ffmpeg_video_decoder.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <algorithm>
@@ skipping 32 matching lines @@
 
 // Returns the number of threads given the FFmpeg CodecID. Also inspects the
 // command line for a valid --video-threads flag.
 static int GetThreadCount(const VideoDecoderConfig& config) {
   // Refer to http://crbug.com/93932 for tsan suppressions on decoding.
   int decode_threads = kDecodeThreads;
 
   const base::CommandLine* cmd_line = base::CommandLine::ForCurrentProcess();
   std::string threads(cmd_line->GetSwitchValueASCII(switches::kVideoThreads));
   if (threads.empty() || !base::StringToInt(threads, &decode_threads)) {
-    // Normalize to three threads for 1080p content, then scale linearly
-    // with number of pixels.
-    // Examples:
-    // 4k: 12 threads
-    // 1440p: 5 threads
-    // 1080p: 3 threads
-    // anything lower than 1080p: 2 threads
-    decode_threads = config.coded_size().width() *
-                     config.coded_size().height() * 3 / 1920 / 1080;
+    // Some ffmpeg codecs don't actually benefit from using more threads.
+    // Only add more threads for those codecs that we know will benefit.
+    switch (config.codec()) {
+      case kUnknownVideoCodec:
+      case kCodecVC1:
+      case kCodecMPEG2:
+      case kCodecHEVC:
+      case kCodecVP9:
+        NOTREACHED();

[DaleCurtis, 2016/10/31 22:26:49]

Actually, sorry we should drop the NOTREACHED(). In the event of an error
condition GpuVideoDecoder/VpxVideoDecoder will fall through to
FFmpegVideoDecoder with some of these codecs, this shouldn't DCHECK() in that
case. I would still keep this block separate from kCodecTheora though with a
comment that these codecs are not supported by ffmpeg.

[hubbe, 2016/10/31 22:36:35]

Done.

+        break;
 
-    int cores = base::SysInfo::NumberOfProcessors();
-    // Leave two execution contexts for other things to run.
-    decode_threads = std::min(decode_threads, cores - 2);
-    // Use at least two threads, or ffmpeg will decode on the calling thread.
-    decode_threads = std::max(decode_threads, kDecodeThreads);
+      case kCodecTheora:
+        // No extra threads for these codecs.
+        break;
+
+      case kCodecH264:
+      case kCodecMPEG4:
+      case kCodecVP8:
+        // Normalize to three threads for 1080p content, then scale linearly
+        // with number of pixels.
+        // Examples:
+        // 4k: 12 threads
+        // 1440p: 5 threads
+        // 1080p: 3 threads
+        // anything lower than 1080p: 2 threads
+        decode_threads = config.coded_size().width() *
+                         config.coded_size().height() * 3 / 1920 / 1080;
+
+        int cores = base::SysInfo::NumberOfProcessors();
+        // Leave two execution contexts for other things to run.
+        decode_threads = std::min(decode_threads, cores - 2);
+        // Use at least two threads, or ffmpeg will decode on the calling
+        // thread.
+        decode_threads = std::max(decode_threads, kDecodeThreads);
+    }
   }
 
   decode_threads = std::max(decode_threads, 0);
   decode_threads = std::min(decode_threads, kMaxDecodeThreads);
   return decode_threads;
 }
 
 static int GetVideoBufferImpl(struct AVCodecContext* s,
                               AVFrame* frame,
                               int flags) {
@@ skipping 328 matching lines @@
   if (!codec || avcodec_open2(codec_context_.get(), codec, NULL) < 0) {
     ReleaseFFmpegResources();
     return false;
   }
 
   av_frame_.reset(av_frame_alloc());
   return true;
 }
 
 }  // namespace media