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.

[DaleCurtis, 2016/10/31 21:26:33]

vp8 should benefit? I'd just exclude THEORA?

[hubbe, 2016/10/31 22:01:49]

Replaced the if statement with a switch to remind people in the future to add
new codecs here.

Added VP8/9 to the list that benefit from more threads.
From looking at the ffmpeg code, it seems like VP1 doesn't support threads, so I
left it off the list.

+    // Only add more threads for those codecs that we know will benefit.
+    if (config.codec() == kCodecH264 || config.codec() == kCodecMPEG4 ||
+        config.codec() == kCodecHEVC || config.codec() == kCodecMPEG2) {
+      // 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);
+      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