Fix media code to work with new ffmpeg.

media/tools/media_bench/media_bench.cc

-// Copyright (c) 2011 The Chromium Authors. All rights reserved.
+// 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.
 
 // 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 209 matching lines @@
     }
   }
 
   std::ostream* log_out = &std::cout;
 #if defined(ENABLE_WINDOWS_EXCEPTIONS)
   // Catch exceptions so this tool can be used in automated testing.
   __try {
 #endif
 
   // Register FFmpeg and attempt to open file.
-  avcodec_init();
   av_log_set_level(verbose_level);
   av_register_all();
   av_register_protocol2(&kFFmpegFileProtocol, sizeof(kFFmpegFileProtocol));
   AVFormatContext* format_context = NULL;
-  // av_open_input_file wants a char*, which can't work with wide paths.
+  // avformat_open_input() wants a char*, which can't work with wide paths.
   // So we assume ASCII on Windows.  On other platforms we can pass the
   // 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);
+  int result = avformat_open_input(&format_context, string_path.c_str(),
+                                   NULL, NULL);
   if (result < 0) {
     switch (result) {
       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;
@@ skipping 16 matching lines @@
       output = file_util::OpenFile(out_path, "wb");
     }
     if (!output) {
       std::cerr << "Error: Could not open output "
                 << out_path.value() << std::endl;
       return 1;
     }
   }
 
   // Parse a little bit of the stream to fill out the format context.
-  if (av_find_stream_info(format_context) < 0) {
+  if (avformat_find_stream_info(format_context, NULL) < 0) {
     std::cerr << "Error: Could not find stream info for "
               << in_path.value() << std::endl;
     return 1;
   }
 
   // Find our target stream.
   int target_stream = -1;
   for (size_t i = 0; i < format_context->nb_streams; ++i) {
     AVCodecContext* codec_context = format_context->streams[i]->codec;
     AVCodec* codec = avcodec_find_decoder(codec_context->codec_id);
@@ skipping 41 matching lines @@
   } else if (skip == 3) {
     codec_context->skip_loop_filter = AVDISCARD_ALL;
     codec_context->skip_frame = AVDISCARD_NONREF;
   }
   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;
+    codec_context->err_recognition = AV_EF_CAREFUL;
   }
 
   // Initialize threaded decode.
   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) {
+  if (avcodec_open2(codec_context, codec, NULL) < 0) {
     std::cerr << "Error: Could not open codec "
               << (codec_context->codec ? codec_context->codec->name : "(NULL)")
               << " for " << in_path.value() << std::endl;
     return 1;
   }
 
   // Buffer used for audio decoding.
   scoped_ptr_malloc<int16, media::ScopedPtrAVFree> samples(
       reinterpret_cast<int16*>(av_malloc(AVCODEC_MAX_AUDIO_FRAME_SIZE)));
 
@@ skipping 162 matching lines @@
   } while (read_result >= 0);
   base::TimeDelta total = base::TimeTicks::HighResNow() - start;
   LeaveTimingSection();
 
   // Clean up.
   if (output)
     file_util::CloseFile(output);
   if (codec_context)
     avcodec_close(codec_context);
   if (format_context)
-    av_close_input_file(format_context);
+    avformat_close_input(&format_context);
 
   // Calculate the sum of times.  Note that some of these may be zero.
   double sum = 0;
   for (size_t i = 0; i < decode_times.size(); ++i) {
     sum += decode_times[i];
   }
 
   double average = 0;
   double stddev = 0;
   double fps = 0;
@@ skipping 47 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;
 }