ffmpeg chromium glue

media/tools/media_bench/media_bench.cc

-// Copyright (c) 2010 The Chromium Authors. All rights reserved.
+// Copyright (c) 2011 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.
 
 // Standalone benchmarking application based on FFmpeg.  This tool is used to
 // measure decoding performance between different FFmpeg compile and run-time
 // options.  We also use this tool to measure performance regressions when
 // testing newer builds of FFmpeg from trunk.
 
 #include "build/build_config.h"
 
@@ skipping 113 matching lines @@
   if (media::InitializeMediaLibrary(FilePath()) == false) {
     std::cerr << "Unable to initialize the media library.";
     return 1;
   }
 
   // Retrieve command line options.
   FilePath in_path(filenames[0]);
   FilePath out_path;
   if (filenames.size() > 1)
     out_path = FilePath(filenames[1]);
-  CodecType target_codec = CODEC_TYPE_UNKNOWN;
+  AVMediaType target_codec = AVMEDIA_TYPE_UNKNOWN;
 
   // Determine whether to benchmark audio or video decoding.
   std::string stream(cmd_line->GetSwitchValueASCII(switches::kStream));
   if (!stream.empty()) {
     if (stream.compare("audio") == 0) {
-      target_codec = CODEC_TYPE_AUDIO;
+      target_codec = AVMEDIA_TYPE_AUDIO;
     } else if (stream.compare("video") == 0) {
-      target_codec = CODEC_TYPE_VIDEO;
+      target_codec = AVMEDIA_TYPE_VIDEO;
     } else {
       std::cerr << "Unknown --stream option " << stream << std::endl;
       return 1;
     }
   }
 
   // Determine number of threads to use for video decoding (optional).
   int video_threads = 0;
   std::string threads(cmd_line->GetSwitchValueASCII(switches::kVideoThreads));
   if (!threads.empty() &&
@@ skipping 78 matching lines @@
   // path bytes through verbatim.
 #if defined(OS_WIN)
   std::string string_path = WideToASCII(in_path.value());
 #else
   const std::string& string_path = in_path.value();
 #endif
   int result = av_open_input_file(&format_context, string_path.c_str(),
                                   NULL, 0, NULL);
   if (result < 0) {
     switch (result) {
-      case AVERROR_NOFMT:
+      case AVERROR(EINVAL):
         std::cerr << "Error: File format not supported "
                   << in_path.value() << std::endl;
         break;
       default:
         std::cerr << "Error: Could not open input for "
                   << in_path.value() << std::endl;
         break;
     }
     return 1;
   }
@@ skipping 33 matching lines @@
     AVCodec* codec = avcodec_find_decoder(codec_context->codec_id);
 
     // See if we found our target codec.
     if (codec_context->codec_type == target_codec && target_stream < 0) {
       *log_out << "* ";
       target_stream = i;
     } else {
       *log_out << "  ";
     }
 
-    if (!codec || (codec_context->codec_type == CODEC_TYPE_UNKNOWN)) {
+    if (!codec || (codec_context->codec_type == AVMEDIA_TYPE_UNKNOWN)) {
       *log_out << "Stream #" << i << ": Unknown" << std::endl;
     } else {
       // Print out stream information
       *log_out << "Stream #" << i << ": " << codec->name << " ("
                << codec->long_name << ")" << std::endl;
     }
   }
 
   // Only continue if we found our target stream.
   if (target_stream < 0) {
@@ skipping 25 matching lines @@
   if (fast2) {
     // Note this flag is no longer necessary for H264 multithreading.
     codec_context->flags2 |= CODEC_FLAG2_FAST;
   }
   if (error_correction) {
     codec_context->error_concealment = FF_EC_GUESS_MVS | FF_EC_DEBLOCK;
     codec_context->error_recognition = FF_ER_CAREFUL;
   }
 
   // Initialize threaded decode.
-  if (target_codec == CODEC_TYPE_VIDEO && video_threads > 0) {
-    if (avcodec_thread_init(codec_context, video_threads) < 0) {
-      std::cerr << "Warning: Could not initialize threading!\n"
-                << "Did you build with pthread/w32thread support?" << std::endl;
-    }
+  if (target_codec == AVMEDIA_TYPE_VIDEO && video_threads > 0) {
+    codec_context->thread_count = video_threads;
   }
 
   // Initialize our codec.
   if (avcodec_open(codec_context, codec) < 0) {
     std::cerr << "Error: Could not open codec "
               << (codec_context->codec ? codec_context->codec->name : "(NULL)")
               << " for " << in_path.value() << std::endl;
     return 1;
   }
 
@@ skipping 38 matching lines @@
         packet.stream_index = target_stream;
         packet.size = 0;
       } else {
         break;
       }
     }
 
     // Only decode packets from our target stream.
     if (packet.stream_index == target_stream) {
       int result = -1;
-      if (target_codec == CODEC_TYPE_AUDIO) {
+      if (target_codec == AVMEDIA_TYPE_AUDIO) {
         int size_out = AVCODEC_MAX_AUDIO_FRAME_SIZE;
 
         base::TimeTicks decode_start = base::TimeTicks::HighResNow();
         result = avcodec_decode_audio3(codec_context, samples.get(), &size_out,
                                        &packet);
         base::TimeDelta delta = base::TimeTicks::HighResNow() - decode_start;
 
         if (size_out) {
           decode_times.push_back(delta.InMillisecondsF());
           ++frames;
@@ skipping 11 matching lines @@
 
           const uint8* u8_samples =
               reinterpret_cast<const uint8*>(samples.get());
           if (hash_djb2) {
             hash_value = DJB2Hash(u8_samples, size_out, hash_value);
           }
           if (hash_md5) {
             MD5Update(&ctx, u8_samples, size_out);
           }
         }
-      } else if (target_codec == CODEC_TYPE_VIDEO) {
+      } else if (target_codec == AVMEDIA_TYPE_VIDEO) {
         int got_picture = 0;
 
         base::TimeTicks decode_start = base::TimeTicks::HighResNow();
         result = avcodec_decode_video2(codec_context, frame.get(),
                                        &got_picture, &packet);
         base::TimeDelta delta = base::TimeTicks::HighResNow() - decode_start;
 
         if (got_picture) {
           decode_times.push_back(delta.InMillisecondsF());
           ++frames;
@@ skipping 138 matching lines @@
 #if defined(ENABLE_WINDOWS_EXCEPTIONS)
   } __except(EXCEPTION_EXECUTE_HANDLER) {
     *log_out << "  Exception:" << std::setw(11) << GetExceptionCode()
              << " " << in_path.value() << std::endl;
     return 1;
   }
 #endif
   CommandLine::Reset();
   return 0;
 }